@iris-ui-kit/react 0.2.3 → 0.3.1

package/dist/index.d.ts

@@ -1,12 +1,13 @@
 import * as _iris_ui_kit_core from '@iris-ui-kit/core';
-import { ReadonlyStore, Store, MachineEvent, Machine, MachineState, RealtimeHandlers, RealtimeOptions, RealtimeStatus, DisposableScope, ResilientFetcherOptions, ResilientFetcher, Variant, Size, Placement, SpreadsheetXmlOptions } from '@iris-ui-kit/core';
-export { AdminPreferences, AdminPreferencesState, Align, DataSourceConfig, DataSourceController, DataSourceMode, DataSourceMutateOptions, DataSourceQuery, DataSourceState, DataViewColumn, FloatingEvent, FloatingMachine, FloatingState, GroupedViewConfig, GroupedViewState, GroupedViewStore, IrisHsva, PageItem as IrisPageItem, IrisRgba, Machine, MachineConfig, MachineEvent, MachineState, MutateOptions, NavNode, Placement, ResourceController, ResourceControllerConfig, ResourceQuery, ResourceState, RowMutateOptions, Side, Size, StateNode, Store, TabItem, TabsNav, TabsNavConfig, TabsNavState, Transition, Variant, addDays, addMonths, buildMonthMatrix, clamp01, clampDate, composeEventHandlers, createAdminPreferences, createClientDataSource, createClientFetcher, createDataSource, createFloatingMachine, createGroupedView, createMachine, createResourceController, createStore, createTabsNav, endOfMonth, filterNavByAccess, findNavNode, findNavPath, firstLeaf, flattenNav, formatLocalISO, formatMonthYear, generateId, getPageRange, getWeekdayNames, hexToRgba, hsvToRgb, hsvaToRgba, isBranch, isClosable, isOutOfRange, isSameDay, isSameMonth, localStorageAdminPreferencesStorage, mergeProps, nodeAllowsRoles, rgbToHex, rgbToHsv, rgbaToHsva, startOfDay, startOfMonth, visibleNav } from '@iris-ui-kit/core';
+import { ReadonlyStore, Store, MachineEvent, Machine, MachineState, RealtimeHandlers, RealtimeOptions, RealtimeStatus, DisposableScope, ResilientFetcherOptions, ResilientFetcher, Variant, Size, Placement, AuditLogType, SpreadsheetXmlOptions, Virtualizer } from '@iris-ui-kit/core';
+export { AdminPreferences, AdminPreferencesState, Align, DataSourceConfig, DataSourceController, DataSourceMode, DataSourceMutateOptions, DataSourceQuery, DataSourceState, DataViewColumn, FloatingEvent, FloatingMachine, FloatingState, GroupedViewConfig, GroupedViewState, GroupedViewStore, IrisHsva, PageItem as IrisPageItem, IrisRgba, Machine, MachineConfig, MachineEvent, MachineState, MutateOptions, NavNode, Placement, ResourceController, ResourceControllerConfig, ResourceQuery, ResourceState, RowMutateOptions, Side, Size, StateNode, Store, TabItem, TabsNav, TabsNavConfig, TabsNavState, Transition, Variant, addDays, addMonths, buildMonthMatrix, clamp01, clampDate, composeEventHandlers, createAdminPreferences, createClientDataSource, createClientFetcher, createDataSource, createFloatingMachine, createGroupedView, createMachine, createResourceController, createStore, createTabsNav, endOfMonth, filterNavByAccess, findNavNode, findNavPath, firstLeaf, flattenNav, formatLocalISO, formatMonthYear, generateId, getPageRange, getWeekdayNames, hexToRgba, hsvToRgb, hsvaToRgba, isBranch, isClosable, isOutOfRange, isSameDay, isSameMonth, localStorageAdminPreferencesStorage, mergeProps, nodeAllowsRoles, parseCsv, rgbToHex, rgbToHsv, rgbaToHsva, startOfDay, startOfMonth, visibleNav } from '@iris-ui-kit/core';
+export { GridFilterColumn, GridFilterQuery, GridSortColumn, LegacyGridColumnsProps, LegacyGridExpansionProps, LegacyGridFilteringProps, LegacyGridPaginationProps, LegacyGridPaginationProxyConfig, LegacyGridPaginationState, LegacyGridRowsOptions, LegacyGridRowsProps, LegacyGridSelectionProps, LegacyGridSortingProps, UseGridClipboardOptions, UseGridClipboardResult, UseGridColumnsOptions, UseGridColumnsResult, UseGridCoreOptions, UseGridEditingOptions, UseGridEditingResult, UseGridExpansionOptions, UseGridExpansionResult, UseGridFilteringOptions, UseGridFilteringResult, UseGridPaginationOptions, UseGridPaginationResult, UseGridRangeOptions, UseGridRangeResult, UseGridRowsOptions, UseGridRowsResult, UseGridSelectionOptions, UseGridSelectionResult, UseGridSortingOptions, UseGridSortingResult, UseGridVirtualOptions, UseGridVirtualResult, toGridColumnsOptions, toGridExpansionOptions, toGridFilteringOptions, toGridPaginationOptions, toGridRowsOptions, toGridSelectionOptions, toGridSortingOptions, useGridClipboard, useGridColumns, useGridCore, useGridEditing, useGridExpansion, useGridFiltering, useGridPagination, useGridRange, useGridRows, useGridSelection, useGridSorting, useGridVirtual } from './grid.js';
 export { ThemeProvider, ThemeProviderProps, UseThemeReturn, useColorScheme, useDirection, useTheme, useThemeContext, useThemeOptional } from './theme.js';
 export { ApplySkinResult, LoadSkinOptions, ResolvedSkin, Skin, SkinBootScriptConfig, SkinCatalog, SkinCatalogConfig, SkinEngine, SkinEngineConfig, SkinError, SkinErrorCode, SkinLookup, SkinManifest, SkinManifestEntry, SkinMode, SkinPatch, SkinRegistry, SkinResolutionError, SkinStorage, SkinTokenOverrides, applySkin, builtinSkins, createSkinCatalog, createSkinEngine, createSkinRegistry, darkSkin, lightSkin, loadSkin, localStorageSkinStorage, memorySkinStorage, renderSkinStyle, resolveSkin, skinBootScript, skinError, skinToCssEntries, validateSkin } from '@iris-ui-kit/skins';
 export { SkinProvider, SkinProviderProps, UseSkinReturn, useSkin, useSkinContext, useSkinOptional } from './skins.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
-import { ButtonHTMLAttributes, ReactNode, CSSProperties, MouseEventHandler, MutableRefObject } from 'react';
+import { ButtonHTMLAttributes, ReactNode, CSSProperties, MouseEventHandler } from 'react';
 import { IrisIconRegistry } from '@iris-ui-kit/icons';
 export { CreateIconRegistryOptions, IrisIconNode, IrisIconRegistry, IrisIconResolver, IrisIconSet, RenderIconOptions, ThemeIconConfig, createIconRegistry, defaultIconRegistry, defaultIcons, renderIconSvg, resolveIcon, resolveThemedIcon } from '@iris-ui-kit/icons';
 export { FieldInputProps, FormContext, IrisForm, IrisFormProps, UseFieldArrayReturn, UseFieldReturn, UseFormReturn, useField, useFieldArray, useForm, useFormContext } from './form.js';
@@ -28,6 +29,7 @@ export { IrisProvider, IrisProviderProps, PluginStoreContext, PluginStoreContext
 export { IrisErrorBoundary, IrisErrorBoundaryFallbackProps, IrisErrorBoundaryProps } from './error-boundary.js';
 export { ApplyThemeResult, ThemeStore, ThemeStoreConfig, applyTheme, createThemeStore, getCssVar, toCssVarName } from '@iris-ui-kit/theme';
 export { ALL_TOKEN_NAMES, AnyToken, COLOR_TOKENS, ColorToken, IrisTheme, IrisThemeColors, IrisThemeRadii, IrisThemeSpacing, IrisThemeType, RADII_TOKENS, RadiusToken, SPACING_TOKENS, SpacingToken, darkTheme, lightTheme } from '@iris-ui-kit/tokens';
+import '@iris-ui-kit/core/grid';
 import '@floating-ui/dom';
 
 /**
@@ -2393,92 +2395,6 @@ interface IrisSelectProps<T = unknown> {
  */
 declare function IrisSelect<T = unknown>({ items, value: valueProp, defaultValue, onValueChange, multiple, placeholder, size, disabled, placement, invalid, id, ariaDescribedby, renderTrigger, style, className, virtual, ...rest }: IrisSelectProps<T>): React.ReactElement;
 
-type IrisTableSortDirection = 'asc' | 'desc';
-/** Map of column key → current width in px (after any resizing). */
-type IrisTableColumnWidths = Record<string, number>;
-type IrisTableEditor = 'text' | 'number' | 'select';
-/** Aggregation op for a column's summary/footer cell. */
-type IrisTableAggregateOp = 'sum' | 'avg' | 'min' | 'max' | 'count';
-interface IrisTableVirtualOptions {
-    /** Per-row height in px (uniform). */
-    itemHeight: number;
-    /** Viewport height. Number → px; string → CSS length. */
-    height: number | string;
-    /** Extra rows rendered above and below the viewport. */
-    buffer?: number;
-}
-interface IrisTableSortState {
-    key: string;
-    direction: IrisTableSortDirection;
-}
-/**
- * One search-form field (vxe-grid formConfig items parity). On submit the
- * field's value merges into the table filters under `key` (client-side path
- * or the proxy query); empty strings are inactive and stripped.
- */
-interface IrisTableFormField {
-    /** Filter key — matched against column keys and the query `filters` map. */
-    key: string;
-    /** Visible field label. */
-    label: string;
-    /** Control kind. Default `'text'`. */
-    type?: 'text' | 'select';
-    /** Options when `type: 'select'`. */
-    options?: Array<{
-        value: string;
-        label: string;
-    }>;
-    placeholder?: string;
-    /** Initial value; reset restores it. */
-    defaultValue?: string;
-}
-/** Params delivered to `IrisTableProps.proxyConfig.query` (vxe proxyConfig parity). */
-interface IrisTableProxyQueryParams {
-    /** 1-based page number. */
-    page: number;
-    pageSize: number;
-    sort: IrisTableSortState | null;
-    /**
-     * Multi-column sort (vxe sort-config.multiple parity), most-significant
-     * first. Present only in multiSort mode — single mode keeps passing `sort`.
-     */
-    sorts?: IrisTableSortState[];
-    filters: Record<string, string>;
-}
-/**
- * Edit-validation presentation (vxe-grid ValidConfig parity).
- */
-interface IrisTableValidConfig {
-    /**
-     * Render the inline editor error message (`data-iris-table-editor-error`).
-     * `false` still runs validation and blocks the commit — only the message
-     * element is skipped (`aria-invalid` stays). Default true.
-     */
-    showMessage?: boolean;
-}
-/** Params delivered to `IrisTableProps.seqMethod` (vxe seqMethod parity). */
-interface IrisTableSeqMethodParams {
-    rowIndex: number;
-    columnIndex: number;
-}
-/** Coordinates delivered to `IrisTableProps.onCellClick` (vxe cell-click parity). */
-interface IrisTableCellClickParams<Row = Record<string, unknown>> {
-    row: Row;
-    column: IrisTableColumn<Row>;
-    rowIndex: number;
-    columnIndex: number;
-}
-/**
- * Coordinates delivered to `IrisTableProps.contextMenu` callbacks (vxe
- * context-menu event params parity): the row/column under the cursor and its
- * grid position.
- */
-interface IrisTableContextMenuParams<Row = Record<string, unknown>> {
-    row: Row;
-    column: IrisTableColumn<Row>;
-    rowIndex: number;
-    columnIndex: number;
-}
 interface IrisTableColumn<Row = Record<string, unknown>> {
     key: string;
     title: string;
@@ -2488,6 +2404,18 @@ interface IrisTableColumn<Row = Record<string, unknown>> {
     titleSuffix?: React.ReactNode;
     /** Path inside the row to read the cell value from. Defaults to `key`. */
     dataIndex?: keyof Row | string;
+    /**
+     * Single-line cell formula (batch AO, iris 独有 — vxe has no computed
+     * columns; the closest is a display-only formatter). Evaluated by the core
+     * `evaluateFormula` parser against each row: field refs + `+ - * / %` +
+     * whitelist functions SUM/AVG/MIN/MAX/COUNT (case-insensitive), optional
+     * leading `=`. The COMPUTED value feeds every data consumer — cell render,
+     * sorting, filtering, grouping, summary, range stats, clipboard and CSV
+     * export. Errors / unknown fields → null (empty cell). An `editable`
+     * formula column is DISPLAY-ONLY: inline editing, row mode and batch edit
+     * ignore it. Overrides `dataIndex` / `sortBy`. Leading `=` optional.
+     */
+    formula?: string;
     sortable?: boolean;
     /** Sort by another field (vxe sort-by parity): the comparator reads this
      * field instead of the column's own value. */
@@ -2505,6 +2433,15 @@ interface IrisTableColumn<Row = Record<string, unknown>> {
      * the value is injected with `dangerouslySetInnerHTML`; ensure the content
      * is trusted to avoid XSS. */
     html?: boolean;
+    /** Render the cell value as a link (vxe... no direct parity, batch L): return
+     * `{ href, label?, target? }` or a plain href string; `null`/`undefined` falls
+     * through to the formatter/raw value. The anchor text is `label` when given,
+     * otherwise the formatted (or raw) text; `target: '_blank'` adds `rel="noreferrer"`. */
+    link?: (value: unknown, row: Row) => {
+        href: string;
+        label?: string;
+        target?: string;
+    } | string | null;
     width?: number | string;
     /** Minimum width (px) when resizing. Default 60. */
     minWidth?: number;
@@ -2517,6 +2454,47 @@ interface IrisTableColumn<Row = Record<string, unknown>> {
     editable?: boolean;
     /** Editor kind. Default `'text'`. */
     editor?: IrisTableEditor;
+    /**
+     * Lock this column's cells against editing (batch BE, iris 独有 — vxe has
+     * no cell-lock concept): `true` locks every cell of the column; a
+     * predicate receives the row (and column) and returns whether THAT cell is
+     * locked — a predicate ignoring its column argument is a row-level lock
+     * (both levels share this one field). Locked cells are not editable —
+     * every editing entry point no-ops (dblclick / click trigger / F2 / Tab
+     * nav / row mode / batch edit / paste / fill / range clear / FNR replace /
+     * Delete shortcut) — render with a striped background and
+     * `data-iris-cell-locked="true"`, and stay fully interactive for
+     * selection, copy and export.
+     */
+    locked?: boolean | ((row: Row, column: IrisTableColumn<Row>) => boolean);
+    /**
+     * Cell permission predicate (batch BJ, iris 独有 — vxe has no per-cell
+     * permission concept): return `'readonly'` to make THAT cell read-only
+     * through every editing entry point (dblclick / click trigger / F2 / Tab
+     * nav / row mode / batch edit / paste / fill / range clear / FNR replace /
+     * Delete shortcut); `'editable'` or absent → editable (default). DYNAMIC —
+     * re-evaluated on every render (unlike `locked`, which is a static
+     * declaration): permission follows the current row/column state without a
+     * re-mount. Readonly cells render with a dotted texture and
+     * `data-iris-cell-readonly="true"` (distinct from locked's 45° stripes),
+     * and stay fully interactive for selection, copy and export. When a cell is
+     * both locked and readonly, locked wins visually (stripes + not-allowed).
+     */
+    cellPermission?: (row: Row, column: IrisTableColumn<Row>) => 'readonly' | 'editable';
+    /** Batch AN column preset (iris 独有): fills display defaults from the core
+     * factory — `'money'` (2 decimals + thousands separator, right-aligned,
+     * number editor + numeric editRules), `'progress'` (percent text, right),
+     * `'date'` (String passthrough, left), `'status'` (UPPERCASE text, center).
+     * User fields always win over the preset defaults (defined-fields-only
+     * merge); localized formatting stays the caller's job. */
+    preset?: _iris_ui_kit_core.ColumnPreset;
+    /**
+     * Native datalist suggestions while editing (batch AM, iris 独有): `true`
+     * builds the option list from the DISTINCT cell values of this column over
+     * the current body data (String-coerced, null/'' excluded, sorted, capped at
+     * 50); an explicit array of `string | number` is used verbatim. Text editor
+     * only — the number/select/textarea editors ignore it. */
+    suggest?: boolean | Array<string | number>;
     /**
      * Options for the `'select'` editor (vxe edit-render options parity). A
      * column with `editor: 'select'` renders a native `<select>` while editing;
@@ -2562,6 +2540,302 @@ interface IrisTableColumn<Row = Record<string, unknown>> {
     sorter?: (a: Row, b: Row) => number;
     /** Custom render for cell content. */
     render?: (value: unknown, row: Row, rowIndex: number) => React.ReactNode;
+    /** Format a cell's value for display (vxe formatter parity, batch I). Applied AFTER
+     * `render`/`html` and BEFORE the raw value; sorting, filtering, editing and summary
+     * keep reading the RAW value. The tooltip defaults to the formatted text when it is
+     * a string. With `clipConfig.copyWithFormat` (batch CU, iris 独有) the range copy
+     * (Ctrl/Cmd+C / toolbar 复制) carries this formatted text instead of the raw value. */
+    formatter?: (value: unknown, row: Row) => React.ReactNode;
+    /** Mask this column's value for display (batch AY, iris 独有 — vxe has no
+     * built-in masking): `'sensitive'` applies the core `maskValue` sensitive
+     * rule (email → 11-digit phone → generic); a custom function receives the
+     * RAW cell value and returns the masked string. Applied FIRST in the
+     * display chain — `render`/`html`/`link`/`formatter`/tooltip all see the
+     * masked value (a `formatter` receives the masked STRING); inline editing,
+     * validation, sorting, filtering, summary, range stats and conditional
+     * styles keep reading the RAW value. Export/copy mask by default unless
+     * `exportRaw` is set. */
+    mask?: 'sensitive' | ((value: unknown) => string);
+    /** Export/copy the RAW value instead of the masked one (batch AY): when
+     * true, `exportCsv`/`exportCurrentViewCsv`/`exportSelectionCsv` and the
+     * clipboard TSV skip this column's mask. Display keeps masking. */
+    exportRaw?: boolean;
+    /**
+     * Render this numeric column's cells as a mini trend line (batch BI, iris
+     * 独有 — vxe has no sparkline): each cell shows a 20×8 SVG polyline of the
+     * column's values over `filteredData[0..i]` INCLUSIVE (the current value is
+     * the final point), so sorting/filtering reorder and trim the series.
+     * Only cells whose RAW value is a finite number render an SVG (non-numeric
+     * cells render nothing); series points coerce like `buildChartData`
+     * (null/non-finite → gap). Wins over `render`/`html`/`link`/`formatter`/
+     * raw; mask, editing, copy/export and summary stay untouched. The cell
+     * `title` shows the series ("10, 4, 8") instead of the tooltip.
+     */
+    sparkline?: boolean;
+    /** Show a header filter trigger + checkbox panel (vxe filterConfig parity, batch I).
+     * Filtering OR-matches the raw `String(value)` against the checked set. */
+    filterable?: boolean;
+    /** Checkbox options for the filter panel; a column without options can't filter. */
+    filterOptions?: IrisTableFilterOption[];
+    /**
+     * Group the body by this column's value (vxe group-config parity, batch M):
+     * a group header row per distinct value (first-appearance order,
+     * `data-iris-group-row`) showing the value + count, then that group's rows,
+     * then a per-group summary row (`data-iris-group-summary`, same `summary`
+     * ops as the footer computed over the group's rows) when any column has a
+     * `summary` op. Flat mode only — tree mode ignores grouping (fail-closed);
+     * proxy mode groups per loaded page. Only the first `groupBy` column drives
+     * the plan — unless the table-level `groupBy?: string[]` (batch BS) is set,
+     * which wins and drives nested multi-column grouping instead. Group headers are collapsible (batch BH, iris 独有): the
+     * `data-iris-group-toggle` button collapses the group (rows + per-group
+     * summary hidden, header + count stay) via `groupCollapsed` /
+     * `defaultGroupCollapsed` / `onGroupCollapseChange`.
+     */
+    groupBy?: boolean;
+    /** Hide this column entirely (vxe column visibleMethod parity, batch U): a
+     * predicate evaluated in the display-columns memo (at most once per
+     * render); `false` hides the column even when `columnVisibility` says
+     * visible (the column's own veto wins). Absent / `true` keeps it. Scope
+     * mirrors `columnVisibility`: top-level columns only — a grouped column's
+     * leaf `visibleMethod` is not consulted (same documented simplification). */
+    visibleMethod?: () => boolean;
+}
+
+/**
+ * One named view preset (batch AH, iris 独有): a user-saved snapshot of the
+ * table's persistable state pieces — the SAME shape `persistState` loads and
+ * saves, captured by the same collector and applied through the same change
+ * callbacks.
+ */
+interface IrisTableNamedView {
+    /** View name (also the view's key in the toolbar select). */
+    name: string;
+    /** The state pieces captured when the view was saved. */
+    snapshot: IrisTablePersistedState;
+}
+/**
+ * Named view presets (batch AH, iris 独有 — vxe has no equivalent; its
+ * closest is manual state saving). The toolbar renders a compact select
+ * (`data-iris-table-views`) of user-saved snapshots: picking a view replays
+ * its snapshot through the change callbacks (same per-piece gating as
+ * `persistState`; `pageSize` reproduces the mount-restore sequence
+ * `onPageChange(1, size)` + one request); the "＋ 保存" item opens an inline
+ * input (`data-iris-views-save`) that snapshots the CURRENT pieces under a
+ * typed name (duplicate names upsert); the × button deletes the active view.
+ * Views load from storage on mount with the same guards as `persistState`
+ * and persist on every change; `activeKey` is controlled-only (never
+ * persisted).
+ */
+interface IrisTableViewConfig {
+    /** Storage adapter (`getItem`/`setItem`; defaults to `localStorage`).
+     * `false` keeps views in-memory only — no reads, no writes. */
+    storage?: Pick<Storage, 'getItem' | 'setItem'> | false;
+    /** Storage key. Default `'iris-table-views'`. */
+    key?: string;
+    /** Label formatter for a view name (rendered in the toolbar select). */
+    label?: (name: string) => string;
+    /** Controlled active view key; omit for uncontrolled (internal state). */
+    activeKey?: string | null;
+}
+
+type IrisTableSortDirection = 'asc' | 'desc';
+/** Map of column key → current width in px (after any resizing). */
+type IrisTableColumnWidths = Record<string, number>;
+/**
+ * Custom column panel options (vxe-grid customConfig parity, batch S): the
+ * toolbar `columnSettings` button opens the full panel — search, drag reorder,
+ * visibility toggles and reset — in place of the plain checkbox menu.
+ */
+interface IrisTableCustomConfig {
+    /** Reset button label; defaults to the i18n `table.customConfig.reset` key. */
+    resetText?: string;
+}
+type IrisTableEditor = 'text' | 'number' | 'select' | 'textarea';
+/** One checkbox option of a filterable column's filter panel (vxe filter-option parity). */
+interface IrisTableFilterOption {
+    value: string;
+    label: string;
+}
+/**
+ * Per-column checked filter sets (vxe filter-multiple parity): column key →
+ * values OR-matched against the raw `String(value)` of each row. Controlled
+ * through `IrisTableProps.filterValues` / `onFilterValuesChange`.
+ */
+type IrisTableFilterValues = Record<string, string[]>;
+/** Aggregation op for a column's summary/footer cell. */
+type IrisTableAggregateOp = 'sum' | 'avg' | 'min' | 'max' | 'count';
+/** Horizontal cell alignment (vxe align / header-align / footer-align parity). */
+type IrisTableAlign = 'left' | 'center' | 'right';
+interface IrisTableVirtualOptions {
+    /** Per-row height in px (uniform), or a `(index) => px` function for known
+     * variable heights (batch AG — the iris take on vxe `virtualYConfig` 增强
+     * 模式; the fn receives the virtual PLAN index — memoize it). */
+    itemHeight: number | ((index: number) => number);
+    /** Viewport height. Number → px; string → CSS length. */
+    height: number | string;
+    /** Extra rows rendered above and below the viewport. */
+    buffer?: number;
+}
+/** State pieces persistable via `persistState` (batch AG, iris 独有). */
+type IrisTablePersistPiece = 'sort' | 'multiSortState' | 'filters' | 'filterValues' | 'columnVisibility' | 'columnOrder' | 'columnWidths' | 'pageSize' | 'expandedKeys';
+/** One persisted state snapshot (batch AG): the pieces `persistState` loads
+ * and saves, keyed by piece name — a piece appears only when defined + included. */
+interface IrisTablePersistedState {
+    sort?: IrisTableSortState | null;
+    multiSortState?: IrisTableSortState[];
+    filters?: Record<string, string>;
+    filterValues?: IrisTableFilterValues;
+    columnVisibility?: Record<string, boolean>;
+    columnOrder?: string[];
+    columnWidths?: IrisTableColumnWidths;
+    pageSize?: number;
+    /** Batch BY: expanded row keys (detail panels + tree carets) captured by
+     * the shared collector when `onExpandedRowsChange` is set and the table
+     * actually expands (renderDetail or tree mode); restored through the
+     * expansion model — `expansion.set` commits and replays
+     * `onExpandedRowsChange(keys)` (expansion has no controlled prop, so the
+     * callback is the parent-owned channel). Row keys are STRINGIFIED at the
+     * model boundary, so the stored array is always strings; the snapshot
+     * accepts raw keys and the restore coerces them. Stale keys (rows not
+     * loaded yet) are fail-inert — the row simply renders expanded when it
+     * arrives. */
+    expandedKeys?: Array<string | number>;
+    /** Batch AJ: natural-language query captured by the named-views collector
+     * when `query` is set; restored FIRST via `onQueryChange` on view apply
+     * (persistState path stays byte-identical; legacy views load unchanged). */
+    query?: string;
+}
+/**
+ * `persistState` configuration (batch AG, iris 独有 — vxe has no built-in
+ * state persistence). Persists view state (sort / filters / column layout /
+ * page size) to a storage adapter so a table remounts where the user left it.
+ * The table is CONTROLLED: restore replays through the change callbacks and
+ * saves serialize the current props on every change.
+ */
+interface IrisTablePersistConfig {
+    /** Storage adapter (`getItem`/`setItem`; defaults to `localStorage`).
+     * `false` fully disables persistence — no reads, no writes. */
+    storage?: Pick<Storage, 'getItem' | 'setItem'> | false;
+    /** Storage key. Default `'iris-table-state'`. */
+    key?: string;
+    /** Pieces to persist. Defaults to ALL pieces. */
+    include?: Array<IrisTablePersistPiece>;
+}
+/** Periodic full view-state snapshots (batch DM, iris 独有). Unlike
+ * `persistState`, this config owns a separate timer/key and writes the same
+ * JSON shape exposed by `tableRef.exportStateJson()`. */
+interface IrisTableAutoSaveStateConfig {
+    /** Positive interval in milliseconds; zero/invalid values disable the timer. */
+    intervalMs?: number;
+    /** Storage adapter; defaults to `localStorage` when available. `false` disables IO. */
+    storage?: Pick<Storage, 'getItem' | 'setItem'> | false;
+    /** Storage key. Defaults to `'iris-table-auto-state'`. */
+    key?: string;
+}
+/** One external drop target for rowDragBetween (batch DQ). */
+interface IrisTableRowDragBetweenTarget<Row extends Record<string, unknown> = Record<string, unknown>> {
+    /** Value read from the target element's `data-iris-drop-zone` attribute. */
+    key: string;
+    /** Called once with the dragged row when it is released over that target. */
+    onDrop: (row: Row) => void;
+}
+
+/**
+ * One table tab (batch CT, iris 独有 — vxe has no parity): a named tab in
+ * the `tableTabs` strip rendered ABOVE the toolbar. Clicking the tab applies
+ * each view name in `views` IN ORDER through the SAME `selectView` path the
+ * toolbar select uses — unknown names are skipped fail-inert, and when
+ * several views touch the same state piece the LAST applied view wins (the
+ * toolbar select then mirrors that last view). An empty `views` array
+ * renders an inert tab; without the `views` config the whole strip is inert.
+ */
+interface IrisTableTab {
+    /** Tab key (identity — the first occurrence wins on duplicates). */
+    key: string;
+    /** Tab label. */
+    label: string;
+    /** Named views applied in order on click; omitted → inert tab. */
+    views?: string[];
+}
+interface IrisTableSortState {
+    key: string;
+    direction: IrisTableSortDirection;
+}
+/**
+ * One search-form field (vxe-grid formConfig items parity). On submit the
+ * field's value merges into the table filters under `key` (client-side path
+ * or the proxy query); empty strings are inactive and stripped.
+ */
+interface IrisTableFormField {
+    /** Filter key — matched against column keys and the query `filters` map. */
+    key: string;
+    /** Visible field label. */
+    label: string;
+    /** Control kind. Default `'text'`. */
+    type?: 'text' | 'select';
+    /** Options when `type: 'select'`. */
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    placeholder?: string;
+    /** Initial value; reset restores it. */
+    defaultValue?: string;
+}
+/** Params delivered to `IrisTableProps.proxyConfig.query` (vxe proxyConfig parity). */
+interface IrisTableProxyQueryParams {
+    /** 1-based page number. */
+    page: number;
+    pageSize: number;
+    sort: IrisTableSortState | null;
+    /**
+     * Multi-column sort (vxe sort-config.multiple parity), most-significant
+     * first. Present only in multiSort mode — single mode keeps passing `sort`.
+     */
+    sorts?: IrisTableSortState[];
+    filters: Record<string, string>;
+}
+/**
+ * Edit-validation presentation (vxe-grid ValidConfig parity).
+ */
+interface IrisTableValidConfig {
+    /**
+     * Render the inline editor error message (`data-iris-table-editor-error`).
+     * `false` still runs validation and blocks the commit — only the message
+     * element is skipped (`aria-invalid` stays). Default true.
+     */
+    showMessage?: boolean;
+}
+/** Params delivered to `IrisTableProps.seqMethod` (vxe seqMethod parity). */
+interface IrisTableSeqMethodParams {
+    rowIndex: number;
+    columnIndex: number;
+}
+/** Coordinates delivered to `IrisTableProps.onCellClick` (vxe cell-click parity). */
+interface IrisTableCellClickParams<Row = Record<string, unknown>> {
+    row: Row;
+    column: IrisTableColumn<Row>;
+    rowIndex: number;
+    columnIndex: number;
+}
+/**
+ * Coordinates delivered to `IrisTableProps.contextMenu` callbacks (vxe
+ * context-menu event params parity): the row/column under the cursor and its
+ * grid position.
+ */
+interface IrisTableContextMenuParams<Row = Record<string, unknown>> {
+    row: Row;
+    column: IrisTableColumn<Row>;
+    rowIndex: number;
+    columnIndex: number;
+}
+
+/** Params delivered to `IrisTableProps.footerMethod` (vxe footer-method parity). */
+interface IrisTableFooterMethodParams<Row = Record<string, unknown>> {
+    /** Leaf columns of the table (grouped headers flattened). */
+    columns: IrisTableColumn<Row>[];
+    /** Full body rows (sorted + filtered). */
+    data: Row[];
 }
 interface IrisTableCellEditEvent<Row = Record<string, unknown>> {
     row: Row;
@@ -2570,6 +2844,33 @@ interface IrisTableCellEditEvent<Row = Record<string, unknown>> {
     newValue: unknown;
     rowIndex: number;
 }
+/** Params delivered to `IrisTableProps.onEditStart` (vxe edit-activated parity, batch V). */
+interface IrisTableEditStartParams<Row = Record<string, unknown>> {
+    row: Row;
+    column: IrisTableColumn<Row>;
+    rowIndex: number;
+}
+/**
+ * Params delivered to `IrisTableProps.onEditClosed` (vxe edit-closed parity,
+ * batch V). Cell mode only — row-edit sessions commit per column through
+ * their own stores and are not reported (documented simplification); an
+ * async-validating commit that lands after `commitEdit` returned is also not
+ * reported (the sync path fires with the committed value).
+ */
+interface IrisTableEditClosedParams<Row = Record<string, unknown>> {
+    row: Row;
+    column: IrisTableColumn<Row>;
+    rowIndex: number;
+    /** The committed value; undefined when the edit was cancelled. */
+    value?: unknown;
+    /** true when the edit was cancelled (Escape) instead of committed. */
+    cancelled: boolean;
+}
+/** Scroll coordinates delivered to `IrisTableProps.onScroll` (vxe scroll parity, batch V). */
+interface IrisTableScrollParams {
+    scrollTop: number;
+    scrollLeft: number;
+}
 type IrisTableRenderDetail<Row = Record<string, unknown>> = (row: Row, rowIndex: number) => React.ReactNode;
 type IrisTableRowExpandable<Row = Record<string, unknown>> = (row: Row, rowIndex: number) => boolean;
 /**
@@ -2581,10 +2882,11 @@ type IrisTableRowExpandable<Row = Record<string, unknown>> = (row: Row, rowIndex
 interface IrisTableTooltipConfig<Row = Record<string, unknown>> {
     /**
      * Render a tooltip on every body cell. Default true when `tooltipConfig` is
-     * set. Truncation-based gating (vxe `showAll: false`) is not implemented —
-     * cells always carry the `title` (documented simplification: detecting a
-     * truncated cell cheaply isn't possible without layout measurement).
-     * `false` is accepted for API parity and behaves identically this batch.
+     * set. With `false`, the native `title` is emitted only when the cell's
+     * single-line content is measured wider than its rendered box; the table
+     * rechecks after root resize. SSR/jsdom (where layout dimensions are zero)
+     * fail open and keep the title. `true` keeps the title on every non-empty
+     * cell.
      */
     showAll?: boolean;
     /**
@@ -2593,86 +2895,994 @@ interface IrisTableTooltipConfig<Row = Record<string, unknown>> {
      */
     content?: (row: Row, column: IrisTableColumn<Row>) => string;
 }
+/**
+ * One header-merge entry (vxe-grid mergeHeaderCells parity, batch P). The
+ * coordinate space is the FLAT header's leaf-column index: `row` 0 only —
+ * entries with `row` > 0 are ignored (the flat header is a single row), and
+ * grouped headers are NOT merged (documented simplification).
+ */
+interface IrisTableMergeCell {
+    /** Header row index — only 0 is supported (flat header). */
+    row: number;
+    /** Leaf-column index of the merged cell's origin. */
+    col: number;
+    /** Columns spanned (gridColumnEnd); the covered cells render null. */
+    colspan?: number;
+    /** Rows spanned (gridRowEnd); inert on the single flat header row. */
+    rowspan?: number;
+}
+/**
+ * Span result shared by `spanMethod` and `footerSpanMethod` (vxe
+ * span-method / footer-span-method parity): both dimensions default to 1;
+ * values > 1 make the cell span adjacent cells, which then render null.
+ * Footer note: `rowspan` is inert in the footer stack (each footer row is
+ * its own grid container — see `footerSpanMethod`).
+ */
+interface IrisTableSpan {
+    rowspan?: number;
+    colspan?: number;
+}
+/** Params delivered to `IrisTableProps.footerSpanMethod` (vxe footer-span-method parity, batch P). */
+interface IrisTableFooterSpanParams<Row = Record<string, unknown>> {
+    /** 0-based row index over the rendered footer stack (footerMethod rows →
+     * summary row → footerData rows, whichever render). */
+    rowIndex: number;
+    columnIndex: number;
+    /** Leaf columns of the table (grouped headers flattened). */
+    columns: IrisTableColumn<Row>[];
+    /** Full body rows (sorted + filtered). */
+    data: Row[];
+}
+/** Footer cell merge callback (vxe footer-span-method parity, batch P). */
+type IrisTableFooterSpanMethod<Row = Record<string, unknown>> = (params: IrisTableFooterSpanParams<Row>) => IrisTableSpan | null;
+/** vxe-grid scrollbarConfig parity (batch Q): `theme: 'thin'` → 6px webkit + Firefox `scrollbar-width: thin` via `data-iris-scrollbar-thin`. */
+type IrisTableScrollbarConfig = {
+    theme?: 'default' | 'thin';
+};
+/** vxe-grid editDirtyConfig parity (batch Q): a committed cell whose value
+ * differs from its pre-edit original renders a primary dot
+ * (`data-iris-cell-dirty`); committing the original value clears it.
+ * `indicator: false` suppresses the dot (tracking stays); `className: true`
+ * also adds an `iris-table-cell-dirty` class for custom styling. */
+type IrisTableEditDirtyConfig = {
+    indicator?: boolean;
+    className?: boolean;
+};
+/**
+ * One conditional-formatting rule (batch AX, iris 独有 — vxe has no built-in
+ * conditional-formatting engine). Passed via `IrisTableProps.conditionalStyles`:
+ * a rule matches a body cell when its optional `column` filter (omitted →
+ * every column) equals the cell's column key AND `when(row, value)` returns
+ * true — `value` is the RAW cell value (`dataIndex ?? key` resolved, formula
+ * columns computed via `getCellValue`). Matching rules merge in array order
+ * after `cellStyle`; later rules win on conflicting style keys.
+ */
+interface IrisTableConditionalStyle<Row = Record<string, unknown>> {
+    /** Column key the rule applies to; omitted → every column. */
+    column?: string;
+    /** Match predicate: `row` is the full row object, `value` the raw cell value. */
+    when: (row: Row, value: unknown) => boolean;
+    /** Inline styles merged onto the body cell when the rule matches. */
+    style: React.CSSProperties;
+}
+/**
+ * One footer-merge entry (vxe-grid mergeFooterItems parity, batch R). The
+ * coordinate space matches `footerSpanMethod`: `row` is the 0-based index
+ * over the rendered footer stack (footerMethod rows → summary row →
+ * footerData rows, whichever render) and `col` the leaf-column index — both
+ * start at 0. The function (`footerSpanMethod`) wins when both are provided.
+ */
+interface IrisTableMergeFooterItem {
+    /** 0-based footer-stack row index (footerMethod rows → summary row → footerData rows). */
+    row: number;
+    /** Leaf-column index of the merged cell's origin. */
+    col: number;
+    /** Columns spanned (gridColumnEnd); the covered cells of the same row render null. */
+    colspan?: number;
+    /** Rows spanned — INERT (each footer row is its own grid container, so
+     * `gridRowEnd` cannot cross rows): covered cells of later rows keep their
+     * own data, like `footerSpanMethod`'s rowspan. */
+    rowspan?: number;
+}
+
+/**
+ * Unified event stream palette (batch DW, iris 独有 — vxe has no single event
+ * bus): the `type` names one of the closed event families; `detail` carries
+ * the SAME params the matching dedicated callback receives (reference-
+ * identical `row`/`column`). Events fire AFTER the dedicated callback — the
+ * bus is a bridge, not a behavior. Controllable proxy `sort` updates (a
+ * parent-driven `sort`/`multiSortState` prop change — not a user click) fire
+ * no event. The expansion family mirrors the shared `onExpandedRowsChange`
+ * channel: EVERY model commit fires `expanded-rows-change` — user toggles,
+ * `expandAll` seeding, and `persistState`/view `expandedKeys` restores all
+ * replay through the expansion model's `onChange` (a restore still needs
+ * `onExpandedRowsChange` + an expandable table — the same gate as the
+ * dedicated callback).
+ */
+type IrisTableEvent<Row = Record<string, unknown>> = {
+    type: 'cell-click';
+    detail: IrisTableCellClickParams<Row>;
+} | {
+    type: 'cell-dblclick';
+    detail: IrisTableCellClickParams<Row>;
+} | {
+    type: 'row-click';
+    detail: {
+        row: Row;
+        rowIndex: number;
+    };
+} | {
+    type: 'row-dblclick';
+    detail: {
+        row: Row;
+        rowIndex: number;
+    };
+} | {
+    type: 'sort-change';
+    detail: {
+        sort: IrisTableSortState | null;
+    };
+} | {
+    type: 'multi-sort-change';
+    detail: {
+        sorts: IrisTableSortState[];
+    };
+} | {
+    type: 'filter-change';
+    detail: {
+        filters: Record<string, string>;
+    };
+} | {
+    type: 'filter-value-change';
+    detail: {
+        filterValues: IrisTableFilterValues;
+    };
+} | {
+    type: 'edit-start';
+    detail: IrisTableEditStartParams<Row>;
+} | {
+    type: 'edit-commit';
+    detail: IrisTableEditClosedParams<Row>;
+} | {
+    type: 'edit-cancel';
+    detail: IrisTableEditClosedParams<Row>;
+} | {
+    type: 'expand-change';
+    detail: {
+        row: Row;
+        expanded: boolean;
+    };
+} | {
+    type: 'tree-expand-change';
+    detail: {
+        row: Row;
+        expanded: boolean;
+    };
+} | {
+    type: 'expanded-rows-change';
+    detail: {
+        expandedKeys: string[];
+    };
+};
 
+interface IrisTableHandle<Row extends Record<string, unknown> = Record<string, unknown>> {
+    /** Insert a row at `index` (default: end). A missing `rowKeyField` value gets an auto id. */
+    insertRow: (row: Row, index?: number) => void;
+    /** Clone the row with `key` (iris 独有): all field values shallow-copied onto a fresh auto id, inserted right after the source (or at `index`); missing key is a silent no-op. */
+    cloneRow: (key: string | number, index?: number) => void;
+    /** Remove the row with `key`; its selection is pruned. */
+    removeRow: (key: string | number) => void;
+    /** Batch-remove several rows by key (vxe removeRows parity): missing keys are silent no-ops, selection is pruned, one onDataChange fires. */
+    removeRows: (keys: Array<string | number>) => void;
+    /** Patch the row with `key` ({ ...row, ...patch }). */
+    updateRow: (key: string | number, patch: Partial<Row>) => void;
+    /** Re-fetch the current page (proxy mode). */
+    refetch: () => void;
+    /** Replace the live row list (vxe loadData parity, batch V): fires onDataChange; in proxy mode the proxy state total stays unchanged until the next query (the core remote source has no setData — documented). */
+    loadData: (rows: Row[]) => void;
+    /** Re-fetch the current page (vxe reloadData parity, batch V — alias of refetch). */
+    reloadData: () => void;
+    /** Merge params into the proxy query and fire the request (vxe commitProxy parity, batch V). */
+    commitProxy: (overrides: Partial<IrisTableProxyQueryParams>) => void;
+    /** Proxy state snapshot (vxe getProxyInfo parity, batch V): page/pageSize/total; null without a proxy. */
+    getProxyInfo: () => {
+        page: number;
+        pageSize: number;
+        total: number;
+    } | null;
+    /** Snapshot (copy) of the current live row list (vxe getTableData parity). */
+    getData: () => Row[];
+    /** Snapshot (copy) of the currently filtered + sorted rows (vxe getFilteredData parity, batch W): the filteredData memo value — the loaded page after local filters/sort (proxy mode: page after the prop `filters` merge), remoteFilter passes rows through unchanged. The handle object is re-created every render, so this always closes over the latest memo. */
+    getFilteredData: () => Row[];
+    /** Serialize the CURRENT filtered view as CSV (batch W): `exportCsv(getFilteredData(), displayColumns)` — hidden columns excluded (displayColumns drops columnVisibility/visibleMethod hides), formula injection neutralized; returns a plain string without BOM (caller downloads via `downloadCsv`). */
+    exportCurrentViewCsv: () => string;
+    /** Serialize the SELECTED rows as CSV (batch AP, iris 独有): selected rows
+     * in bodyData order (filtered + sorted + tree-flattened) → the same
+     * `exportCsv` shape as `exportCurrentViewCsv` (formula columns materialized
+     * on shadow rows, hidden columns excluded); empty selection → `''` (caller
+     * detects via `getSelection()`). */
+    exportSelectionCsv: () => string;
+    /** Serialize rows whose keys are explicitly supplied, preserving current
+     * body/view order and the same formula/mask/hidden-column pipeline. */
+    exportRowsCsv: (keys: Array<string | number>) => string;
+    /** Multi-segment CSV export (batch DI, iris 独有): ONE file — the current
+     * table block (`# current` + `exportCurrentViewCsv()` byte-for-byte) followed
+     * by one `# <key>` + ref block per `exportNames` entry IN ORDER; segments
+     * joined by a blank line (`\n\n`), no trailing newline. Each ref block is
+     * serialized by its OWN keys (first row's keys as header) — NOT this table's
+     * columns; empty ref rows → just the segment header; a `''` key skips that
+     * segment (even its header). Empty/absent `exportNames` → the bare
+     * current-table CSV (byte-identical to `exportCurrentViewCsv()`, zero
+     * regression). Caller downloads via `downloadCsv`. */
+    exportMultiCsv: () => string;
+    /** Current selection keys (vxe getCheckboxRecords parity). */
+    getSelection: () => Array<string | number>;
+    /** Clear every selected row (vxe clearCheckboxRow parity). */
+    clearSelection: () => void;
+    /** Select every checkMethod-eligible row of the current page (vxe
+     * setAllCheckboxRow(true) parity — `checkMethod` rows are skipped). */
+    selectAll: () => void;
+    /** Toggle a single row's selection by key (vxe toggleCheckboxRow parity —
+     * a direct toggle that bypasses `checkMethod`). */
+    toggleRowSelection: (key: string | number) => void;
+    /** Scroll the row with `key` into view (vxe scrollToRow parity); no-op when the row is not rendered. */
+    scrollToRow: (key: string | number) => void;
+    /** Scroll the row with `key` into view AND flash a transient row highlight (`data-iris-row-target`, cleared after 2s — batch CZ, iris 独有: vxe has no locate flash); a later goToRow replaces the previous target; unknown/unrendered key → no-op (scrollToRow precedent); fires no events and needs no `onCurrentRowChange`. */
+    goToRow: (key: string | number) => void;
+    /** Toggle a row's expand state (vxe toggleRowExpand parity): tree mode toggles the caret, detail mode the panel; no-op for plain tables. */
+    toggleRowExpand: (key: string | number) => void;
+    /** Clear the active sort (vxe clearSort parity) — single and multi channels. */
+    clearSort: () => void;
+    /** Clear every filter channel (vxe clearFilter parity): text filters + checked sets. */
+    clearFilter: () => void;
+    /** Set the current (highlighted) row (vxe setCurrentRow parity); no-op without onCurrentRowChange (or an unknown key). */
+    setCurrentRow: (key: string | number) => void;
+    /** Set the current (highlighted) column (vxe setCurrentColumn parity); no-op without onCurrentColumnChange (or an unknown key). */
+    setCurrentColumn: (key: string) => void;
+    /** Audit trail snapshot (batch AT, iris 独有): newest-first entries (seq/at/type/rowKey/column/old→new) — an empty array when `auditLog` is off or nothing was committed yet. */
+    getAuditLog: () => ReadonlyArray<IrisTableAuditEntry>;
+    /** Wipe every audit entry (batch AT, iris 独有): the seq counter never resets — audit integrity. No-op without `auditLog`. */
+    clearAuditLog: () => void;
+    /** Version-history snapshot (batch BA, iris 独有): newest-first LIGHTWEIGHT entries (index/at/type — deliberately WITHOUT rows, so the snapshot stays cheap; `restoreVersion` fetches the rows from the controller) — an empty array when `versionHistory` is off or nothing was committed yet. */
+    getVersions: () => ReadonlyArray<IrisTableVersionEntry>;
+    /** Restore the rows captured before the commit with `index` (batch BA, iris 独有): applies them through the normal write-back channel (`commitRowList`, type `'undo'` — auditable and undoable) WITHOUT pushing a new version; no-op for an unknown index (trimmed/cleared) or without `versionHistory`. */
+    restoreVersion: (index: number) => void;
+    /** Export the rows captured BEFORE the commit with `index` as CSV (batch BF, iris 独有): the same `exportCsv` shape as `exportCurrentViewCsv` (formula columns materialized on shadow rows, masks applied, hidden columns excluded) — the PRE-change snapshot, NOT the live view; an unknown index (trimmed/cleared) or no `versionHistory` → `''` (caller detects via `getVersions()`). */
+    exportVersionCsv: (index: number) => string;
+    /** Export the compare-view DIFF rows as CSV (batch BV, iris 独有): current-view rows marked `removed`/`changed` in VIEW order + `compareWith`-only `added` rows in SNAPSHOT order, each prefixed with a marker column (`__iris_diff`, header = i18n `table.compare.diff`); changed cells export a `maskedOld → maskedNew` composite (mask before composition; `exportRaw` keeps both sides bare; formula columns do not self-composite) — same serializer shape as `exportCurrentViewCsv` (formula materialized, masks applied, hidden columns excluded); no `compareWith`/`rowKey` → `''`, identical snapshots → header only. */
+    exportComparisonCsv: () => string;
+    /** Export the audit trail as CSV (batch CO, iris 独有): spec-literal 6 columns `time,type,rowKey,column,old,new` — `time` = `formatClock(new Date(at))` (HH:MM:SS local — byte-identical to the audit panel's time cell, display/export consistency), the rest verbatim (undefined → '', typed numbers bare, strings RFC-4180-quoted + OWASP formula-neutralized via core `toCsv` — audit content is untrusted data); newest-first (ring order — the same view as `getAuditLog`); `auditLog` off → `''`, on but empty ring → header only (two states, caller distinguishes via `getAuditLog()`). */
+    exportTimelineCsv: () => string;
+    /** Export the annotated cells as CSV (batch DU, iris 独有 — vxe has no note
+     * concept, so no export parity): spec-literal 3 columns
+     * `rowKey,column,annotation`, one line per noted body cell in bodyData
+     * order; notes resolve through the SAME cellNoteState path as the cell
+     * render (dynamic `cellNote` wins over the static `annotations` map),
+     * hidden columns excluded via the view-columns list; values flow through
+     * core `toCsv` (RFC-4180 quoting + OWASP formula neutralization —
+     * annotation text is untrusted data). Fail-closed: `exportAnnotations`
+     * off → `''`; on but no notes on the current body → `''` (spec-literal
+     * 无批注返回空 — the two states are indistinguishable, mirroring
+     * `exportSelectionCsv`). */
+    exportAnnotationsCsv: () => string;
+    /** Export the CURRENT view state as JSON (batch BZ, iris 独有): all 9 spec
+     * blocks — sort / filters / filterValues / columnVisibility / columnOrder /
+     * columnWidths / pageSize / expandedKeys / query — captured by the SAME
+     * collector as `persistState` (multiSortState deliberately excluded — not
+     * in the spec; `importStateJson` accepts supersets). A piece appears only
+     * when restorable (owning callback present; `pageSize` only with a proxy;
+     * `expandedKeys` only when expandable AND restorable; `query` only when
+     * set) — a bare table exports `'{}'`. Round-trips byte-identically through
+     * `importStateJson`. */
+    exportStateJson: () => string;
+    /** Apply a previously exported state JSON (batch BZ, iris 独有): parses and
+     * replays every present piece through the owning change callbacks (the same
+     * per-piece gating as a view apply — `query` restores FIRST via
+     * `onQueryChange`, `pageSize` reproduces `onPageChange(1, size)` + exactly
+     * one request, `expandedKeys` replaces the whole set via the expansion
+     * model). Invalid JSON or a non-object value → `false` with NOTHING applied;
+     * valid JSON applies piece-by-piece lazily and returns `true` (ineligible
+     * pieces — missing callback / wrong type — are skipped). */
+    importStateJson: (json: string) => boolean;
+    /** Compare two exported-state JSONs (batch DE, iris 独有): field-level diff text (`+` added / `-` removed / `~ changed old → new`), deterministic by sorted keys + structural deep-equal (order-independent); identical → `''`; invalid JSON → `! compareStates: invalid JSON` (never throws). Pairs with `exportStateJson`/`importStateJson` — `a` = before, `b` = after. */
+    compareStates: (a: string, b: string) => string;
+    /** Column access stats (batch EB, iris 独有 — vxe has no counter): a
+     * snapshot of the per-column session counters — `{ key, clicks, edits,
+     * total }` sorted total DESC, key ASC tiebreak; `[]` when `columnStats` is
+     * off or nothing was counted yet (fail-closed). Session-local (no
+     * persistence, no clear channel); the handle re-created every render
+     * closes over the latest ref-mirrored map (getFilteredData precedent). */
+    getColumnStats: () => ReadonlyArray<IrisTableColumnStat>;
+}
+/**
+ * Audit-trail entry shape (batch AT, iris 独有) — mirrors the core
+ * `AuditLogEntry` contract (the handle returns a snapshot of the controller
+ * ring). Row-level structural changes (insert/remove) carry only `rowKey`.
+ */
+interface IrisTableAuditEntry {
+    /** Monotonic sequence number (never resets on clear — audit integrity). */
+    seq: number;
+    /** Epoch ms when the entry was pushed. */
+    at: number;
+    /** Commit kind: any core {@link AuditLogType} (edit/insert/remove/paste/batch/fill/undo/redo/merge). */
+    type: AuditLogType;
+    /** Key of the first changed row (undefined when none could be resolved). */
+    rowKey?: string | number;
+    /** Column key of the first changed cell (undefined for row-level ops). */
+    column?: string;
+    /** Value before the change. */
+    oldValue?: unknown;
+    /** Value after the change. */
+    newValue?: unknown;
+}
+/**
+ * Version-history entry shape (batch BA, iris 独有) — a LIGHTWEIGHT mirror of
+ * the core `VersionHistoryEntry` WITHOUT the rows (the handle snapshot stays
+ * cheap; `restoreVersion(index)` fetches the rows from the controller).
+ */
+interface IrisTableVersionEntry {
+    /** Monotonic version index (never resets on clear). */
+    index: number;
+    /** Epoch ms when the version was pushed. */
+    at: number;
+    /** Commit-kind hint: any core {@link AuditLogType} (edit/insert/remove/paste/batch/fill/undo/redo/merge). */
+    type: AuditLogType;
+}
+/**
+ * Collaborative-presence cursor entry (batch BD, iris 独有 — vxe has no
+ * cursor sharing): one remote participant's cursor on a selected cell. Pure
+ * display — the table renders the entry verbatim and owns no collaboration
+ * state or logic. `cellKey` uses the canonical `${rowKeyVal}::${colKey}`
+ * delimiter (the same as `cellId` and the `annotations` map keys).
+ */
+interface IrisTablePresenceEntry {
+    /** Stable participant id (also surfaced as `data-iris-presence-id`). */
+    id: string;
+    /** Participant display name — the text of the cell's corner label. */
+    name: string;
+    /** Cursor color, used verbatim: the cell outline + the label background. */
+    color: string;
+    /** Target cell: `${rowKeyVal}::${colKey}` (same delimiter as `cellId`). */
+    cellKey: string;
+}
 /**
- * vxe-grid proxyConfig parity — the server-side data proxy (query slice).
- * When set, `data` is ignored: rows come from `query` (paged), and the table
- * renders a pager below the body. Edit write-back keeps working — committed
- * edits update the live rows locally until the next refetch replaces them.
+ * Column access-stats entry (batch EB, iris 独有 — vxe has no counter): one
+ * leaf column's session counters. DELIBERATELY session-local (no core
+ * controller, no persistence, no clear channel) — the parent reads the
+ * snapshot and owns any downstream use. `total = clicks + edits` is the sort
+ * key (descending; ties resolve key ASC for a deterministic order).
  */
-interface IrisTableProxyConfig<Row extends Record<string, unknown>> {
+interface IrisTableColumnStat {
+    /** Leaf column key (the same key as the column def / `data-iris-table-header`). */
+    key: string;
+    /** Cell clicks on this column — every cell click counts ONCE (row-edit, cell-range and click-trigger paths included). */
+    clicks: number;
+    /** Inline-edit opens on this column — cell-mode `beginEdit` plus each row-mode session created. */
+    edits: number;
+    /** `clicks + edits` — the handle/panel sort key. */
+    total: number;
+}
+
+interface IrisTableAdvancedProps<Row extends Record<string, unknown> = Record<string, unknown>> {
+    nlSummary?: boolean;
     /**
-     * Fetch one page. 1-based `page`; `sort`/`filters` are the ACTIVE state,
-     * passed through when `remoteSort`/`remoteFilter` are enabled.
+     * Mini chart preview (batch AR, iris 独有): when true, the toolbar gains a
+     * chart trigger (`data-iris-chart-trigger`) opening a floating panel
+     * (`data-iris-chart-panel`) that charts the CURRENT filtered rows: a
+     * numeric-column select (columns where `typeof getCellValue(row, col) ===
+     * 'number'` for some row, or `col.summary === 'sum'`) plus a bar/line kind
+     * toggle. The SVG (viewBox 0 0 300 120) is built from the core
+     * `buildChartData` material over the first 20 values (a muted "共 N 行"
+     * note when truncated) — structured JSX only, no SVG strings. Token colors
+     * only; Esc / outside / scroll close it. Requires a toolbar render (the
+     * gate admits `chartPreview` like `undo`).
+     */
+    chartPreview?: boolean;
+    /**
+     * Auto-refresh (batch AS, iris 独有 — vxe has no interval refresh): when
+     * set, the table re-queries the proxy every `intervalMs` ms while in proxy
+     * mode (non-proxy `data` tables are inert — there is nothing to refetch).
+     * Each tick calls the SAME refetch the built-in ↻ button uses — the
+     * standard refetch path, so `loading` flips true for the duration of the
+     * request (the core source has no silent-refresh option; documented
+     * behavior, not suppressed). `intervalMs` ≤ 0 disables the timer
+     * (fail-closed). The interval restarts whenever `intervalMs` changes
+     * (keyed on the scalar, so an inline object doesn't reset the timer every
+     * render) and is cleared on unmount / proxy removal. Additive — default
+     * off.
+     */
+    autoRefresh?: {
+        intervalMs: number;
+    };
+    /**
+     * Freshness stamp (batch AS, iris 独有 — vxe shows no data-arrival time):
+     * when true, the toolbar renders `Updated at HH:MM:SS`
+     * (`data-iris-freshness`, i18n `table.freshness`, 24h local `formatClock`)
+     * re-stamped on EVERY live-data change — initial arrival, refetch, edit
+     * commit, row ops / paste / batch / range clear, undo/redo (everything
+     * that funnels through `setLiveData`). Hidden until the first row exists
+     * (`liveData.length === 0`). Requires a toolbar render. Additive — default
+     * off.
+     */
+    freshness?: boolean;
+    /**
+     * Validation summary (batch BR, iris 独有 — vxe shows no editRules outcome
+     * counts): when true, the toolbar renders a muted commit-outcome ledger
+     * (`data-iris-validation-summary`, i18n `table.validationSummary`, en
+     * `Passed {ok} · Failed {fail}` / zh `通过 {ok} · 失败 {fail}`) for columns
+     * with declarative `editRules`: ok = a commit that passed editRules and
+     * landed (cell and row edit modes), fail = a commit attempt rejected by
+     * editRules. Typing-time validation, legacy `validate` columns, paste/fill/
+     * FNR/batch bypasses and Escape cancels never count. Hidden until at least
+     * one outcome is counted; re-enabling the switch resets the ledger.
+     * Requires a toolbar render (the gate admits `validationSummary` like
+     * `freshness`). Additive — default off.
+     */
+    validationSummary?: boolean;
+    /**
+     * Audit log (batch AT, iris 独有 — vxe has no audit trail): when true, every
+     * mutation commit appends ONE entry to a bounded (200) ring — inline/row
+     * edits, insert/remove row ops, paste, fill, batch edit, undo/redo replay
+     * (type hint per site; rowKey + first-changed-cell context from a light
+     * diff of the row lists, documented simplification). The toolbar gains an
+     * audit trigger (`data-iris-audit-trigger`) opening a floating panel
+     * (`data-iris-audit-panel`, like the chart/stats panels — Esc / outside /
+     * scroll close) listing newest-first entries (seq + `formatClock` time +
+     * type + rowKey + column + muted old→new). `tableRef.getAuditLog()` /
+     * `clearAuditLog()` expose the trail programmatically (the seq never
+     * resets on clear — audit integrity). Requires a toolbar render (the gate
+     * admits `auditLog` like `undo`). Additive — default off.
+     */
+    auditLog?: boolean;
+    /**
+     * Performance panel (batch BL, iris 独有 — vxe has no perf stats): when
+     * true, every render commit samples `nowMs()` (render-top mark →
+     * dependency-less `useLayoutEffect` run) into a core `createPerfStats`
+     * latest-snapshot controller (`@iris-ui-kit/core/perf-stats` — own
+     * subpath). Duration = render + layout phase, excludes paint
+     * (documented). The toolbar gains a ⚡ trigger (`data-iris-perf-trigger`)
+     * opening a floating panel (`data-iris-perf-panel`, like the audit panel
+     * — Esc / outside / scroll close) showing the last render duration,
+     * row count, leaf-column count and the audit-trail depth — live: the
+     * panel subscribes to BOTH controllers, so `tableRef.clearAuditLog()`
+     * refreshes the changes count in place; `auditLog` off → muted `—`. The
+     * push notifies only the panel (separate portal root) — the table never
+     * re-renders from its own measurement. Requires a toolbar render (the
+     * gate admits `perfStats` like `auditLog`). Off = zero cost. Additive —
+     * default off.
+     */
+    perfStats?: boolean;
+    /**
+     * Version history (batch BA, iris 独有 — vxe has no time-travel): when set,
+     * every row-list commit (`commitRowList` — row ops, paste, fill, range
+     * clear, batch edit, undo/redo replay) pushes the PRE-change rows into a
+     * bounded ring (core `createVersionHistory`, default max 20; `max: 0`
+     * unlimited; `max` read once at mount). The toolbar gains a history trigger
+     * (`data-iris-history-trigger`) opening a floating panel
+     * (`data-iris-history-panel`, like the audit panel — Esc / outside / scroll
+     * close) listing versions newest-first (#index + `formatClock` time + commit
+     * type); clicking an entry restores those rows through the normal write-back
+     * channel (`commitRowList(rows, 'undo')` — auditable and undoable) WITHOUT
+     * pushing a new version. Inline cell/row edits (the `commitValue` funnel)
+     * don't create versions (documented — restore replaces the whole row list,
+     * so row-level commits are the coherent unit). `tableRef.getVersions()`
+     * (lightweight — no rows) / `restoreVersion(index)` expose the ring
+     * programmatically. Requires a toolbar render (the gate admits
+     * `versionHistory` like `undo`). Additive — default off.
+     */
+    versionHistory?: {
+        max?: number;
+    };
+    /**
+     * Compare view (batch AU, iris 独有 — vxe has no compare capability): a
+     * snapshot the live rows are diffed against by `rowKey`. Every live row
+     * absent from the snapshot renders `data-iris-row-removed`, every live row
+     * present in both with ≥1 differing cell renders `data-iris-row-changed`
+     * with `data-iris-cell-changed` on the changed cells and a title tooltip
+     * `旧值: X → 新值: Y` (old = live value, new = snapshot value) that
+     * overrides the tooltipConfig title (compare wins, documented); snapshot-
+     * only rows are `added` in the core diff but have no rendered slot — the
+     * compare view renders the live dataset (documented). Core `diffRows` is
+     * framework-free; the memo is null without `compareWith` or `rowKey` —
+     * additive, default off.
+     */
+    compareWith?: Row[];
+    /**
+     * One-click compare merge (batch ED, iris 独有 — vxe has no compare/merge
+     * capability): when true (with `compareWith` + `rowKey`, and a toolbar
+     * render — the gate admits `mergeCompare` like `undo`), the toolbar gains
+     * a text-label button (`data-iris-table-compare-merge`, i18n
+     * `table.mergeCompare`, en `Merge compare` / zh `合并差异`) that applies
+     * EVERY added/changed difference to the CURRENT data — changed rows get
+     * their differing cells replaced in place by the snapshot values (shallow
+     * copy of the live row — a live-only key absent from the snapshot is reset
+     * to `undefined`, so the merged row matches the snapshot exactly and a
+     * second click is a no-op), added rows are
+     * appended in snapshot order (shallow copy — snapshot elements are never
+     * aliased into liveData) — through the normal write-back channel
+     * `commitRowList(rows, 'merge')`, so the merge is audited (a single
+     * `merge` entry), undoable and versioned like any row-list commit.
+     * `removed` rows are untouched (spec: changed/added only). Disabled while
+     * there is nothing to apply (identical snapshot / removed-only diff); the
+     * handler early-returns the same way (double-safety, idempotent).
+     * Additive — default off.
+     */
+    mergeCompare?: boolean;
+    /**
+     * Cell auto-link (batch CA, iris 独有 — vxe has no URL/email auto-
+     * detection): when true, text cells run their display chain
+     * (mask → formatter ?? raw) through core `detectAutoLink`; a whole-text
+     * URL/email match renders an `<a data-iris-auto-link>` (_blank +
+     * noreferrer) instead of plain text. Non-matching text falls through to
+     * the formatter/raw branch unchanged; an explicit `col.link` column still
+     * wins (evaluated before autoLink). Additive — default off.
+     */
+    autoLink?: boolean;
+    /**
+     * Recent filters (batch CB, iris 独有 — vxe has no "recent filters"
+     * concept): when true, every filter-panel confirm (non-empty checked
+     * set) records `{ key, values, ts }` into a core `createRecentFilters`
+     * ring (newest-first, 10 entries, MRU — re-confirming the same set
+     * bumps it to the top). The filter panel shows the recent entries
+     * above the options; clicking one applies it immediately (across
+     * columns) and closes. Additive — default off.
+     */
+    recentFilters?: boolean;
+    /**
+     * Edit-history sidebar (batch DB, iris 独有 — vxe has no edit history): a
+     * right-side drawer panel (portal, `position: fixed`, 360px, NO backdrop —
+     * non-modal) opened from the toolbar trigger (`data-iris-edit-sidebar-trigger`,
+     * ⏳ right after the version-history trigger). It merges the batch-AT audit
+     * ring and the batch-BA version ring into ONE timeline view, newest-first
+     * (`at` desc; a same-ms tie lists the audit entry ABOVE its version — the
+     * deterministic record-order arbitration). Version entries are clickable:
+     * pressing one restores those rows through the normal write-back channel
+     * (`commitRowList(rows, 'undo')` — auditable and undoable) WITHOUT pushing a
+     * new version, exactly like the version-history panel, and closes. Audit
+     * entries render seq + `formatClock` time + type + rowKey + column + muted
+     * old→new. Fail-closed matrix: a recording layer whose prop is OFF
+     * contributes NOTHING — the record layers are never implicitly enabled, so
+     * with only `versionHistory` the panel lists versions alone, with only
+     * `auditLog` audit entries alone, and with neither the empty state. The
+     * panel subscribes to BOTH controllers (`useSyncExternalStore` each) so a
+     * commit while it is open refreshes the timeline in place. Closes on Esc /
+     * outside pointer-down / any scroll; the trigger is exempt (a press on it
+     * toggles instead of close-then-reopen). Requires a toolbar render (the
+     * gate admits `editSidebar` like `versionHistory`). Additive — default off.
+     */
+    editSidebar?: boolean;
+    /**
+     * Imperative handle (vxe-grid edit insert/remove/setRow parity + iris-only
+     * additions): row ops, proxy/view/selection methods, and (batch BZ) the
+     * full view-state JSON export/import — `exportStateJson()` /
+     * `importStateJson(json)` (sort / filters / filterValues /
+     * columnVisibility / columnOrder / columnWidths / pageSize / expandedKeys /
+     * query — the same collector as `persistState`).
+     */
+    tableRef?: React.MutableRefObject<IrisTableHandle<Row> | null>;
+    /** Fired after any internal row operation / edit write-back, with the new row list. */
+    onDataChange?: (rows: Row[]) => void;
+    /** Veto rows from selection (vxe-grid checkboxConfig.checkMethod parity). */
+    checkMethod?: (row: Row, rowIndex: number) => boolean;
+    /** Pager options (vxe-grid pagerConfig parity). */
+    pagerConfig?: IrisTablePagerConfig;
+    /** Fixed height (vxe-grid height parity, batch N): makes the root a vertical
+     * scroll container with a sticky header row. Number → px; string → CSS length. */
+    height?: number | string;
+    /** Minimum height of the fixed-height container (with `height`/`maxHeight`). */
+    minHeight?: number | string;
+    /** Maximum height of the fixed-height container (with `height`/`minHeight`). */
+    maxHeight?: number | string;
+    /** Thin scrollbars (vxe-grid scrollbarConfig parity, batch Q): when
+     * `theme: 'thin'`, the root and its virtual-scroll descendant get 6px
+     * webkit scrollbars plus Firefox `scrollbar-width: thin` via
+     * `data-iris-scrollbar-thin`. Default: browser scrollbars. */
+    scrollbarConfig?: {
+        theme?: 'default' | 'thin';
+    };
+    /** Batch DP (iris 独有): add token-driven custom thumb styling to the native
+     * scrollbar while retaining native scrolling and accessibility. */
+    scrollbarThumb?: boolean;
+    /**
+     * Back-to-top (batch EA, iris 独有 — vxe has no floating back-to-top): when
+     * true, a 40×40 round ↑ button floats at the scroll viewport's bottom-right
+     * once the table's effective scroller scrolls past 200px (the fixed-height
+     * root, vxe-grid `height` parity, or the virtual-scroll viewport — the
+     * viewport wins when both exist, the same resolution the paging keys use).
+     * Clicking it scrolls back to the top (`scrollTo({ top: 0, behavior })` with
+     * a `scrollTop = 0` fallback; reduced-motion users get `'auto'`). The
+     * anchor is a sticky zero-height endcap (absolute-in-anchor corner button,
+     * z 3 above the sticky header / pinned columns) — zero layout footprint,
+     * no dead scroll tail — and the button disappears once the scroller returns
+     * above the threshold. Non-scrollable tables never show it (fail-closed);
+     * printable tables suppress it. Additive — default off.
+     */
+    scrollToTop?: boolean;
+    /** Batch DN (iris 独有): show count/average statistics for numeric columns
+     * inside their leaf headers, separate from footer/column totals. */
+    headerStats?: boolean;
+    /** Dirty-cell tracking (vxe-grid editDirtyConfig parity, batch Q): a cell
+     * whose committed value differs from its pre-edit original renders a
+     * primary dot (`data-iris-cell-dirty`, cell gets `position: relative`);
+     * committing the original value clears it. `indicator: false` suppresses
+     * the dot (tracking stays); `className: true` also adds an
+     * `iris-table-cell-dirty` class for custom styling. */
+    editDirtyConfig?: {
+        indicator?: boolean;
+        className?: boolean;
+    };
+    /** Fill the parent (vxe-grid auto-resize parity, batch Q): a
+     * ResizeObserver measures the root and, when no explicit `height` is set,
+     * renders `height: 100%` so the table fills AND tracks its parent (the
+     * fixed-height scroll machinery engages after the first positive
+     * measure). When `height` IS set the measured size is kept internally and
+     * the explicit height wins (no visible change). Without ResizeObserver
+     * (jsdom/SSR) the scroll engagement is a no-op. Default false. */
+    autoResize?: boolean;
+    /**
+     * Re-measure on content changes (vxe-grid syncResize parity, batch R):
+     * when true, `autoResize` is off and NO explicit `height` is set, an
+     * effect keyed on data / loading / error / footerData / size / bordered
+     * runs the SAME root measure autoResize uses (plus on
+     * `visibilitychange`), so the fixed-height machinery tracks
+     * content-driven size changes without a ResizeObserver. Same application
+     * rules as `autoResize`: with `height` set the explicit height wins and
+     * the effect does nothing. Default false. */
+    syncResize?: boolean;
+    /**
+     * Narrow-width responsive mode (iris 独有 — vxe has no responsive column
+     * behavior): a prop-gated ResizeObserver measures the root; when the
+     * container measures below 480px (strictly — 480 exactly is full width),
+     * the lowest-priority top-level columns are greedily hidden until the
+     * natural width fits (pinned columns survive, at least one column stays),
+     * and — only when columns STILL overflow after collapsing — a horizontal
+     * scroll hint bar (`data-iris-scroll-hint`) + root overflowX auto appear
+     * so no data is unreachable. At/above 480px, without ResizeObserver
+     * (jsdom/SSR) or with the prop off, the render is byte-identical. Default
+     * false. */
+    responsive?: boolean;
+    /**
+     * Seed the live row list with a COPY of `data` (vxe-grid keepSource
+     * parity, batch R): `liveData` initializes to `[...data]` instead of the
+     * `data` reference, so mutating the original array after mount cannot
+     * change the table. The table is immutable either way — it never mutates
+     * the rows it receives; `keepSource` just decouples the initial seed.
+     * Later controlled re-feeds (new `data` reference) keep the hand-off. */
+    keepSource?: boolean;
+    /**
+     * Root stacking (vxe-grid zIndex parity, batch R): sets `z-index` on the
+     * root with `position: relative` (CSS z-index is inert on static
+     * elements). Rendered before `style` — a caller-provided style can still
+     * override. */
+    zIndex?: number;
+    /** Highlight rows on hover (vxe highlight-hover-row parity, batch N). Default true. */
+    highlightHoverRow?: boolean;
+    /** Header overflow (vxe showHeaderOverflow parity, batch W): when false, header cells switch to `whiteSpace: 'normal'` + `overflow: 'visible'` (text wraps instead of the ellipsis). Default true. */
+    showHeaderOverflow?: boolean;
+    /** Footer overflow (vxe showFooterOverflow parity, batch W): when false, summary / footerMethod / footerData cells switch to `whiteSpace: 'normal'` + `overflow: 'visible'` (text wraps instead of the ellipsis). Default true. */
+    showFooterOverflow?: boolean;
+    /** Background watermark text (iris 独有 — vxe has no watermark concept): when set, a rotated tiled watermark layer (wrapper `data-iris-watermark` → overlay `data-iris-watermark-overlay` → tiles `data-iris-watermark-tile`, same DOM shape as the standalone IrisWatermark primitive) overlays the table's static rows / footer / pager — below the sticky header, pinned columns and floating panels. The wrapper is a sticky first child of the root (the scroll container), so in fixed-height mode it pins to the scroll viewport and stays put while rows scroll beneath. Pure display: `aria-hidden` + `pointer-events: none` + `user-select: none`, token-driven (`--iris-muted` / `--iris-space-xl` / `--iris-font-size-lg`). Empty string hides the layer. */
+    watermark?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+
+interface IrisTableEditingProps<Row extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Column drag-sort (vxe-grid columnDragConfig parity). Reorders leaf
+     * columns on drop; parent owns columns (pass the reordered array back).
+     * Batch CH (iris 独有 — vxe has no drag-out pin): when `columnPinMenu` is
+     * ALSO on, dragging a column header past the table's LEFT edge pins it
+     * left on release (drag-out pin) instead of reordering — a second gesture
+     * into the pin menu's state channel (same `onColumnPinnedChange` contract,
+     * both controlled/uncontrolled modes, never a reorder). Plain `columnDrag`
+     * without `columnPinMenu` keeps the vxe reorder-only behavior.
+     * Batch DK (iris 独有): a pinned intra-zone reorder ALSO fires
+     * `onColumnOrderChange` with the new top-level key list (flat leaf tables
+     * only; grouped leaves stay `onReorder`-only) so a header frozen-zone
+     * reorder is durable for controlled parents through the same channel the
+     * settings panel uses.
+     */
+    columnDrag?: {
+        /** Called with the reordered column array after a drop. */
+        onReorder: (columns: IrisTableColumn<Row>[]) => void;
+    };
+    /** Render a leading sequence-number column (vxe-grid seqConfig parity). */
+    seq?: boolean;
+    /**
+     * Excel-style row/column references (batch AO, iris 独有 — vxe seqConfig
+     * shows numbers only, no column letters): muted A/B/C… letter badges
+     * (`data-iris-cell-ref`) after every LEAF header title (A = first leaf;
+     * seq/selection/detail/drag columns are skipped, grouped leaves follow
+     * source order) plus a leading row-number column 1, 2, 3…
+     * (`data-iris-row-ref`). When `seq` is on the seq column IS the row
+     * number — no duplicate column. Additive — default off.
+     */
+    showCellRefs?: boolean;
+    /**
+     * Cell merge (vxe-grid spanMethod parity): return `{ rowspan, colspan }`
+     * for a cell at (rowIndex, columnIndex); both default 1. Values > 1 make
+     * the cell span adjacent cells (the spanned cells are skipped).
+     */
+    spanMethod?: (params: {
+        rowIndex: number;
+        columnIndex: number;
+    }) => {
+        rowspan?: number;
+        colspan?: number;
+    } | null | undefined;
+    /**
+     * Header merge (vxe-grid mergeHeaderCells parity, batch P): merge entries
+     * keyed by leaf-column index of the FLAT header row (`row` 0 only — rows
+     * > 0 are ignored). A merge cell renders with `gridColumnEnd: span
+     * colspan` / `gridRowEnd: span rowspan`; the covered cells render null.
+     * Grouped headers and `columnVirtualization` are not merged (documented
+     * simplification).
+     */
+    mergeHeaderCells?: IrisTableMergeCell[];
+    /**
+     * Footer merge (vxe-grid mergeFooterItems parity, batch R): declarative
+     * span entries in the SAME coordinate space as `footerSpanMethod` — `row`
+     * is the 0-based index over the rendered footer stack (footerMethod rows →
+     * summary row → footerData rows, whichever render) and `col` the
+     * leaf-column index; both start at 0. A merge cell renders `gridColumnEnd:
+     * span colspan`; the covered cells of the same row render null. `rowspan`
+     * is inert (each footer row is its own grid container — covered cells of
+     * later rows keep their own data; mirrors `footerSpanMethod`'s rowspan).
+     * The function wins: when `footerSpanMethod` is provided,
+     * `mergeFooterItems` is ignored. Entries outside the rendered stack are
+     * no-ops.
+     */
+    mergeFooterItems?: IrisTableMergeFooterItem[];
+    /**
+     * Row key fallback (vxe-grid deprecated string `rowId` parity, re-typed as
+     * a function, batch R): when a row lacks the `rowKey` field, this callback
+     * supplies the row's key — used by selection, expansion, dirty tracking,
+     * editing and tree flattening. `rowKey` wins over `rowId`; without either,
+     * the row index is used at index-bearing call sites (unchanged). The
+     * imperative handle's row ops, clipboard paste and find&replace write-backs
+     * still address rows by the `rowKey` field only (keyless rows are skipped
+     * there). */
+    rowId?: (row: Row, rowIndex: number) => string | number;
+    /** Row drag-sort configuration (composed over core createSortable). */
+    rowDrag?: {
+        /** Reorder callback — receives the reordered row array (parent owns data). */
+        onReorder: (rows: Row[]) => void;
+    };
+    /** Batch DQ (iris 独有): drop a dragged row on an external element whose `data-iris-drop-zone` value matches `key`; the parent owns the zone DOM. */
+    rowDragBetween?: IrisTableRowDragBetweenTarget<Row>[];
+    /** Inline-edit configuration (vxe-grid editConfig parity). */
+    editConfig?: {
+        /** What opens the editor. Default `'dblclick'`. */
+        trigger?: 'click' | 'dblclick' | 'manual';
+        /** Show a required asterisk next to headers of columns with rules. */
+        showAsterisk?: boolean;
+        /** Drop the draft when opening another cell without committing. */
+        autoClear?: boolean;
+        /** Edit mode (vxe editConfig.mode parity, batch K): `'cell'` (default) edits one cell at a time; `'row'` opens every editable column of the clicked row together — Enter/blur commits THAT column, Escape cancels the whole row, clicking another row commits the current row's open editors first. */
+        mode?: 'cell' | 'row';
+    };
+    /** Edit-validation presentation (vxe-grid ValidConfig parity). */
+    validConfig?: IrisTableValidConfig;
+    onCellEdit?: (event: IrisTableCellEditEvent<Row>) => void;
+    /** Edit start (vxe edit-activated parity, batch V): fired when an inline editor opens (cell double-click; cell mode only). */
+    onEditStart?: (params: IrisTableEditStartParams<Row>) => void;
+    /** Edit close (vxe edit-closed parity, batch V): fired when an edit session ends — `cancelled: false` carries the committed value, `cancelled: true` when Escape discarded it. Cell mode only (see `TableTypes.IrisTableEditClosedParams`). */
+    onEditClosed?: (params: IrisTableEditClosedParams<Row>) => void;
+    /** Batch BQ (iris 独有): auto-save committed inline edits — after a successful commit, fire `onAutosave` with the post-commit row list (parent persistence hook; orthogonal to `onDataChange`, which inline edits never trigger). `editAutosave` is the feature switch — `onAutosave` alone is inert (keymap precedent). No-op commits (same value), cancelled (Escape) and validation-failed edits never fire; row edit mode fires per committed column. */
+    editAutosave?: boolean;
+    /** Batch BQ (iris 独有): parent persistence hook fired by `editAutosave` with the post-commit row list. */
+    onAutosave?: (rows: Row[]) => void;
+    /** Batch CC (iris 独有): textarea editors auto-grow their height with content — 1 row to start, up to a 6-row cap, then scroll inside the editor (measured via scrollHeight on input, no re-render loop). Off by default (fail-closed; batch I's rows=3 stays). */
+    editAutoHeight?: boolean;
+    /** Batch CG (iris 独有 — vxe has no equivalent; Excel-style status-bar parity):
+     * a live character count in the editing cell's bottom-right corner (cell AND
+     * row edit modes, recomputed per keystroke from the session draft) plus a
+     * cell-count/sum badge at the selected range's bottom-right cell when
+     * `cellRange` has a live selection (a pure reduction over the rangeStats
+     * material — count = Σ column non-null counts, sum = Σ numeric column sums,
+     * `null` = no numeric data — rounded via the same `aggregateAccuracy` gate as
+     * the summary row). Additive; default off (fail-closed).
+     */
+    charCount?: boolean;
+    /** Batch CQ (iris 独有 — vxe has no equivalent): show a live preview of the
+     * formatter-applied result below the editing cell — recomputed per keystroke
+     * from the session draft through the SAME display chain as the committed cell
+     * (mask → formatter, with the commit path's draft coercion for number/select
+     * editors), rendered as a muted small line (`data-iris-edit-preview`). Only
+     * columns with a `formatter` render a preview. Additive; default off
+     * (fail-closed).
+     */
+    editPreview?: boolean;
+    /** Batch DH (iris 独有 — vxe has no equivalent; data-consistency assist):
+     * while an inline (cell-mode) editor is open, every other cell in the SAME
+     * column whose committed value exactly matches the current draft renders a
+     * light highlight (`data-iris-input-hint` + a `--iris-input-hint` token
+     * background) — a glanceable "these rows already share this value" cue
+     * while typing. Matching is RAW (`String(raw) === String(draft)`, same
+     * draft caliber as the editor/commit path — not the masked/formatted
+     * display). The editing cell itself is exempt. An empty draft is
+     * fail-closed (never floods the whole column). Computed live per keystroke
+     * via the existing cell-edit store — zero new state. Row-edit mode is a
+     * documented fiat: each column's draft lives in its own session, so row
+     * mode does not participate. Additive; default off (fail-closed).
+     */
+    pattern?: boolean;
+    /** Batch DL (iris 独有): alias for the pattern-edit consistency hint. While
+     * an inline draft is open, matching committed values in the same column get
+     * `data-iris-input-hint`; kept as a separate switch for the batch contract. */
+    patternFill?: boolean;
+    /** Batch EB (iris 独有 — vxe has no column access stats): count per-column
+     * cell clicks and inline-edit opens (SESSION-local internal counting — no
+     * core controller, no persistence, no clear channel). Every cell click
+     * counts ONCE through exactly one path — row-edit mode counts the clicked
+     * row's columns (a click + one edit per editable column opened), cell-range
+     * clicks count the clicked column, click-trigger edits count as BOTH a
+     * click and an edit; paste/fill, header clicks and keyboard-opened editors
+     * never add clicks. `handle.getColumnStats()` returns the `{ key, clicks,
+     * edits, total }` snapshot (total desc, key asc tiebreak; `[]` when off or
+     * idle) and the toolbar `▦` trigger opens the top-5 panel. The counting
+     * bumps are plain functional setState — the opt-in re-render cost is
+     * documented (off = zero cost, no bumps, no re-renders). Additive; default
+     * off (fail-closed). */
+    columnStats?: boolean;
+    /** Batch CR (iris 独有 — vxe has no equivalent; Excel status-bar parity):
+     * show a full-width horizontal strip directly below the toolbar
+     * (`data-iris-column-totals`) with the column totals for every
+     * `summary === 'sum'` column — aggregated over the CURRENT body rows with
+     * the exact summary-row value pipeline (`aggregate` + the
+     * `aggregateAccuracy` rounding gate + `renderSummary` fallback), one grid
+     * cell per leaf column (`data-iris-column-totals-cell`) so tracks stay
+     * aligned; non-sum columns render empty placeholders. The strip shows even
+     * with an empty body (`0`). Additive; default off (fail-closed).
+     */
+    columnTotals?: boolean;
+    /** Batch CS (iris 独有 — vxe has no equivalent; vxe keeps the pixel offset, never re-anchors).
+     * In virtual mode, an expansion commit re-locates the first visible row
+     * (the content anchor, with its partial offset) in the NEW plan and
+     * writes `newIndex × slotHeight + relativeTop` — the rows under the
+     * cursor stay put across tree/detail expand AND collapse. Uniform slot
+     * heights only (`rowHeight`/`virtualScroll.itemHeight` functions are
+     * pixel-only — the variable-height offset tree is child-internal);
+     * non-virtual tables are inert (documented fiat); full-set restores
+     * (`expandAll` / `persistState` replay) fall back to the virtualizer's
+     * re-clamp; a single-key commit stays exact. Additive; default off
+     * (fail-closed).
+     */
+    expandScrollPreserve?: boolean;
+    /** Batch CJ (iris 独有 — vxe has no shortcut help): show a `?` toolbar
+     * trigger that opens a floating panel listing every built-in keyboard
+     * shortcut with its EFFECTIVE key — the same normalized map every handler
+     * matches against, so `keymap` remaps reflect live and a listed key always
+     * actually works. Read-only reference (no rebind UI). Additive; default
+     * off (fail-closed).
+     */
+    shortcutHints?: boolean;
+    /** Header select-all toggle (additive — not in vxe's emits, batch V): fired with the PRE-toggle header state and the current selection keys. */
+    onSelectAllChange?: (state: boolean | 'indeterminate', selection: Array<string | number>) => void;
+    /** Root scroll (vxe scroll parity, batch V): `{ scrollTop, scrollLeft }` of the root container; fires in column-virtualization mode and via a native listener otherwise (only meaningful with `height`, else overflow is hidden). */
+    onScroll?: (params: IrisTableScrollParams) => void;
+    /** Render an expandable detail panel beneath a row. */
+    renderDetail?: IrisTableRenderDetail<Row>;
+    /** Which rows can expand a detail panel. */
+    rowExpandable?: IrisTableRowExpandable<Row>;
+    /** Initially-expanded row keys (uncontrolled). Shared by detail rows + tree rows. */
+    defaultExpandedRowKeys?: Array<string | number>;
+    /** Expand every tree row that has children on mount (vxe expand-config
+     * expandAll parity). One-shot: seeds the expansion model with all tree keys
+     * on the first data arrival (proxy pages load async). Default false. */
+    expandAll?: boolean;
+    /** Notified with the expanded row keys whenever they change (batch BY: also the restore channel for `persistState`'s `expandedKeys` piece — the model commit replays this callback). */
+    onExpandedRowsChange?: (keys: Array<string | number>) => void;
+    /** Detail expand toggle (vxe toggle-row-expand parity): `expanded` is the NEW state after the toggle. */
+    onExpandChange?: (row: Row, expanded: boolean) => void;
+    /** Tree expand toggle (vxe toggle-tree-expand parity): `expanded` is the NEW state after the toggle. */
+    onTreeExpandChange?: (row: Row, expanded: boolean) => void;
+    /** Read a row's child rows to render the table as a tree. */
+    getSubRows?: (row: Row) => Row[] | undefined;
+    /** Lazy tree (vxe lazyLoad parity): a row with no `getSubRows` children still renders a caret; the first expand calls this and `load` resolves the children (expanding the row). */
+    lazyLoad?: (row: Row, load: (children: Row[]) => void) => void;
+    /** Batch CL (iris 独有 — vxe has no expand animation):
+     * animate detail-panel and tree-row expansion with a max-height + opacity
+     * enter transition (token-driven — `--iris-table-expand-max` cap and
+     * `--iris-duration-md` duration, both with fallbacks;
+     * `prefers-reduced-motion: reduce` turns the animation off entirely).
+     * Pure CSS entrance — zero state/effect; root tree rows (depth 0) stay
+     * static. Inert in virtual mode (lazy slots would replay the animation on
+     * scroll-mount). Additive; default off (fail-closed).
+     */
+    expandAnimation?: boolean;
+    /**
+     * Enable WAI-ARIA grid keyboard navigation (single-tabstop roving cell
+     * focus). Arrow keys move one cell; Home/End jump to the row's first/last
+     * cell; PageUp/PageDown jump 10 rows (clamped; virtual tables also scroll
+     * the viewport ±10 × row height); Tab/Shift+Tab move row-major to the
+     * next/prev cell (clamped at the bounds — no wrap, focus never leaves the
+     * table); Enter is an alias of ArrowDown (F2 stays the edit-start key).
+     * While an inline editor is open the editor's own keys win — Tab commits
+     * and moves to the next editable column (batch J), unchanged.
      */
-    query: (params: IrisTableProxyQueryParams) => Promise<{
-        rows: Row[];
-        total: number;
-    }>;
-    /** Auto-load the first page on mount (vxe autoLoad parity). Default true. */
-    autoLoad?: boolean;
-    /** Sort changes re-query the server instead of sorting client-side (vxe proxyConfig.sort). Default false. */
-    remoteSort?: boolean;
-    /** Filter changes re-query the server instead of filtering client-side (vxe proxyConfig.filter). Default false. */
-    remoteFilter?: boolean;
-    /** Rows per page. Default 10. */
-    pageSize?: number;
-    /** Initial page (1-based). Default 1. */
-    defaultPage?: number;
-    /** Fired when the page changes. */
-    onPageChange?: (page: number, pageSize: number) => void;
-}
-/**
- * Search-form configuration (vxe-grid formConfig parity). Renders a field row
- * above the toolbar (or the table root). Submit merges the values into the
- * table filters: client-side via the existing `filteredData` path, or into the
- * proxy query (`setParams({ filters, page: 1 })`) when `proxyConfig` is set.
- */
-interface IrisTableFormConfig {
-    fields: IrisTableFormField[];
-    /** Label of the submit button. Defaults to the i18n `table.formSubmit` key. */
-    submitText?: string;
-    /** Label of the reset button. Defaults to the i18n `table.formReset` key. */
-    resetText?: string;
-    /** Fired on submit with every field's value (empty strings stripped). */
-    onSearch?: (values: Record<string, string>) => void;
-    /** Fired on reset with the reset values (defaults re-applied). */
-    onReset?: (values: Record<string, string>) => void;
-}
-/**
- * Imperative row operations (vxe-grid insert/remove/setRow parity, simplified
- * to key addressing). Assigned to `tableRef.current` on mount; every op
- * applies a core pure helper to the live row list, commits through the same
- * write-back channel as cell edits, and fires `onDataChange` with the new
- * list. Not-found keys are silent no-ops (the core helpers return the
- * original reference).
- */
-interface IrisTableHandle<Row extends Record<string, unknown> = Record<string, unknown>> {
-    /** Insert a row at `index` (default: end). A missing `rowKeyField` value gets an auto id. */
-    insertRow: (row: Row, index?: number) => void;
-    /** Remove the row with `key`; its selection is pruned. */
-    removeRow: (key: string | number) => void;
-    /** Patch the row with `key` ({ ...row, ...patch }). */
-    updateRow: (key: string | number, patch: Partial<Row>) => void;
-    /** Re-fetch the current page (proxy mode). */
-    refetch: () => void;
-    /** Clear every selected row (vxe clearCheckboxRow parity). */
-    clearSelection: () => void;
-    /** Select every checkMethod-eligible row of the current page (vxe
-     * setAllCheckboxRow(true) parity — `checkMethod` rows are skipped). */
-    selectAll: () => void;
-    /** Toggle a single row's selection by key (vxe toggleCheckboxRow parity —
-     * a direct toggle that bypasses `checkMethod`). */
-    toggleRowSelection: (key: string | number) => void;
-}
-/** Pager configuration (vxe-grid pagerConfig parity). */
-interface IrisTablePagerConfig {
-    /** Rows-per-page options rendered as a size selector next to the pager. A
-     * change re-queries with the new size and resets the page to 1. */
-    pageSizes?: number[];
-}
-/** Public input surface for the React table adapter. */
-interface IrisTableProps<Row extends Record<string, unknown> = Record<string, unknown>> {
+    keyboardNavigation?: boolean;
+    /** Batch AN shortcuts (iris 独有 — vxe keyboardConfig has no edit/clear
+     * keys): F2 begins editing the focused cell's column (when editable),
+     * Delete/Backspace clears it to `''` — one batched `commitRowList`
+     * (undo-covered via the undo funnel). Requires `keyboardNavigation`'s
+     * focused-cell state (single-tabstop roving cell focus); without it the
+     * shortcuts are inert. While an inline editor is open the editor's own
+     * keys win. Additive — default off. */
+    tableShortcuts?: boolean;
+    /** Batch DR (iris 独有): edit keys for the focused editable cell. F2 is
+     * always included when this prop is present; Enter and Space extend it. */
+    editKeys?: Array<'F2' | 'Enter' | 'Space'>;
+    /** Batch BG (iris 独有 — vxe keyboardConfig has no rebinding): rebind the
+     * built-in shortcut keys. ONE key spec string per action
+     * (`Modifier+Key`, case-insensitive; `Ctrl`/`Cmd`/`Meta` share one
+     * ctrl-or-meta flag — `Ctrl+C` matches Ctrl OR Cmd). Actions:
+     * `edit` (default F2) / `clear` (Delete, Backspace) need `tableShortcuts`;
+     * `undo` (Ctrl+Z) / `redo` (Ctrl+Y, Ctrl+Shift+Z) need `undo`;
+     * `copy` (Ctrl+C) / `paste` (Ctrl+V) need `clipConfig`;
+     * `fill` (Ctrl+D — one-step drag-down) needs `rangeFill` + a live range;
+     * `query` (Ctrl+K — focuses the query input) needs the controlled `query`.
+     * An override REPLACES that action's bindings wholesale (aliases included);
+     * invalid specs (`''` / `'Meta'` / `'Ctrl+'` …) are dropped fail-closed —
+     * the action keeps its default. Modifiers match exactly: `Ctrl+Shift+Z`
+     * redoes, `Alt+Ctrl+Z` is inert. Additive — default off (defaults unchanged). */
+    keymap?: Partial<Record<_iris_ui_kit_core.IrisTableKeyAction, string>>;
+    /** Batch DJ (iris 独有 — vxe keyboardConfig has no focus gate): shortcut
+     * scope for the table's WINDOW keydown listeners (undo/redo, clip
+     * copy/paste, fnr Ctrl+F + Escape, batch-edit Escape). `hotkeyScope`
+     * (default `true`) gates the shortcuts to fire only while the focus is
+     * INSIDE the table (`rootRef.contains(e.target)` — the focused element,
+     * read live from the keydown target, no extra focus/blur state). Set it to
+     * `false` for the permissive compatibility mode where the same bindings
+     * fire regardless of where the focus is. `outerScope` (default `false`)
+     * forces the GLOBAL scope (fire from anywhere) and wins over
+     * `hotkeyScope`. Fail-closed by default: fnr/batch-edit tighten from
+     * anywhere → in-table; undo/clip keep their existing in-table behavior. */
+    hotkeyScope?: boolean;
+    /** Force GLOBAL shortcut scope (fire from anywhere, ignoring
+     * `hotkeyScope`). Default `false`. */
+    outerScope?: boolean;
+    /** Batch BS (iris 独有 — vxe group-config has no multi-column grouping): table-level NESTED multi-column grouping. Array elements are leaf column `key`s; their order defines the nesting levels (`['dept','status']` → `dept` level 0 → `status` level 1). Every level renders its own collapsible group header (indented by depth, `data-iris-group-depth`); a parent group's count is the subtree row total; the per-group summary row (`summary` ops) appears only on the innermost level. Composite group keys join the level values with `::` (`data-iris-group-key`), so `groupCollapsed`/`defaultGroupCollapsed` address nested groups directly (`'Engineering::Active'`) and a collapsed parent hides its whole subtree. When set, the array WINS over any column-level `groupBy: true` flag; absent/empty/unknown-only → the single-column batch M/BH path runs byte-identical (the array's level-0 fallback). Unknown keys are dropped, duplicates keep the first occurrence. Inert in tree mode (fail-closed, like column grouping). */
+    groupBy?: string[];
+    /** Batch BH (iris 独有 — vxe group-config has no collapse): controlled set of
+     * collapsed group keys. Keys are `String(cell value)` of the `groupBy` column —
+     * the same identity `data-iris-group-key` carries. When set, the rendered body
+     * only changes after the parent writes the prop back (no optimistic flip).
+     * Inert without `groupBy` / in tree mode. */
+    groupCollapsed?: Array<string | number>;
+    /** Default collapsed group keys (uncontrolled mode). */
+    defaultGroupCollapsed?: Array<string | number>;
+    /** Fired on every group-header toggle with the next collapsed keys, in BOTH
+     * controlled and uncontrolled modes (lift-ready). */
+    onGroupCollapseChange?: (next: Array<string | number>) => void;
+    /** Enable virtual scrolling for the body. */
+    virtualScroll?: IrisTableVirtualOptions;
+    /** Per-row height (batch BN, iris 独有 — vxe row-height is a fixed config value). Number → uniform height (overrides the default AND `virtualScroll.itemHeight` in virtual mode); `(index) => number` → per-row heights — in virtual mode the fn feeds the variable-height virtualizer (virtual PLAN index, prefix-sum offsets, like `virtualScroll.itemHeight`), otherwise each body row gets its inline height (bodyData index). `rowStyle` stays the per-row escape hatch (it wins). */
+    rowHeight?: number | ((index: number) => number);
+    /** Batch EC (iris 独有 — vxe autoHeight fills rows to the VIEWPORT instead; there is no content-wrap display row): when NO fixed row height is set — `rowHeight` and `virtualScroll.itemHeight` both absent — DATA rows grow to their content. The one-line clamp (nowrap + ellipsis) is released for data-row cells via a CSS root marker (`data-iris-adaptive-height`) and each data row's height is pinned to its MEASURED rendered height (a dependency-free layout effect reads `offsetHeight` after every commit, diffs once, same-value bail — no re-render loops; window resize + a ResizeObserver re-measure; data/edit/font/density changes self-heal through the per-commit effect), so a textarea/paragraph cell renders fully instead of being clipped at one line. Header/summary/footer/state rows stay nowrap; virtual tables and tables with a fixed `rowHeight` are inert (uniform slots). Rows that measure `≤ 0` (jsdom/SSR/hidden) keep natural height — never a 0px collapse. `rowStyle` stays the per-row escape hatch (it wins). Additive; default off (fail-closed — the nowrap base renders byte-identical). */
+    adaptiveRowHeight?: boolean;
+    /** Persist view state across remounts (batch AG, iris 独有 — vxe has no built-in persistence). Loads sort / multiSortState / filters / filterValues / columnVisibility / columnOrder / columnWidths / pageSize / expandedKeys on mount (replayed through the matching change callbacks) and saves the CURRENT props on every change (the table is controlled). pageSize is only meaningful with proxyConfig.onPageChange (restored via onPageChange(1, restored) before the first query); expandedKeys (batch BY) needs onExpandedRowsChange + an expandable table (renderDetail or tree) — restored through the expansion model, which replays the callback (full-set replace); storage: false fully disables persistence (no reads, no writes); default key 'iris-table-state'. */
+    persistState?: IrisTablePersistConfig;
+    /** Batch DM (iris 独有): periodically persist the complete exported view
+     * state to a separate storage key and restore it once on mount. */
+    autoSaveState?: IrisTableAutoSaveStateConfig;
+    /** Batch DV (iris 独有 — vxe has no URL-state concept): deep-linkable view
+     * state — when `true`, the table mirrors sort / sorts (multiSort mode) /
+     * filters / filterValues / page+pageSize (proxy only) into ONE `_table`
+     * query param (`history.replaceState`, other params preserved; empty state
+     * removes it) and restores from the URL on mount (URL wins over
+     * `persistState` on conflicts) and on `hashchange`/`popstate` (share-link
+     * support). Each piece follows the SAME per-piece callback gates as
+     * `persistState` (onSortChange / onMultiSortChange / onFiltersChange /
+     * onFilterValuesChange / proxy onPageChange) — an uncontrolled piece is
+     * inert in both directions. Decode is whole-state fail-closed: a corrupt /
+     * wrong-version payload is ignored entirely, never partially restored.
+     * Default off. */
+    urlState?: boolean;
+}
+
+interface IrisTableLayoutProps<Row extends Record<string, unknown> = Record<string, unknown>> {
     columns: IrisTableColumn<Row>[];
     /** Table data. Optional when `proxyConfig` is set (server-side source). */
     data?: Row[];
@@ -2697,6 +3907,18 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
     striped?: boolean;
     /** Size preset (vxe-grid size parity): medium / small / mini. */
     size?: 'medium' | 'small' | 'mini';
+    /**
+     * Row-density preset (iris 独有 — vxe has no density concept): three tiers
+     * of row/cell padding stacked on top of `size` (both write
+     * `--iris-cell-pad-y`; density wins on ties). Default comfortable.
+     */
+    density?: IrisTableDensity;
+    /**
+     * Toolbar density-toggle button (iris 独有 — vxe has no density toggle):
+     * cycles comfortable → compact → cozy → comfortable; while shown, the
+     * button state wins over the `density` prop.
+     */
+    densityToggle?: boolean;
     /** First sequence number (vxe seq-config.startIndex parity). Default 1. */
     seqStartIndex?: number;
     /** Custom sequence renderer (vxe seq-config.seqMethod parity). */
@@ -2711,6 +3933,8 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
     currentColumnKey?: string;
     /** Fired when the current column changes (header click). */
     onCurrentColumnChange?: (key: string) => void;
+    /** Header cell click (vxe header-click parity). Fired after the sort toggle on sortable headers. */
+    onHeaderClick?: (column: IrisTableColumn<Row>) => void;
     /** Veto a current-column change: return false to keep the previous column. */
     beforeCurrentColumnChange?: (key: string) => boolean | void;
     /** Hide the header row(s) (vxe show-header parity). Default true. */
@@ -2720,6 +3944,51 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
      * row, one grid row per entry; structure matches `data`.
      */
     footerData?: Row[];
+    /** Custom footer rows (vxe footer-method parity, batch N): one grid row per returned entry, cell value = `entry[col.key]`, same styling as the summary row; `footerData` renders below. `columns` = leaf columns, `data` = full filtered rows. */
+    footerMethod?: (params: IrisTableFooterMethodParams<Row>) => Row[];
+    /** Footer cell merge (vxe footer-span-method parity, batch P): `colspan` > 1 spans adjacent cells (covered cells skipped, same occupy pattern as `spanMethod`); `rowspan` inert (each footer row is its own grid container). Applies over the footer stack in order: footerMethod rows → summary row → footerData rows; `rowIndex` is 0-based over that stack, `columns` = leaf columns, `data` = full filtered body rows. Group summary rows are not part of the stack. */
+    footerSpanMethod?: IrisTableFooterSpanMethod<Row>;
+    /** Header cell alignment (vxe header-align parity): `headerAlign` wins over
+     * the column's `align`, then 'left'. Applies to flat + grouped headers. */
+    headerAlign?: IrisTableAlign;
+    /** Footer/summary cell alignment (vxe footer-align parity): `footerAlign`
+     * wins over the column's `align`. Applies to summary, footer-method, footer-data. */
+    footerAlign?: IrisTableAlign;
+    /**
+     * Auto-detect column types (batch CX, iris 独有 — vxe requires the caller
+     * to declare `sortType` per column; no auto inference): on FIRST data
+     * arrival, each leaf column's value kind (`string`/`number`/`date`/
+     * `boolean`) is inferred by the core `detectColumnType` from its first 50
+     * non-nullish values (all-samples-agree; mixed columns and numeric/boolean
+     * STRINGS fall back to `string`). Detected columns receive the matching
+     * default alignment + `sortType` — `number` → right-aligned + `'number'`
+     * sort, everything else → left + `'string'` — filling ONLY the fields the
+     * caller left `undefined` (explicit `align`/`sortType` always win; preset
+     * defaults survive). One-shot per mount (later data re-feeds never
+     * re-detect); SSR-safe (effect-driven, the fill lands post-hydration).
+     * Default false — byte-identical with the pre-prop render path.
+     */
+    autoDetectTypes?: boolean;
+    /** Batch CM (iris 独有 — vxe has no summary sticky parity): `'sticky'` pins
+     * the GLOBAL summary row (op row or footerMethod rows — the two renders
+     * that occupy the same footer slot) to the viewport's bottom edge inside
+     * the fixed-height scroll container (`position: sticky; bottom: 0`;
+     * gated by `[data-iris-table-fixed-height]`, same z-index 1 as pinned
+     * columns). Two explicit fiats: per-group summary rows never stick (groups
+     * would fight over the bottom edge) and footerData rows never stick
+     * (contractually rendered below the summary). Pure CSS additive; default
+     * `'default'` — fail-closed, no sticky attr. */
+    summaryRowStyle?: 'default' | 'sticky';
+    /**
+     * Decimal places for summary/footer aggregate values (vxe
+     * aggregateAccuracyConfig parity, batch P): a finite numeric op result is
+     * rounded via `Number(value.toFixed(n))` at the single summary point
+     * (global + per-group summaries), before `renderSummary` — custom renderers
+     * see the rounded value. Non-finite results are left untouched. Values
+     * outside 0–100 (inclusive) are ignored — no rounding (`toFixed`
+     * RangeError guard). Default: no rounding.
+     */
+    aggregateAccuracy?: number;
     /** Per-row class hook (vxe row-class-name parity). */
     rowClassName?: (row: Row, rowIndex: number) => string;
     /** Per-cell class hook (vxe cell-class-name parity). */
@@ -2729,25 +3998,141 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
     /** Per-footer-cell class hook (vxe footer-cell-class-name parity). */
     footerCellClassName?: (column: IrisTableColumn<Row>, rowIndex: number) => string;
     /** Per-row inline style hook (vxe row-style parity). */
-    rowStyle?: (row: Row, rowIndex: number) => CSSProperties;
+    rowStyle?: (row: Row, rowIndex: number) => React.CSSProperties;
     /** Per-cell inline style hook (vxe cell-style parity). */
-    cellStyle?: (row: Row, column: IrisTableColumn<Row>, rowIndex: number) => CSSProperties;
+    cellStyle?: (row: Row, column: IrisTableColumn<Row>, rowIndex: number) => React.CSSProperties;
+    /** Conditional cell styles (batch AX, iris 独有): an ordered rule list merged onto matching body cells AFTER `cellStyle` — later matching rules win on conflicting keys. A rule matches when its `column` filter (omitted → every column) equals the cell's column key AND `when(row, value)` is true; `value` is the RAW cell value (dataIndex ?? key resolved, formula columns computed). Rules evaluate inline per visible cell (cost = visibleCells × rules; virtual scroll bounds it — memoize the array in the caller). */
+    conditionalStyles?: IrisTableConditionalStyle<Row>[];
+    /** External table data for cross-table formula refs (batch BC, iris 独有): `=other!col` reads `formulaTables['other'][0]['col']` (the FIRST row of the named table). Missing tables arg / unknown table / EMPTY table / unknown field → the whole formula null (fail-closed); a known nullish field coerces (Excel parity). Immutable contract: pass a NEW object when referenced tables change. */
+    formulaTables?: Record<string, Row[]>;
+    /** Extra row sets appended to `handle.exportMultiCsv()` (batch DI, iris 独有 — vxe has no multi-file export): each entry names a referenced table whose BARE rows (`Row[]`, no column definitions — they're not IrisTable column configs) are serialized by their OWN enumerable keys (first row's keys are the header), NOT by this table's columns. `key` is both the `# <key>` segment header and (documented) the section name; `ref` is called lazily at export time (handle call, not render) so it can read the live source rows of that table. Empty/absent `exportNames` → `exportMultiCsv()` falls back to the bare current-table CSV, byte-identical to `exportCurrentViewCsv()`. An entry with an empty `key` is skipped entirely; an empty ref row set emits just the segment header. Immutable contract: pass a NEW array when the set changes. */
+    exportNames?: Array<{
+        key: string;
+        ref: () => Row[];
+    }>;
     /** Per-header-cell inline style hook (vxe header-cell-style parity). */
-    headerCellStyle?: (column: IrisTableColumn<Row>) => CSSProperties;
+    headerCellStyle?: (column: IrisTableColumn<Row>) => React.CSSProperties;
     /** Per-footer-cell inline style hook (vxe footer-cell-style parity). */
-    footerCellStyle?: (column: IrisTableColumn<Row>, rowIndex: number) => CSSProperties;
+    footerCellStyle?: (column: IrisTableColumn<Row>, rowIndex: number) => React.CSSProperties;
+    /**
+     * Unified event stream (batch DW, iris 独有 — vxe has no single event bus):
+     * cell/row click, sort, filter, edit and expand events merged into ONE
+     * subscription. The bus fires AFTER the matching dedicated callback (if
+     * wired) — a bridge, not a behavior, so gate parity holds by construction
+     * (no `onCellClick`/`rowMode` → no cell-click event). `type` is one of the
+     * closed `IrisTableEvent` palette; `detail` carries the SAME params the
+     * dedicated callback receives (reference-identical `detail.row`/`column`).
+     * Controllable proxy `sort` updates (a parent-driven `sort`/`multiSortState`
+     * prop change — not a user click) fire no event. The expansion family
+     * mirrors the shared `onExpandedRowsChange` channel: EVERY model commit
+     * fires `expanded-rows-change` — user toggles, `expandAll` seeding, and
+     * `persistState`/view `expandedKeys` restores all replay through the
+     * expansion model's `onChange` (a restore still needs `onExpandedRowsChange`
+     * + an expandable table — the same gate as the dedicated callback).
+     */
+    onTableEvent?: (event: {
+        type: string;
+        detail: unknown;
+    }) => void;
     /** Cell click (vxe cell-click parity). Fired after internal handlers. */
     onCellClick?: (params: IrisTableCellClickParams<Row>) => void;
+    /** Cell double-click (vxe cell-dblclick parity). Fired AFTER the inline edit starts on editable columns; non-editable columns fire it too. */
+    onCellDblClick?: (params: IrisTableCellClickParams<Row>) => void;
     bordered?: boolean;
+    /**
+     * Rounded root corners (vxe-grid round parity, batch P): the root gets
+     * `border-radius: var(--iris-radius-lg, 10px)` when `bordered && round`;
+     * otherwise the default md radius applies.
+     */
+    round?: boolean;
+    /**
+     * Cell padding override (vxe-grid deprecated `padding` parity, batch P):
+     * sets `--iris-cell-pad` on the root; every cell padding reads
+     * `var(--iris-cell-pad, var(--iris-cell-pad-y, 8px) 12px)`, so the size
+     * presets (small/mini) still win through `--iris-cell-pad-y`.
+     */
+    padding?: string;
     /** Enable column resizing (drag the header's trailing edge or focus + arrow keys). */
     resizableColumns?: boolean;
+    /** Batch DS (iris 独有): show the live pixel width while a resize drag is active. */
+    widthHint?: boolean;
+    /**
+     * Auto-fit column widths on double-click (iris 独有, batch DG — vxe has no
+     * auto-resize): when true (WITH `resizableColumns`, so the handle exists),
+     * double-clicking a column boundary measures the widest rendered content
+     * (header + body cells, `scrollWidth` already includes both-side padding)
+     * and writes the clamped width via `onColumnWidthsChange` (the same duck
+     * channel as drag/keyboard). Falls back fail-closed: no handle without
+     * `resizableColumns`; virtual scrolling measures only the rendered window
+     * (vxe autoResize behavior). Additive — default off.
+     */
+    autoResizeColumns?: boolean;
     /** Controlled per-column pixel widths, keyed by column `key`. */
     columnWidths?: IrisTableColumnWidths;
     defaultColumnWidths?: IrisTableColumnWidths;
     onColumnWidthsChange?: (next: IrisTableColumnWidths) => void;
+    /**
+     * Toolbar reset-widths button (iris 独有, batch BO): clicking it calls
+     * `onColumnWidthsChange({})` — the empty map means zero overrides, so every
+     * column falls back to its declared width. Like `zoomConfig`, this prop
+     * alone does not create the toolbar.
+     */
+    columnWidthsReset?: boolean;
+    /**
+     * Column header pin menu (batch BX, iris 独有 — vxe has no built-in
+     * header pin menu): when true, right-clicking a column HEADER opens a
+     * built-in menu — 固定左 (key `__iris-pin-left`) when the column is not
+     * pinned, 取消固定 (key `__iris-unpin`) when it is pinned left OR right
+     * (the item flips with the column's CURRENT pin state, single and mutually
+     * exclusive — spec has no pin-right action). The menu is fully independent
+     * of `contextMenu` (which only opens on body cells and never on headers):
+     * `columnPinMenu` works with NO `contextMenu` configured, and the two are
+     * separate floating instances — opening one closes the other. Every action
+     * fires `onColumnPinnedChange` in BOTH controlled and uncontrolled modes
+     * (`onColumnWidthsChange` dual-channel precedent, no optimistic flip when
+     * controlled); without `pinnedColumns` the table holds the pin state
+     * internally and the static `col.pinned` declaration seeds the fallback.
+     * Additive — default off.
+     */
+    columnPinMenu?: boolean;
+    /**
+     * Controlled per-column pin state (batch BX): column key → `'left'` /
+     * `'right'` / `null` (unpinned). When set, the map is the ONLY read source
+     * for the rendered pin state — an explicit `null` entry overrides a static
+     * `col.pinned` declaration (controlled-null-wins); absent keys fall back to
+     * the column's own declaration, so `{}` never unpins static pins.
+     */
+    pinnedColumns?: Record<string, 'left' | 'right' | null>;
+    /**
+     * Fired on every pin-menu action with the column key and the next side
+     * (`null` = unpin), in both controlled and uncontrolled modes (lift-ready).
+     */
+    onColumnPinnedChange?: (key: string, side: 'left' | 'right' | null) => void;
+    /**
+     * Pinned-count boundary drag (batch CV, iris 独有 — vxe has no pinned
+     * boundary handle): when true, the LAST left-pinned leaf header's trailing
+     * edge carries a draggable separator handle (8px grip + 2px primary line,
+     * sticky inside the pinned cell) that adjusts the number of left-pinned
+     * columns — drag right pins more / drag left unpins, commit-on-release (a
+     * translateX ghost follows the pointer while dragging); Arrow-Left/Right
+     * nudge the count by one. The commit writes `setColumnPinned('left' |
+     * null)` per CHANGED column (the SAME dual-channel throat as the pin menu —
+     * `onColumnPinnedChange` fires per column in both modes, no optimistic
+     * flip when controlled) and then fires `onPinnedCountChange` once; no-op
+     * drags fire nothing. Left-only count: no handle without at least one
+     * left-pinned column; the boundary never crosses the first right-pinned
+     * index (hard cap); widths approximate via the pinnedOffsets fallback
+     * chain (non-numeric → default, fiat). While on, the boundary column's
+     * `resizableColumns` handle is suppressed (a resize grip on the same edge
+     * would fight the boundary drag). Additive — default off.
+     */
+    pinnedDrag?: boolean;
+    /** Fired once per pinned-boundary commit with the new left-pinned column count (0 = none), AFTER the per-column `onColumnPinnedChange` calls. */
+    onPinnedCountChange?: (count: number) => void;
     /** Called when a data row is clicked. Interactive child controls stop propagation. */
     onRowClick?: (row: Row, rowIndex: number) => void;
-    /** Called when an inline-editable cell is committed with a changed value. */
+    /** Row double-click (vxe row-dblclick parity). */
+    onRowDblClick?: (row: Row, rowIndex: number) => void;
     /**
      * Column visibility (vxe-grid columnConfig.visible parity). Map of
      * column key → visible (default true). Hidden columns are not rendered.
@@ -2756,13 +4141,31 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
     /** Fired when visibility changes (parent owns the map). */
     onColumnVisibilityChange?: (next: Record<string, boolean>) => void;
     /**
-     * Client-side filters (vxe-grid filterConfig parity, local mode). Map of
-     * column key → filter text; rows are filtered with the core filterSort
-     * material (substring, case-insensitive).
+     * Column show/hide transition (batch DY, iris 独有 — vxe has no fade): when
+     * true, `columnVisibility` changes play a 200ms opacity + width transition
+     * instead of snapping — a hiding column keeps its cells mounted while its
+     * track collapses Wpx→0px and opacity fades to 0, then commits away; a
+     * showing column mounts at 0px/opacity 0 and restores both. The duration is
+     * token-driven (`--iris-duration-md`, fallback 200ms) and the whole machine
+     * is disabled under `prefers-reduced-motion` (instant show/hide, vxe
+     * parity). Mount-hidden columns never animate (only later toggles play); a
+     * mid-fade revert restarts the fade in the new direction. Pure render-side
+     * additive — `columnVisibility`/`onColumnVisibilityChange` keep their exact
+     * semantics. Default false — byte-identical with the pre-prop render path.
      */
+    columnFade?: boolean;
+    /** Controlled column order (vxe customConfig parity): the panel's drag list reorders these keys; unnamed keys follow in source order, unknown keys ignored. Top-level columns only. */
+    columnOrder?: string[];
+    /** Fired when the panel confirms a new order. `undefined` clears the order (parent drops `columnOrder`). */
+    onColumnOrderChange?: (order: string[] | undefined) => void;
+    /** Client-side filters (vxe-grid filterConfig parity, local mode): column key → filter text; rows filtered with the core filterSort material (substring, case-insensitive). */
     filters?: Record<string, string>;
-    /** Fired when a filter value changes (parent owns the map). */
+    /** Fired when a filter value changes (parent owns the map). Batch T: this IS the text filter channel (vxe filter-change parity) — a separate `onFilterChange` prop was intentionally NOT added; checked sets use `onFilterValuesChange`. */
     onFiltersChange?: (next: Record<string, string>) => void;
+    /** Per-column checked filter sets (vxe filter-multiple parity): column key → values OR-matched against the raw `String(value)` of each row. Controlled via `onFilterValuesChange`; without a handler read-only. */
+    filterValues?: IrisTableFilterValues;
+    /** Fired when the filter panel confirms or clears a column's checked set. */
+    onFilterValuesChange?: (next: IrisTableFilterValues) => void;
     /** Search form (vxe-grid formConfig parity). */
     formConfig?: IrisTableFormConfig;
     /** Toolbar (vxe-grid toolbarConfig parity, minimal built-ins). */
@@ -2772,8 +4175,12 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
         onRefresh?: () => void;
         /** Show the column-visibility toggle button. */
         columnSettings?: boolean;
+        /** Custom column panel options (vxe customConfig parity): the columnSettings button opens the full panel (search + drag reorder + visibility toggles + reset) instead of the plain checkbox menu. */
+        customConfig?: IrisTableCustomConfig;
         /** Enable the CSV import button. Receives parsed rows (header → keys). */
         onImport?: (rows: Record<string, unknown>[]) => void;
+        /** Fired by the export button (vxe toolbar export parity, batch L). */
+        onExport?: () => void;
         /** Custom action buttons rendered after the built-ins (vxe toolbar buttons parity). */
         buttons?: Array<{
             key: string;
@@ -2781,86 +4188,184 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
             onClick: () => void;
             icon?: string;
         }>;
+        /** Batch action (vxe toolbar batch parity, batch M): a primary button rendered after the built-ins while `selectable === 'multi'` and rows are selected; receives the current selection keys. When `edit` is true (iris 独有), the button instead opens the built-in batch edit panel — an editable-column select + value input + 应用: ONE `commitRowList` writes the value into every selected row (selection unchanged, editRules bypassed like paste). */
+        batch?: {
+            label: string;
+            onClick: (keys: Array<string | number>) => void;
+            icon?: string;
+            edit?: boolean;
+        };
+    };
+    /** Zoom overlay (vxe toolbar zoom parity, batch U): when `showButton`, the
+     * toolbar renders a toggle (⛶ when not zoomed, ✕ when zoomed) that pins the
+     * table root as a fullscreen overlay (fixed, inset 0, popover z-index);
+     * Esc exits. Local state — no parent props needed. */
+    zoomConfig?: {
+        showButton?: boolean;
+    };
+    /** Import preview (iris 独有 — vxe has no pre-import preview): when true,
+     * the toolbar ⇪ CSV import shows a centered modal previewing the first 5
+     * parsed rows (plus a total-count note when more) before anything lands;
+     * 确认 calls `toolbar.onImport` with ALL parsed rows, 取消 / Esc / backdrop
+     * close with zero calls. Default false — the import lands directly (vxe
+     * parity). */
+    importPreview?: boolean;
+    /** Section layouts (vxe-grid layouts parity, batch U, suppression-only):
+     * `form`/`toolbar` `'hidden'` skips that section (the config stays
+     * accepted); `pager` `'hidden'` skips the proxy pager. Defaults render
+     * every section exactly as before. */
+    layouts?: {
+        form?: 'top' | 'hidden';
+        toolbar?: 'top' | 'hidden';
+        pager?: 'bottom' | 'hidden';
     };
     /** Render with print-friendly styles (hides the toolbar, keeps rows). */
     printable?: boolean;
+}
+
+interface IrisTableQueryProps<Row extends Record<string, unknown> = Record<string, unknown>> {
+    /** Named view presets (batch AH, iris 独有) — toolbar select of saved snapshots. */
+    views?: IrisTableViewConfig;
+    /** Fired when the active view changes (select / save / delete clears null). */
+    onActiveViewChange?: (key: string | null) => void;
+    /** Batch CT — iris 独有 (vxe has no parity).
+     * A `role=tablist` strip rendered ABOVE the toolbar: clicking a tab applies
+     * each name in `views` IN ORDER through the same selectView path the toolbar
+     * select uses (unknown names are skipped fail-inert; when several views touch
+     * the same piece the last applied view wins and the toolbar select mirrors
+     * that last view). Fail-closed: without the prop nothing renders, and no tab
+     * is active until the first click. */
+    tableTabs?: IrisTableTab[];
+    /** Natural-language query (iris 独有): controlled string parsed by core
+     * `parseTableQuery` (`age > 25 and role in (Test, PM) sort by name asc`);
+     * the toolbar query input shows while present, parsed filters AND-merge
+     * (`=`/`contains` → substring, `in` → filterValues OR-match, relational →
+     * rules); `sort by` seeds only with no sort prop set; proxy comma-joins
+     * substring/in into the remote filter map. Controlled-only. */
+    query?: string;
+    /** Fired on every keystroke (parent owns the string). */
+    onQueryChange?: (next: string) => void;
+    /** Render only the horizontally-visible columns plus pinned columns and overscan. */
+    columnVirtualization?: boolean;
     /**
-     * Column drag-sort (vxe-grid columnDragConfig parity). Reorders leaf
-     * columns on drop; parent owns columns (pass the reordered array back).
+     * Selection summary (batch AP, iris 独有 — vxe has no parity feature, the
+     * header count is its closest cousin): when `selectable === 'multi'` and
+     * rows are selected, the toolbar renders `已选 N 行`
+     * (`data-iris-selection-summary`, i18n `table.selectionSummary`) plus a
+     * `· 合计 X` per leaf column with `summary === 'sum'` (the SAME aggregate
+     * material + `aggregateAccuracy` rounding + `String(value)` formatting the
+     * summary row uses, computed over the SELECTED rows in bodyData order) and
+     * a clear button (`data-iris-selection-clear`) that runs the shared
+     * `clearSelection` path. Additive — default off.
      */
-    columnDrag?: {
-        /** Called with the reordered column array after a drop. */
-        onReorder: (columns: IrisTableColumn<Row>[]) => void;
-    };
-    /** Render a leading sequence-number column (vxe-grid seqConfig parity). */
-    seq?: boolean;
+    selectionSummary?: boolean;
+    /** Enable rectangular cell-range selection. */
+    cellRange?: boolean;
     /**
-     * Cell merge (vxe-grid spanMethod parity): return `{ rowspan, colspan }`
-     * for a cell at (rowIndex, columnIndex); both default 1. Values > 1 make
-     * the cell span adjacent cells (the spanned cells are skipped).
+     * Excel-style drag fill (batch AQ, iris 独有 — vxe has no fill parity):
+     * when `cellRange` has a live selected range (≥1 cell), a fill handle
+     * (`data-iris-range-fill`, 6px primary square at the range's bottom-right
+     * cell) appears; dragging it DOWN or RIGHT cyclically fills the target
+     * rectangle from the source range values (`(r, c)` ← source
+     * `((r - start.row) % rangeRows + start.row, …)`), formula columns and
+     * keyless rows skipped, through ONE batched `commitRowList`, then extends
+     * the range to the drag end (Excel parity). Dragging UP/LEFT is ignored
+     * (the handle only grows the range). Additive — default off.
      */
-    spanMethod?: (params: {
-        rowIndex: number;
-        columnIndex: number;
-    }) => {
-        rowspan?: number;
-        colspan?: number;
-    } | null | undefined;
-    /** Row drag-sort configuration (composed over core createSortable). */
-    rowDrag?: {
-        /** Reorder callback — receives the reordered row array (parent owns data). */
-        onReorder: (rows: Row[]) => void;
+    rangeFill?: boolean;
+    /**
+     * Cell drag-move (batch CN, iris 独有 — vxe has no cell-move parity): when
+     * `cellRange` has a live selected range (≥1 cell), a move grip
+     * (`data-iris-range-move`, 12×4 primary pill on the range's top edge at its
+     * top-left cell) appears; dragging it to another cell CUT-MOVES the whole
+     * block there (剪切移动 — source cells not covered by the destination rect
+     * are cleared; locked/readonly and formula cells survive both phases) and
+     * the selection follows the moved block (Excel parity). The drag end clamps
+     * so the block always fits (down/up/right/left 越界). Zero-commit no-op
+     * when the drag stays on the source block. Inert without `cellRange`.
+     * Additive — default off.
+     */
+    cellDrag?: boolean;
+    /**
+     * Cell drag-copy (batch DZ, iris 独有 — vxe has no cell-copy parity): when
+     * `cellRange` has a live selected range (≥1 cell), a copy grip
+     * (`data-iris-range-copy`, 12×4 primary pill on the range's BOTTOM edge at
+     * its top-left cell — the CN move grip owns the top edge, zero collision)
+     * appears; dragging it to another cell COPIES the whole block there (源块
+     * 不动 — the source keeps its values, unlike cellDrag's cut-move) through
+     * ONE batched `commitRowList`, and the selection stays on the source block
+     * (Excel parity — a copy never moves the selection). The whole destination
+     * rectangle must FIT inside the table (越界忽略, deliberately divergent
+     * from cellDrag's clamp): an out-of-bounds drag end shows no outline and
+     * the release is a zero-commit no-op; a drop on the source block itself is
+     * a zero-commit no-op too. Formula columns are never read/written;
+     * locked/readonly destination cells survive; keyless rows skipped. Inert
+     * without `cellRange`. Additive — default off.
+     */
+    cellDragCopy?: boolean;
+    /** Clipboard batch (vxe-grid clipboard-config parity, batch O): Ctrl/Cmd+C copies the selected cell range; Ctrl/Cmd+V pastes TSV text into the range anchor onward (overflow beyond the last row/col is ignored). Requires `cellRange` to have a live selected range; additive — default off.
+     * Batch BP (iris 独有 — vxe clipboard-config has no output-format switch): `copyFormat` selects the copy OUTPUT format for BOTH consumption points (Ctrl/Cmd+C and the range toolbar 复制 button) — `'tsv'` (default, byte-identical to batch O) / `'csv'` (RFC-4180, headerless range fiat like the 导出 CSV download) / `'html'` (a `<table>` fragment via core `toHtml`, with a header row of column titles — the toHtml contract — and the masked cell values, the batch-AY invariant across all three formats). Paste is unaffected — it always reads `\t`-delimited text. Invalid runtime values fail-closed to `'tsv'`.
+     * Batch CU (iris 独有 — vxe clipboard-config always copies raw values, no format-preserving copy): `copyWithFormat` copies the FORMATTED text of formatter columns (the `contextCellText` display chain — mask → formatter → String, the same chain as the context-menu 复制值) instead of the raw/masked value, across ALL THREE `copyFormat` serializers. Only `col.formatter` columns switch chains — non-formatter columns stay byte-identical — and the formatted STRING still flows through the same serializers (RFC-4180 quoting + OWASP neutralization still apply). `exportRaw`'s copy-path skip is superseded on formatter columns (mask → formatter always); exports are untouched.
+     */
+    clipConfig?: {
+        copy?: boolean;
+        paste?: boolean;
+        copyFormat?: 'tsv' | 'csv' | 'html';
+        copyWithFormat?: boolean;
     };
-    /** Inline-edit configuration (vxe-grid editConfig parity). */
-    editConfig?: {
-        /** What opens the editor. Default `'dblclick'`. */
-        trigger?: 'click' | 'dblclick' | 'manual';
-        /** Show a required asterisk next to headers of columns with rules. */
-        showAsterisk?: boolean;
-        /** Drop the draft when opening another cell without committing. */
-        autoClear?: boolean;
+    /** Paste options (iris 独有 — vxe-grid clipboard-config has no overflow-insert switch):
+     * `insertIfOverflow` makes a SINGLE-CELL paste append clipboard lines that run past
+     * the last row as brand-new rows (auto-id keys via `insertRowInList`, surplus cells
+     * dropped, locked/readonly columns skipped) — one batched commit. Multi-cell
+     * rectangle pastes stay clipped (fiat) and the default (absent) keeps batch-O
+     * overflow-drop behavior byte-identical. Additive — default off.
+     */
+    pasteOptions?: {
+        insertIfOverflow?: boolean;
     };
-    /** Edit-validation presentation (vxe-grid ValidConfig parity). */
-    validConfig?: IrisTableValidConfig;
-    onCellEdit?: (event: IrisTableCellEditEvent<Row>) => void;
-    /** Render an expandable detail panel beneath a row. */
-    renderDetail?: IrisTableRenderDetail<Row>;
-    /** Which rows can expand a detail panel. */
-    rowExpandable?: IrisTableRowExpandable<Row>;
-    /** Initially-expanded row keys (uncontrolled). Shared by detail rows + tree rows. */
-    defaultExpandedRowKeys?: Array<string | number>;
-    /** Expand every tree row that has children on mount (vxe expand-config
-     * expandAll parity). One-shot: seeds the expansion model with all tree keys
-     * on the first data arrival (proxy pages load async). Default false. */
-    expandAll?: boolean;
-    /** Notified with the expanded row keys whenever they change. */
-    onExpandedRowsChange?: (keys: Array<string | number>) => void;
-    /** Read a row's child rows to render the table as a tree. */
-    getSubRows?: (row: Row) => Row[] | undefined;
-    /** Enable WAI-ARIA grid keyboard navigation. */
-    keyboardNavigation?: boolean;
-    /** Enable virtual scrolling for the body. */
-    virtualScroll?: IrisTableVirtualOptions;
-    /** Render only the horizontally-visible columns plus pinned columns and overscan. */
-    columnVirtualization?: boolean;
-    /** Enable rectangular cell-range selection. */
-    cellRange?: boolean;
+    /** Find & replace (vxe-grid find parity, batch O): Ctrl/Cmd+F (when not editing) opens a find/replace bar above the table; Enter/Shift+Enter step through matches; Esc closes and clears highlights. Matches over bodyData (flat mode), case-insensitive substring. Additive — default off. */
+    fnr?: boolean;
+    /** Batch CK (iris 独有 — vxe has no inline search highlight): a
+     * case-insensitive literal-substring search over each text cell's display
+     * chain (mask → formatter ?? raw — the same text autoLink consumes); every
+     * occurrence renders as an inline `<mark data-iris-search-hit>` (the
+     * surface-selected token — the same search-highlight language fnr uses for
+     * matched cells). Display-only: no bar, no match state, no write-back —
+     * the distinction from fnr is the mechanism, not the query.
+     * `render`/`html`/`link`/`autoLink`/sparkline cells are untouched
+     * (documented fiats). Additive; default off (fail-closed).
+     */
+    searchHighlight?: string;
+    /** Built-in undo/redo (iris 独有 — vxe has no built-in undoRedoHistory): when enabled, every data mutation (row ops, paste, find&replace, range clear, cell/row edits, batch edit) records the POST-change row list; Ctrl/Cmd+Z undoes and Ctrl/Cmd+Y (or Ctrl/Cmd+Shift+Z) redoes — never while an inline editor is open. The toolbar renders ↶/↷ buttons after the title (disabled from canUndo/canRedo); restores prune selection keys that no longer exist. Additive — default off. */
+    undo?: boolean;
     /** Shift-click checkbox range selection (vxe checkboxConfig `isShiftKey`
      * parity, batch G): shift-clicking a row checkbox toggles every
      * checkMethod-eligible row between the last-clicked anchor row and the
      * target (in body order); a plain click just moves the anchor. The header
      * select-all resets the anchor. Default false. */
     checkboxRange?: boolean;
-    /** Empty state node (replaces the row body when `data` is empty). */
-    emptyState?: ReactNode;
+    /** Row-selection drag range (batch BT, iris 独有 — vxe has no mouse-drag
+     * checkbox range): pressing the row-selection cell in multi mode and
+     * dragging past the 4px threshold continuously checks every
+     * checkMethod-eligible row between the pressed anchor row and the hovered
+     * row (closed interval in body order); checkMethod-disabled rows are
+     * skipped. The applied set only ever grows during one drag (reverse drags
+     * shrink the interval but never uncheck); a plain click still toggles a
+     * single row. Default false. */
+    selectionDrag?: boolean;
+    /** Empty state node (replaces the row body when `data` is empty). Also accepts
+     * an `IrisTableEmptyState` descriptor (iris 独有 — vxe has no empty-state
+     * action button): `{ text?, action? }` renders the text plus an inline action
+     * button on the same row. */
+    emptyState?: React.ReactNode | IrisTableEmptyState;
     /** Show the loading state instead of rows. */
     loading?: boolean;
     /** Show the error state instead of rows (takes precedence over loading). */
     error?: boolean;
     /** Custom loading-state node. */
-    loadingState?: ReactNode;
+    loadingState?: React.ReactNode;
     /** Custom error-state node. */
-    errorState?: ReactNode;
+    errorState?: React.ReactNode;
     /** Fired by the built-in Retry button in the error state row. */
     onRetry?: () => void;
     /**
@@ -2872,16 +4377,107 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
     /** Cell tooltips (vxe-grid tooltipConfig parity, title mode, batch G): a
      * native `title` on every body cell, content from the callback or the raw
      * cell value; editing cells are exempt and empty content drops the tooltip.
-     * Truncation gating is not implemented — titles render on every cell
-     * regardless of `showAll` (documented simplification, kept simple and
-     * explicit). */
+     * With `showAll: false`, titles remain only for cells whose single-line
+     * content measures wider than the rendered cell; SSR/jsdom zero-width
+     * layouts fail open and retain the title. */
     tooltipConfig?: IrisTableTooltipConfig<Row>;
+    /** Cell annotations (iris 独有, batch AZ — vxe has no cell-note concept): a
+     * static map of notes keyed `${rowKey}::${columnKey}` — the same `::`
+     * delimiter as the internal `cellId` (`annotations[cellId(k, col.key)]`).
+     * A noted cell renders a corner badge (`data-iris-cell-note-badge`) + gets
+     * `data-iris-cell-note` + the note as its title (beats `tooltipConfig`);
+     * the dynamic `cellNote` callback wins over this map when both are set. */
+    annotations?: Record<string, string>;
+    /** Dynamic per-cell note (iris 独有, batch AZ): computed from the row +
+     * column — wins over the static `annotations` map. With a note the cell
+     * gets `data-iris-cell-note` + a corner badge + the note as its title
+     * (beats `tooltipConfig`); a null/'' note renders nothing. */
+    cellNote?: (row: Row, column: IrisTableColumn<Row>) => string | null;
+    /** Hover note preview (batch BM, iris 独有 — vxe has no cell-note concept,
+     * and its tooltip can only show the cell value): with `notePopover`, hovering
+     * a noted cell shows a floating popover (`data-iris-note-popover`, role
+     * tooltip, pure display — pointer-events none) anchored to the cell's badge
+     * corner INSTEAD of the native `title`; Escape / outside pointer-down /
+     * any scroll close it. Content-only: zero i18n / core. */
+    notePopover?: boolean;
+    /**
+     * Annotation editing (batch BB, iris 独有 — vxe has no note editing): when
+     * true, the context menu gains built-in items 添加批注 / 编辑批注 / 删除批注
+     * (keys `__iris-annotate` / `__iris-annotate-edit` / `__iris-annotate-remove`,
+     * i18n `table.annotate(.edit/.remove)`) appended AFTER the summary item,
+     * chosen by the clicked cell's existing note (add when none, edit+remove
+     * when one). The add/edit items open a floating annotate panel
+     * (`data-iris-annotate-panel`) — textarea seeded from
+     * `annotations[cellId(rowKey, col.key)]` + 保存 (`data-iris-annotate-save`)
+     * + 删除 (`data-iris-annotate-remove`, only when a note exists); the remove
+     * item deletes the cell's annotation directly. Requires `contextMenu`;
+     * writes flow through `onAnnotationsChange` — without it the items still
+     * show but save/remove are inert (documented).
+     */
+    annotationEditing?: boolean;
+    /**
+     * Annotation write channel (batch BB, iris 独有): receives the NEXT
+     * annotations map on every annotate-panel save — empty text removes the
+     * cell's key, non-empty sets it — and on remove (menu item or panel
+     * button). The map stays fully controlled: `annotations` remains the read
+     * source and the table holds no internal annotation state (same shape and
+     * ownership as `onFiltersChange`).
+     */
+    onAnnotationsChange?: (next: Record<string, string>) => void;
+    /**
+     * Annotation CSV export (batch DU, iris 独有 — vxe has no note concept, so
+     * no export parity): when true, `tableRef.current.exportAnnotationsCsv()`
+     * serializes every noted cell of the current view as CSV
+     * (`rowKey,column,annotation` — the same cellNoteState resolution as the
+     * render, hidden columns excluded). Additive — default off (fail-closed:
+     * without the prop the handle returns `''`).
+     */
+    exportAnnotations?: boolean;
+    /**
+     * Collaborative-presence cursors (batch BD, iris 独有 — vxe has no cursor
+     * sharing): remote participants' selected cells. Each entry draws a 2px
+     * colored outline on its cell (`data-iris-presence="true"`, outline in the
+     * entry's `color` — first entry wins when several share a cell) plus a
+     * corner label with the participant's name (`data-iris-presence-label`
+     * with `-id`/`-name`). Pure display: the table holds no collaboration
+     * state, so a NEW array reference re-renders while in-place mutation does
+     * not (same controlled contract as `data` / `annotations`).
+     */
+    presence?: IrisTablePresenceEntry[];
+    /** Header cell tooltips (vxe header-tooltip-config parity, batch P): a
+     * native `title` on flat + grouped header cells; empty content drops the
+     * tooltip. */
+    headerTooltipConfig?: {
+        content?: (column: IrisTableColumn<Row>) => string;
+    };
+    /** Footer cell tooltips (vxe footer-tooltip-config parity, batch P): a
+     * native `title` on summary / footer-method / footer-data cells; empty
+     * content drops the tooltip. */
+    footerTooltipConfig?: {
+        content?: (column: IrisTableColumn<Row>) => string;
+    };
     /**
      * Right-click context menu (vxe-grid contextMenu parity, batch H). Opens on
      * body leaf cells only — header, seq, selection, expand, summary and footer
      * cells never open it. The menu floats at the cursor (virtual anchor),
      * closes on Escape / outside pointer-down / any scroll, and fires `onSelect`
      * with the clicked item's key and the cell's grid coordinates.
+     *
+     * Batch BW (iris 独有): EVERY menu unconditionally gains two built-in quick
+     * actions after the user items (and after the value-distribution / summary
+     * items when those props are on, before the annotate items) — 复制值
+     * (key `__iris-copy-value`, i18n `table.copyValue`, copies the cell's
+     * display text — mask → formatter → String — to the clipboard) and 清空
+     * (key `__iris-clear-cell`, i18n `table.clearCell`, writes the cell to ''
+     * through the same commitRowList funnel as the Delete shortcut — undo /
+     * audit / onDataChange covered; locked/readonly cells no-op). Both keys are
+     * intercepted at the onSelect wiring, so the user callback never sees them;
+     * without a clipboard the copy no-ops safely.
+     *
+     * Set `formatActions` to true to additionally append opt-in region format
+     * actions (number to two decimals and uppercase text). They remain
+     * intercepted by the table and use the same commit funnel; the default is
+     * false so an ordinary context menu is unchanged.
      */
     contextMenu?: {
         items: (params: IrisTableContextMenuParams<Row>) => Array<{
@@ -2890,19 +4486,121 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
             disabled?: boolean;
         }>;
         onSelect: (key: string, params: IrisTableContextMenuParams<Row>) => void;
+        formatActions?: boolean;
     };
-    /** Imperative handle for row ops (vxe-grid edit insert/remove/setRow parity). */
-    tableRef?: MutableRefObject<IrisTableHandle<Row> | null>;
-    /** Fired after any internal row operation / edit write-back, with the new row list. */
-    onDataChange?: (rows: Row[]) => void;
-    /** Veto rows from selection (vxe-grid checkboxConfig.checkMethod parity). */
-    checkMethod?: (row: Row, rowIndex: number) => boolean;
-    /** Pager options (vxe-grid pagerConfig parity). */
-    pagerConfig?: IrisTablePagerConfig;
-    style?: CSSProperties;
-    className?: string;
+    /**
+     * Value distribution panel (batch AM, iris 独有): when true, the context
+     * menu gains a built-in item (key `__iris_distribution`, i18n
+     * `table.distribution`) that opens a floating panel counting each distinct
+     * value of the CLICKED column over the current body rows — top 20 + a
+     * muted "其余 N 个" fold — computed by the core `valueDistribution`
+     * material over `bodyData` with the `dataIndex ?? key` indirection.
+     * Requires `contextMenu` to be set (the item appends to its items). */
+    valueDistribution?: boolean;
 }
 
+/**
+ * vxe-grid proxyConfig parity — the server-side data proxy (query slice).
+ * When set, `data` is ignored: rows come from `query` (paged), the table
+ * renders a pager below the body, and edit write-back keeps working.
+ */
+interface IrisTableProxyConfig<Row extends Record<string, unknown>> {
+    /**
+     * Fetch one page. 1-based `page`; `sort`/`filters` are the ACTIVE state,
+     * passed through when `remoteSort`/`remoteFilter` are enabled.
+     */
+    query: (params: IrisTableProxyQueryParams, signal?: AbortSignal) => Promise<{
+        rows: Row[];
+        total: number;
+    }>;
+    /** Optional Core resilient fetching (dedup/TTL/SWR, breaker, and rate limiting). */
+    resilient?: ResilientFetcherOptions;
+    /** Auto-load the first page on mount (vxe autoLoad parity). Default true. */
+    autoLoad?: boolean;
+    /** Sort changes re-query the server instead of sorting client-side (vxe proxyConfig.sort). Default false. */
+    remoteSort?: boolean;
+    /** Filter changes re-query the server instead of filtering client-side (vxe proxyConfig.filter). Default false. */
+    remoteFilter?: boolean;
+    /** Rows per page. Default 10. */
+    pageSize?: number;
+    /** Initial page (1-based). Default 1. */
+    defaultPage?: number;
+    /** Cumulative sequence numbers across pages (batch L): with the table `seq`
+     * prop, the seq cell renders `(page - 1) * pageSize + rowIndex + 1` instead of `rowIndex + seqStartIndex`. `seqMethod` still wins. */
+    seq?: boolean;
+    /** Fired when the page changes. */
+    onPageChange?: (page: number, pageSize: number) => void;
+}
+/**
+ * Search-form configuration (vxe-grid formConfig parity): a field row above
+ * the toolbar; submit merges values into the filters (client-side or proxy).
+ */
+interface IrisTableFormConfig {
+    fields: IrisTableFormField[];
+    /** Label of the submit button. Defaults to the i18n `table.formSubmit` key. */
+    submitText?: string;
+    /** Label of the reset button. Defaults to the i18n `table.formReset` key. */
+    resetText?: string;
+    /** Fired on submit with every field's value (empty strings stripped). */
+    onSearch?: (values: Record<string, string>) => void;
+    /** Fired on reset with the reset values (defaults re-applied). */
+    onReset?: (values: Record<string, string>) => void;
+}
+/** Empty-state descriptor (iris 独有 — vxe has no empty-state action button):
+ * object form of `emptyState` renders centered text (optional) plus an inline
+ * action button. A plain ReactNode stays on the node path untouched. */
+interface IrisTableEmptyState {
+    /** Empty-state text (falls back to the localized default when omitted). */
+    text?: ReactNode;
+    /** Action button rendered inline after the text. */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+/** Pager configuration (vxe-grid pagerConfig parity). */
+interface IrisTablePagerConfig {
+    /** Rows-per-page options rendered as a size selector next to the pager. A
+     * change re-queries with the new size and resets the page to 1. */
+    pageSizes?: number[];
+    /** Show the total-row count (i18n `table.total`) before the size selector (vxe pagerConfig.showTotal parity). */
+    showTotal?: boolean;
+}
+/** Public input surface for the React table adapter. */
+/** Row-density preset (iris 独有 — vxe has no density concept): the three
+ * tiers stack ON TOP of `size` — both write `--iris-cell-pad-y`, and the
+ * density rules come later in the stylesheet (same specificity, later
+ * wins). Default comfortable. */
+type IrisTableDensity = 'comfortable' | 'compact' | 'cozy';
+interface IrisTableProps<Row extends Record<string, unknown> = Record<string, unknown>> extends IrisTableLayoutProps<Row>, IrisTableEditingProps<Row>, IrisTableQueryProps<Row>, IrisTableAdvancedProps<Row> {
+}
+
+/** URL-state snapshot (batch DV): the pieces `urlState` reads/writes in the
+ * `_table` query param. Mirror of `IrisTablePersistedState` minus the
+ * layout/expansion pieces — a deep link carries what affects served rows. */
+interface IrisTableUrlState {
+    /** Wire schema version — decode rejects anything else (forward-compat). */
+    v: 1;
+    /** Single-column sort (omitted when inactive; null never encoded). */
+    sort?: IrisTableSortState | null;
+    /** Multi-column sort list (multiSort mode only, non-empty). */
+    sorts?: IrisTableSortState[];
+    /** Text filters (column key → filter text, non-empty map only). */
+    filters?: Record<string, string>;
+    /** Checked filter sets (column key → values, non-empty map only). */
+    filterValues?: IrisTableFilterValues;
+    /** 1-based page (proxy only; omitted when 1). */
+    page?: number;
+    /** Rows per page (proxy only). */
+    pageSize?: number;
+}
+/** Query-param key that carries the whole payload. */
+declare const IRIS_URL_STATE_KEY = "_table";
+/** Sticky zero-height endcap: pins the button to the bottom of the scroll
+ * viewport (an absolute box would ride the content — the BU watermark
+ * precedent); z 3 paints above the sticky header (z 2) / pinned columns
+ * (z 1) but below the floating panels. pointerEvents none — the zero-height
+ * strip never eats a click. */
 /**
  * Data-driven table. Renders as a CSS-grid layout (no native `<table>`) so it
  * can support future virtual scroll / column resize uniformly. Wires ARIA
@@ -2910,14 +4608,23 @@ interface IrisTableProps<Row extends Record<string, unknown> = Record<string, un
  *
  * Sortable columns cycle `none → asc → desc → none` on click.
  */
-declare function IrisTable<Row extends Record<string, unknown>>({ columns, data, rowKey, selectable, selection: selectionProp, defaultSelection, onSelectionChange, sort: sortProp, defaultSort, onSortChange, multiSort, multiSortState: multiSortStateProp, defaultMultiSort, onMultiSortChange, striped, size, seqStartIndex, seqMethod, currentRowKey, onCurrentRowChange, beforeCurrentRowChange, currentColumnKey, onCurrentColumnChange, beforeCurrentColumnChange, showHeader, footerData, rowClassName, cellClassName, headerCellClassName, footerCellClassName, rowStyle, cellStyle, headerCellStyle, footerCellStyle, onCellClick, bordered, resizableColumns, columnWidths: columnWidthsProp, defaultColumnWidths, onColumnWidthsChange, onRowClick, onCellEdit, tableRef, onDataChange, checkMethod, pagerConfig, editConfig, validConfig, rowDrag, columnDrag, columnVisibility, onColumnVisibilityChange, filters, formConfig, toolbar, tooltipConfig, contextMenu, printable, seq, spanMethod, renderDetail, rowExpandable, defaultExpandedRowKeys, expandAll, onExpandedRowsChange, getSubRows, keyboardNavigation, cellRange, checkboxRange, virtualScroll, columnVirtualization, emptyState, loading, error, loadingState, errorState, onRetry, proxyConfig, style, className, ...rest }: IrisTableProps<Row>): React.ReactElement;
+declare function IrisTable<Row extends Record<string, unknown>>({ columns, data, rowKey, selectable, selection: selectionProp, defaultSelection, onSelectionChange, sort: sortProp, defaultSort, onSortChange, multiSort, multiSortState: multiSortStateProp, defaultMultiSort, onMultiSortChange, striped, size, density, densityToggle, seqStartIndex, seqMethod, currentRowKey, onCurrentRowChange, beforeCurrentRowChange, currentColumnKey, onCurrentColumnChange, beforeCurrentColumnChange, onHeaderClick, showHeader, footerData, footerMethod, footerSpanMethod, headerAlign, footerAlign, autoDetectTypes, summaryRowStyle, aggregateAccuracy, highlightHoverRow, showHeaderOverflow, showFooterOverflow, watermark, height, minHeight, maxHeight, scrollbarConfig, scrollbarThumb, scrollToTop, headerStats, editDirtyConfig, autoResize, syncResize, responsive, keepSource, zIndex, rowId, mergeFooterItems, rowClassName, cellClassName, headerCellClassName, footerCellClassName, rowStyle, cellStyle, conditionalStyles, headerCellStyle, footerCellStyle, onCellClick, onCellDblClick, onTableEvent, bordered, round, padding, resizableColumns, widthHint, autoResizeColumns, columnWidths: columnWidthsProp, defaultColumnWidths, onColumnWidthsChange, columnWidthsReset, columnPinMenu, pinnedColumns: pinnedColumnsProp, onColumnPinnedChange, pinnedDrag, onPinnedCountChange, onRowClick, onRowDblClick, onCellEdit, onEditStart, onEditClosed, editAutosave, onAutosave, editAutoHeight, charCount, editPreview, pattern, patternFill, columnStats, columnTotals, expandScrollPreserve, shortcutHints, onSelectAllChange, onScroll, tableRef, onDataChange, checkMethod, pagerConfig, editConfig, validConfig, rowDrag, rowDragBetween, columnDrag, columnVisibility: columnVisibilityProp, onColumnVisibilityChange, columnFade, columnOrder: columnOrderProp, onColumnOrderChange, filters, onFiltersChange, filterValues, onFilterValuesChange, formConfig, toolbar, zoomConfig, importPreview, layouts, tooltipConfig, annotations, cellNote, notePopover, annotationEditing, onAnnotationsChange, exportAnnotations, presence, headerTooltipConfig, footerTooltipConfig, contextMenu, valueDistribution, nlSummary, chartPreview, autoRefresh, freshness, validationSummary, auditLog, perfStats, versionHistory, editSidebar, compareWith, mergeCompare, autoLink, recentFilters, formulaTables, exportNames, printable, seq, spanMethod, mergeHeaderCells, renderDetail, rowExpandable, defaultExpandedRowKeys, expandAll, onExpandedRowsChange, onExpandChange, onTreeExpandChange, getSubRows, lazyLoad, expandAnimation, keyboardNavigation, tableShortcuts, editKeys, keymap, hotkeyScope, outerScope, groupBy, groupCollapsed, defaultGroupCollapsed, onGroupCollapseChange, cellRange, rangeFill, cellDrag, cellDragCopy, clipConfig, pasteOptions, fnr, searchHighlight, undo, checkboxRange, selectionDrag, virtualScroll, rowHeight, adaptiveRowHeight, persistState, autoSaveState, urlState, views, onActiveViewChange, tableTabs, query, onQueryChange, columnVirtualization, emptyState, loading, error, loadingState, errorState, onRetry, proxyConfig, showCellRefs, selectionSummary, style, className, ...rest }: IrisTableProps<Row>): React.ReactElement;
 
 /**
  * Serialize rows as a CSV string per RFC 4180. Column order determines field
  * order; cell values are read via `dataIndex` (defaulting to the column key).
  * Returns a plain string without BOM.
+ *
+ * Batch AY: masked-by-default export — a column with `mask` exports the
+ * masked value unless it opts out via `exportRaw`. Masking materializes each
+ * masked column's value onto a shadow row at the key the serializer reads
+ * (string `dataIndex`, else `key`), the batch-AO shadow-row convention;
+ * formula columns are already materialized by
+ * `withComputedFormulaCells` before this serializer runs, so the mask applies
+ * on top. No masks → the input array is returned as-is (reference-preserving).
  */
 declare function exportCsv<Row extends Record<string, unknown>>(rows: readonly Row[], columns: readonly IrisTableColumn<Row>[]): string;
+
 /**
  * Trigger a download of the given CSV string. A host `FileSaveHandler` (set via
  * `setFileSaveHandler`) intercepts it for native save in desktop/mobile shells;
@@ -2962,6 +4669,8 @@ interface IrisVirtualScrollProps<T = unknown> {
     buffer?: number;
     /** Stable key per item. Falls back to index. */
     keyOf?: (item: T, index: number) => string | number;
+    /** Optional Grid Core-owned controller. When omitted, this component owns one. */
+    virtualizer?: Virtualizer;
     /** Render a single item. */
     renderItem: (item: T, index: number) => React.ReactNode;
     onScroll?: (scrollTop: number) => void;
@@ -3044,6 +4753,39 @@ interface IrisDatePickerProps {
  */
 declare function IrisDatePicker({ value: valueProp, defaultValue, onValueChange, min, max, weekStartsOn, locale, placeholder, disabled, invalid, placement, id, ariaDescribedby, style, className, ...rest }: IrisDatePickerProps): React.ReactElement;
 
+/**
+ * Month-only picker composed from Iris Popover primitives.
+ *
+ * The public value is a local-time `Date` normalized to the first day of its
+ * month. The panel intentionally offers a 12-month grid rather than a native
+ * month input, select, or day-level calendar.
+ *
+ * @example
+ * <IrisMonthPicker value={month} onValueChange={setMonth} locale="en-US" />
+ */
+interface IrisMonthPickerProps {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onValueChange?: (next: Date | null) => void;
+    /** Initial visible year when no value is selected. */
+    defaultMonth?: Date | null;
+    /** Inclusive month bounds; individual days are ignored. */
+    min?: Date;
+    max?: Date;
+    locale?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    placement?: Placement;
+    /** id forwarded to the trigger. */
+    id?: string;
+    /** Forwarded as aria-describedby on the trigger. */
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+declare function IrisMonthPicker({ value: valueProp, defaultValue, onValueChange, defaultMonth, min, max, locale, placeholder, disabled, invalid, placement, id, ariaDescribedby, style, className, ...rest }: IrisMonthPickerProps): React.ReactElement;
+
 interface IrisTreeNode {
     /** Stable unique identifier. */
     id: string;
@@ -3517,4 +5259,4 @@ interface IrisCommandPaletteProps extends Omit<React.HTMLAttributes<HTMLDivEleme
  */
 declare function IrisCommandPalette({ open, onOpenChange, items, placeholder, emptyText, filter, onSelect, virtual, style, ...rest }: IrisCommandPaletteProps): React.ReactElement | null;
 
-export { AccordionContext, type AccordionContextValue, DialogContext, type DialogContextValue, type DragState, DrawerContext, type DrawerContextValue, DropdownContext, type DropdownContextValue, IrisAccordion, IrisAccordionItem, type IrisAccordionItemProps, type IrisAccordionProps, type IrisAccordionValue, IrisAffix, type IrisAffixProps, IrisAlert, type IrisAlertProps, type IrisAlertTone, IrisAnchor, type IrisAnchorItem, type IrisAnchorProps, IrisAspectRatio, type IrisAspectRatioProps, IrisAvatar, type IrisAvatarProps, type IrisAvatarShape, type IrisAvatarSize, IrisBackTop, type IrisBackTopProps, IrisBadge, type IrisBadgeProps, type IrisBadgeSize, type IrisBadgeTone, type IrisBadgeVariant, IrisBanner, type IrisBannerProps, type IrisBannerTone, IrisBreadcrumb, IrisBreadcrumbItem, type IrisBreadcrumbItemProps, type IrisBreadcrumbProps, IrisButton, type IrisButtonProps, type IrisButtonSize, type IrisButtonType, type IrisButtonVariant, IrisCalendar, type IrisCalendarProps, IrisCard, type IrisCardPadding, type IrisCardProps, type IrisCardVariant, IrisCarousel, type IrisCarouselProps, IrisCascader, type IrisCascaderNode, type IrisCascaderProps, type IrisCascaderSize, IrisCheckbox, type IrisCheckboxProps, type IrisCheckboxSize, type IrisCheckboxValue, IrisChip, type IrisChipProps, type IrisChipSize, type IrisChipTone, type IrisChipVariant, IrisColorPicker, type IrisColorPickerProps, IrisCombobox, type IrisComboboxOption, type IrisComboboxProps, type IrisComboboxSize, type IrisCommandItem, IrisCommandPalette, type IrisCommandPaletteProps, IrisCopyButton, type IrisCopyButtonProps, type IrisCopyButtonSize, IrisCountdown, type IrisCountdownProps, type IrisCountdownSize, IrisDatePicker, type IrisDatePickerProps, type IrisDateRange, IrisDateRangePicker, type IrisDateRangePickerProps, IrisDescriptions, type IrisDescriptionsItem, type IrisDescriptionsLayout, type IrisDescriptionsProps, IrisDialog, IrisDialogClose, type IrisDialogCloseProps, IrisDialogContent, type IrisDialogContentProps, IrisDialogDescription, type IrisDialogDescriptionProps, type IrisDialogProps, IrisDialogTitle, type IrisDialogTitleProps, IrisDialogTrigger, type IrisDialogTriggerProps, IrisDivider, type IrisDividerOrientation, type IrisDividerProps, type IrisDividerSpacing, IrisDragger, type IrisDraggerBounds, type IrisDraggerPosition, type IrisDraggerProps, IrisDrawer, IrisDrawerClose, type IrisDrawerCloseProps, IrisDrawerContent, type IrisDrawerContentProps, type IrisDrawerProps, type IrisDrawerSide, IrisDrawerTitle, type IrisDrawerTitleProps, IrisDrawerTrigger, type IrisDrawerTriggerProps, IrisDropdown, IrisDropdownItem, type IrisDropdownItemProps, IrisDropdownMenu, type IrisDropdownMenuProps, type IrisDropdownProps, IrisDropdownSeparator, type IrisDropdownSeparatorProps, IrisDropdownTrigger, type IrisDropdownTriggerProps, IrisEmptyState, type IrisEmptyStateProps, IrisFieldset, type IrisFieldsetProps, IrisFileUpload, type IrisFileUploadFile, type IrisFileUploadProps, type IrisFileUploadRejectReason, type IrisFileUploadRejection, IrisFloatButton, type IrisFloatButtonAction, type IrisFloatButtonProps, type IrisFloatButtonShape, IrisFormField, type IrisFormFieldProps, IrisGauge, type IrisGaugeProps, type IrisGaugeStatus, IrisIcon, type IrisIconProps, IrisImage, type IrisImageProps, IrisInput, type IrisInputProps, type IrisInputSize, type IrisInputType, IrisKbd, type IrisKbdProps, type IrisKbdSize, IrisList, type IrisListItem, type IrisListProps, IrisMarquee, type IrisMarqueeDirection, type IrisMarqueeProps, IrisMasonry, type IrisMasonryProps, type IrisMentionOption, IrisMentions, type IrisMentionsProps, IrisMenu, IrisMenuContent, type IrisMenuContentProps, IrisMenuItem, type IrisMenuItemProps, type IrisMenuProps, IrisMenuSeparator, type IrisMenuSeparatorProps, IrisMenuSub, type IrisMenuSubProps, IrisMenuTrigger, type IrisMenuTriggerProps, IrisNumberInput, type IrisNumberInputProps, type IrisNumberInputSize, IrisOtpInput, type IrisOtpInputProps, type IrisOtpInputSize, type IrisOtpInputType, IrisPagination, type IrisPaginationProps, type IrisPaginationSize, IrisPasswordInput, type IrisPasswordInputProps, IrisPopover, IrisPopoverContent, type IrisPopoverContentProps, type IrisPopoverProps, IrisPopoverTrigger, type IrisPopoverTriggerProps, IrisProgress, IrisProgressCircle, type IrisProgressCircleProps, type IrisProgressCircleStatus, type IrisProgressProps, type IrisProgressSize, type IrisProgressTone, IrisRadio, IrisRadioGroup, type IrisRadioGroupProps, type IrisRadioProps, type IrisRadioSize, IrisRangeSlider, type IrisRangeSliderProps, type IrisRangeSliderValue, IrisRating, type IrisRatingProps, type IrisRatingSize, IrisResizer, type IrisResizerHandle, type IrisResizerProps, type IrisResizerSize, IrisResult, type IrisResultProps, type IrisResultStatus, IrisRibbon, type IrisRibbonPlacement, type IrisRibbonProps, IrisScrollArea, type IrisScrollAreaAxis, type IrisScrollAreaProps, IrisSegmented, type IrisSegmentedOption, type IrisSegmentedProps, type IrisSegmentedSize, IrisSelect, type IrisSelectItem, type IrisSelectProps, type IrisSelectSize, type IrisSelectTriggerState, IrisSkeleton, type IrisSkeletonProps, type IrisSkeletonShape, IrisSlider, type IrisSliderOrientation, type IrisSliderProps, IrisSlot, type IrisSlotProps, IrisSpinner, type IrisSpinnerProps, type IrisSpinnerSize, IrisSplitButton, type IrisSplitButtonAction, type IrisSplitButtonProps, type IrisSplitButtonSize, type IrisSplitButtonVariant, IrisSplitter, type IrisSplitterOrientation, type IrisSplitterProps, IrisStatistic, type IrisStatisticProps, type IrisStatisticSize, type IrisStatisticTrend, type IrisStepStatus, IrisStepper, type IrisStepperOrientation, type IrisStepperProps, IrisStepperStep, type IrisStepperStepProps, IrisSwitch, type IrisSwitchProps, type IrisSwitchSize, IrisTable, type IrisTableAggregateOp, type IrisTableCellClickParams, type IrisTableCellEditEvent, type IrisTableColumn, type IrisTableColumnWidths, type IrisTableContextMenuParams, type IrisTableEditor, type IrisTableFormConfig, type IrisTableFormField, type IrisTableHandle, type IrisTablePagerConfig, type IrisTableProps, type IrisTableProxyQueryParams, type IrisTableRenderDetail, type IrisTableRowExpandable, type IrisTableSeqMethodParams, type IrisTableSortDirection, type IrisTableSortState, type IrisTableTooltipConfig, type IrisTableValidConfig, type IrisTableVirtualOptions, IrisTabs, IrisTabsContent, type IrisTabsContentProps, IrisTabsList, type IrisTabsListProps, type IrisTabsOrientation, type IrisTabsProps, IrisTabsTrigger, type IrisTabsTriggerProps, IrisTagInput, type IrisTagInputProps, IrisTextarea, type IrisTextareaProps, type IrisTextareaSize, IrisTimePicker, type IrisTimePickerFormat, type IrisTimePickerProps, type IrisTimeValue, IrisTimeline, type IrisTimelineItem, type IrisTimelineProps, type IrisTimelineVariant, type IrisToast, type IrisToastInput, type IrisToastPosition, type IrisToastVariant, IrisToastViewport, type IrisToastViewportProps, IrisToggleGroup, IrisToggleGroupItem, type IrisToggleGroupItemProps, type IrisToggleGroupMultipleProps, type IrisToggleGroupOrientation, type IrisToggleGroupProps, type IrisToggleGroupSingleProps, type IrisToggleGroupSize, type IrisToggleGroupType, type IrisToggleGroupValue, type IrisToggleGroupVariant, IrisToolbar, type IrisToolbarOrientation, type IrisToolbarProps, IrisTooltip, type IrisTooltipProps, IrisTour, type IrisTourProps, type IrisTourStep, IrisTransfer, type IrisTransferItem, type IrisTransferProps, type IrisTransferVirtualOptions, IrisTree, type IrisTreeNode, type IrisTreeProps, IrisTreeSelect, type IrisTreeSelectNode, type IrisTreeSelectProps, type IrisTreeSelectSize, type IrisTreeSelectionMode, type IrisTreeVirtualOptions, IrisVirtualScroll, type IrisVirtualScrollAlign, type IrisVirtualScrollHandle, type IrisVirtualScrollProps, IrisVisuallyHidden, type IrisVisuallyHiddenProps, IrisWatermark, type IrisWatermarkProps, MenuContext, type MenuContextValue, PopoverContext, type PopoverContextValue, RadioGroupContext, type RadioGroupContextValue, StepperContext, type StepperContextValue, TabsContext, type TabsContextValue, ToggleGroupContext, type ToggleGroupContextValue, type UseDragOptions, type UseToastReturn, __PROGRESS_STYLE_ID, __SKELETON_STYLE_ID, __SPINNER_STYLE_ID, __resetProgressStyles, __resetSkeletonStyles, __resetSpinnerStyles, clearToasts, defaultFilter, dismissToast, downloadCsv, downloadExcel, exportCsv, exportExcel, formatBytes, formatRemaining, getToasts, pushToast, subscribeToasts, useAccordionContext, useDialogContext, useDisposableScope, useDrag, useDrawerContext, useDropdownContext, useMachine, useMenuContext, usePopoverContext, useReconnectingSource, useResilientFetcher, useStepperContext, useStore, useStoreSelector, useTabsContext, useToast, useToggleGroupContext };
+export { AccordionContext, type AccordionContextValue, DialogContext, type DialogContextValue, type DragState, DrawerContext, type DrawerContextValue, DropdownContext, type DropdownContextValue, IRIS_URL_STATE_KEY, IrisAccordion, IrisAccordionItem, type IrisAccordionItemProps, type IrisAccordionProps, type IrisAccordionValue, IrisAffix, type IrisAffixProps, IrisAlert, type IrisAlertProps, type IrisAlertTone, IrisAnchor, type IrisAnchorItem, type IrisAnchorProps, IrisAspectRatio, type IrisAspectRatioProps, IrisAvatar, type IrisAvatarProps, type IrisAvatarShape, type IrisAvatarSize, IrisBackTop, type IrisBackTopProps, IrisBadge, type IrisBadgeProps, type IrisBadgeSize, type IrisBadgeTone, type IrisBadgeVariant, IrisBanner, type IrisBannerProps, type IrisBannerTone, IrisBreadcrumb, IrisBreadcrumbItem, type IrisBreadcrumbItemProps, type IrisBreadcrumbProps, IrisButton, type IrisButtonProps, type IrisButtonSize, type IrisButtonType, type IrisButtonVariant, IrisCalendar, type IrisCalendarProps, IrisCard, type IrisCardPadding, type IrisCardProps, type IrisCardVariant, IrisCarousel, type IrisCarouselProps, IrisCascader, type IrisCascaderNode, type IrisCascaderProps, type IrisCascaderSize, IrisCheckbox, type IrisCheckboxProps, type IrisCheckboxSize, type IrisCheckboxValue, IrisChip, type IrisChipProps, type IrisChipSize, type IrisChipTone, type IrisChipVariant, IrisColorPicker, type IrisColorPickerProps, IrisCombobox, type IrisComboboxOption, type IrisComboboxProps, type IrisComboboxSize, type IrisCommandItem, IrisCommandPalette, type IrisCommandPaletteProps, IrisCopyButton, type IrisCopyButtonProps, type IrisCopyButtonSize, IrisCountdown, type IrisCountdownProps, type IrisCountdownSize, IrisDatePicker, type IrisDatePickerProps, type IrisDateRange, IrisDateRangePicker, type IrisDateRangePickerProps, IrisDescriptions, type IrisDescriptionsItem, type IrisDescriptionsLayout, type IrisDescriptionsProps, IrisDialog, IrisDialogClose, type IrisDialogCloseProps, IrisDialogContent, type IrisDialogContentProps, IrisDialogDescription, type IrisDialogDescriptionProps, type IrisDialogProps, IrisDialogTitle, type IrisDialogTitleProps, IrisDialogTrigger, type IrisDialogTriggerProps, IrisDivider, type IrisDividerOrientation, type IrisDividerProps, type IrisDividerSpacing, IrisDragger, type IrisDraggerBounds, type IrisDraggerPosition, type IrisDraggerProps, IrisDrawer, IrisDrawerClose, type IrisDrawerCloseProps, IrisDrawerContent, type IrisDrawerContentProps, type IrisDrawerProps, type IrisDrawerSide, IrisDrawerTitle, type IrisDrawerTitleProps, IrisDrawerTrigger, type IrisDrawerTriggerProps, IrisDropdown, IrisDropdownItem, type IrisDropdownItemProps, IrisDropdownMenu, type IrisDropdownMenuProps, type IrisDropdownProps, IrisDropdownSeparator, type IrisDropdownSeparatorProps, IrisDropdownTrigger, type IrisDropdownTriggerProps, IrisEmptyState, type IrisEmptyStateProps, IrisFieldset, type IrisFieldsetProps, IrisFileUpload, type IrisFileUploadFile, type IrisFileUploadProps, type IrisFileUploadRejectReason, type IrisFileUploadRejection, IrisFloatButton, type IrisFloatButtonAction, type IrisFloatButtonProps, type IrisFloatButtonShape, IrisFormField, type IrisFormFieldProps, IrisGauge, type IrisGaugeProps, type IrisGaugeStatus, IrisIcon, type IrisIconProps, IrisImage, type IrisImageProps, IrisInput, type IrisInputProps, type IrisInputSize, type IrisInputType, IrisKbd, type IrisKbdProps, type IrisKbdSize, IrisList, type IrisListItem, type IrisListProps, IrisMarquee, type IrisMarqueeDirection, type IrisMarqueeProps, IrisMasonry, type IrisMasonryProps, type IrisMentionOption, IrisMentions, type IrisMentionsProps, IrisMenu, IrisMenuContent, type IrisMenuContentProps, IrisMenuItem, type IrisMenuItemProps, type IrisMenuProps, IrisMenuSeparator, type IrisMenuSeparatorProps, IrisMenuSub, type IrisMenuSubProps, IrisMenuTrigger, type IrisMenuTriggerProps, IrisMonthPicker, type IrisMonthPickerProps, IrisNumberInput, type IrisNumberInputProps, type IrisNumberInputSize, IrisOtpInput, type IrisOtpInputProps, type IrisOtpInputSize, type IrisOtpInputType, IrisPagination, type IrisPaginationProps, type IrisPaginationSize, IrisPasswordInput, type IrisPasswordInputProps, IrisPopover, IrisPopoverContent, type IrisPopoverContentProps, type IrisPopoverProps, IrisPopoverTrigger, type IrisPopoverTriggerProps, IrisProgress, IrisProgressCircle, type IrisProgressCircleProps, type IrisProgressCircleStatus, type IrisProgressProps, type IrisProgressSize, type IrisProgressTone, IrisRadio, IrisRadioGroup, type IrisRadioGroupProps, type IrisRadioProps, type IrisRadioSize, IrisRangeSlider, type IrisRangeSliderProps, type IrisRangeSliderValue, IrisRating, type IrisRatingProps, type IrisRatingSize, IrisResizer, type IrisResizerHandle, type IrisResizerProps, type IrisResizerSize, IrisResult, type IrisResultProps, type IrisResultStatus, IrisRibbon, type IrisRibbonPlacement, type IrisRibbonProps, IrisScrollArea, type IrisScrollAreaAxis, type IrisScrollAreaProps, IrisSegmented, type IrisSegmentedOption, type IrisSegmentedProps, type IrisSegmentedSize, IrisSelect, type IrisSelectItem, type IrisSelectProps, type IrisSelectSize, type IrisSelectTriggerState, IrisSkeleton, type IrisSkeletonProps, type IrisSkeletonShape, IrisSlider, type IrisSliderOrientation, type IrisSliderProps, IrisSlot, type IrisSlotProps, IrisSpinner, type IrisSpinnerProps, type IrisSpinnerSize, IrisSplitButton, type IrisSplitButtonAction, type IrisSplitButtonProps, type IrisSplitButtonSize, type IrisSplitButtonVariant, IrisSplitter, type IrisSplitterOrientation, type IrisSplitterProps, IrisStatistic, type IrisStatisticProps, type IrisStatisticSize, type IrisStatisticTrend, type IrisStepStatus, IrisStepper, type IrisStepperOrientation, type IrisStepperProps, IrisStepperStep, type IrisStepperStepProps, IrisSwitch, type IrisSwitchProps, type IrisSwitchSize, IrisTable, type IrisTableAggregateOp, type IrisTableAlign, type IrisTableAuditEntry, type IrisTableAutoSaveStateConfig, type IrisTableCellClickParams, type IrisTableCellEditEvent, type IrisTableColumn, type IrisTableColumnStat, type IrisTableColumnWidths, type IrisTableConditionalStyle, type IrisTableContextMenuParams, type IrisTableCustomConfig, type IrisTableEditClosedParams, type IrisTableEditDirtyConfig, type IrisTableEditStartParams, type IrisTableEditor, type IrisTableEmptyState, type IrisTableEvent, type IrisTableFilterOption, type IrisTableFilterValues, type IrisTableFooterMethodParams, type IrisTableFooterSpanMethod, type IrisTableFooterSpanParams, type IrisTableFormConfig, type IrisTableFormField, type IrisTableHandle, type IrisTableMergeCell, type IrisTableMergeFooterItem, type IrisTableNamedView, type IrisTablePagerConfig, type IrisTablePersistConfig, type IrisTablePersistPiece, type IrisTablePersistedState, type IrisTablePresenceEntry, type IrisTableProps, type IrisTableProxyQueryParams, type IrisTableRenderDetail, type IrisTableRowDragBetweenTarget, type IrisTableRowExpandable, type IrisTableScrollParams, type IrisTableScrollbarConfig, type IrisTableSeqMethodParams, type IrisTableSortDirection, type IrisTableSortState, type IrisTableSpan, type IrisTableTab, type IrisTableTooltipConfig, type IrisTableUrlState, type IrisTableValidConfig, type IrisTableViewConfig, type IrisTableVirtualOptions, IrisTabs, IrisTabsContent, type IrisTabsContentProps, IrisTabsList, type IrisTabsListProps, type IrisTabsOrientation, type IrisTabsProps, IrisTabsTrigger, type IrisTabsTriggerProps, IrisTagInput, type IrisTagInputProps, IrisTextarea, type IrisTextareaProps, type IrisTextareaSize, IrisTimePicker, type IrisTimePickerFormat, type IrisTimePickerProps, type IrisTimeValue, IrisTimeline, type IrisTimelineItem, type IrisTimelineProps, type IrisTimelineVariant, type IrisToast, type IrisToastInput, type IrisToastPosition, type IrisToastVariant, IrisToastViewport, type IrisToastViewportProps, IrisToggleGroup, IrisToggleGroupItem, type IrisToggleGroupItemProps, type IrisToggleGroupMultipleProps, type IrisToggleGroupOrientation, type IrisToggleGroupProps, type IrisToggleGroupSingleProps, type IrisToggleGroupSize, type IrisToggleGroupType, type IrisToggleGroupValue, type IrisToggleGroupVariant, IrisToolbar, type IrisToolbarOrientation, type IrisToolbarProps, IrisTooltip, type IrisTooltipProps, IrisTour, type IrisTourProps, type IrisTourStep, IrisTransfer, type IrisTransferItem, type IrisTransferProps, type IrisTransferVirtualOptions, IrisTree, type IrisTreeNode, type IrisTreeProps, IrisTreeSelect, type IrisTreeSelectNode, type IrisTreeSelectProps, type IrisTreeSelectSize, type IrisTreeSelectionMode, type IrisTreeVirtualOptions, IrisVirtualScroll, type IrisVirtualScrollAlign, type IrisVirtualScrollHandle, type IrisVirtualScrollProps, IrisVisuallyHidden, type IrisVisuallyHiddenProps, IrisWatermark, type IrisWatermarkProps, MenuContext, type MenuContextValue, PopoverContext, type PopoverContextValue, RadioGroupContext, type RadioGroupContextValue, StepperContext, type StepperContextValue, TabsContext, type TabsContextValue, ToggleGroupContext, type ToggleGroupContextValue, type UseDragOptions, type UseToastReturn, __PROGRESS_STYLE_ID, __SKELETON_STYLE_ID, __SPINNER_STYLE_ID, __resetProgressStyles, __resetSkeletonStyles, __resetSpinnerStyles, clearToasts, defaultFilter, dismissToast, downloadCsv, downloadExcel, exportCsv, exportExcel, formatBytes, formatRemaining, getToasts, pushToast, subscribeToasts, useAccordionContext, useDialogContext, useDisposableScope, useDrag, useDrawerContext, useDropdownContext, useMachine, useMenuContext, usePopoverContext, useReconnectingSource, useResilientFetcher, useStepperContext, useStore, useStoreSelector, useTabsContext, useToast, useToggleGroupContext };