@iris-ui-kit/vue 0.2.28 → 0.2.30

package/dist/index.d.cts

@@ -1,8 +1,8 @@
 import * as vue from 'vue';
 import { ShallowRef, Ref, VNode, PropType, ComputedRef, InjectionKey } from 'vue';
 import * as _iris_ui_kit_core from '@iris-ui-kit/core';
-import { ReadonlyStore, Store, RealtimeHandlers, RealtimeOptions, RealtimeStatus, ResilientFetcherOptions, ResilientFetcher, DisposableScope, Variant, Size, Placement, FloatingMachine, 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, RealtimeHandlers, RealtimeOptions, RealtimeStatus, ResilientFetcherOptions, ResilientFetcher, DisposableScope, Variant, Size, Placement, FloatingMachine, TableViewConfig, TableTab, AuditLogEntry, TableNamedView, TableViewSnapshot, 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, parseCsv, rgbToHex, rgbToHsv, rgbaToHsva, startOfDay, startOfMonth, visibleNav } from '@iris-ui-kit/core';
 export { IrisThemeContext, IrisThemeKey, ThemeProvider, UseThemeReturn, useColorScheme, useDirection, useTheme, useThemeContext } from './theme.cjs';
 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 { IrisSkinContext, IrisSkinKey, SkinProvider, UseSkinReturn, useSkin, useSkinContext } from './skins.cjs';
@@ -4017,8 +4017,8 @@ declare const IrisResizer: vue.DefineComponent<vue.ExtractPropTypes<{
 }>, {
     minWidth: number;
     disabled: boolean;
-    maxHeight: number;
     minHeight: number;
+    maxHeight: number;
     handles: IrisResizerHandle[];
     maxWidth: number;
     keepAspect: boolean;
@@ -4231,13 +4231,157 @@ declare const IrisVirtualScroll: vue.DefineComponent<vue.ExtractPropTypes<{
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 type IrisTableSortDirection = 'asc' | 'desc';
+/** Table row-density preset. */
+type IrisTableDensity = 'comfortable' | 'compact' | 'cozy';
+/** Clipboard range-copy options. Invalid runtime formats fall back to TSV. */
+interface IrisTableClipConfig {
+    copy?: boolean;
+    paste?: boolean;
+    copyFormat?: 'tsv' | 'csv' | 'html';
+    copyWithFormat?: boolean;
+}
 interface IrisTableSortState {
     key: string;
     direction: IrisTableSortDirection;
 }
+type IrisTableViewConfig = TableViewConfig;
+type IrisTableViewSnapshot = TableViewSnapshot;
+type IrisTableNamedView = TableNamedView<IrisTableViewSnapshot>;
+type IrisTableTab = TableTab;
+/** Params delivered to {@link IrisTableProxyConfig.query} (vxe proxyConfig parity). */
+interface IrisTableProxyQueryParams {
+    /** 1-based page number. */
+    page: number;
+    pageSize: number;
+    sort: IrisTableSortState | null;
+    /**
+     * Multi-column sort (multiSort mode), most-significant first. Only set in
+     * multiSort mode — single mode keeps passing `sort`.
+     */
+    sorts?: IrisTableSortState[];
+    /** key → filter value (empty string = inactive, stripped by the controller). */
+    filters: Record<string, string>;
+}
+/**
+ * Server-side data proxy (vxe-grid proxyConfig parity, query slice). When set,
+ * `data` is ignored: rows come from `query` (paged), the table renders a pager
+ * below the body, and inline-edit write-back keeps working on a local copy.
+ */
+interface IrisTableProxyConfig<Row = Record<string, unknown>> {
+    /** Fetch one page. 1-based `page`; `sort`/`sorts`/`filters` are the ACTIVE state. */
+    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. Default false. */
+    remoteSort?: boolean;
+    /** Filter changes re-query the server instead of filtering client-side. 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;
+}
+/** One search-form field (vxe-grid formConfig items parity). */
+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;
+}
+/** Search-form configuration (vxe-grid formConfig parity). */
+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;
+}
+/** One custom toolbar action button (vxe toolbar buttons parity). */
+interface IrisTableToolbarButton {
+    key: string;
+    label: string;
+    onClick: () => void;
+    icon?: string;
+}
+/** Batch action (vxe toolbar batch parity): rendered while multi-selection is non-empty. */
+interface IrisTableToolbarBatch {
+    label: string;
+    onClick: (keys: Array<string | number>) => void;
+    icon?: string;
+}
+/** Toolbar (vxe-grid toolbarConfig parity, minimal built-ins). */
+interface IrisTableToolbarConfig {
+    title?: string;
+    /** Fired by the refresh button. */
+    onRefresh?: () => void;
+    /** Fired by the export button (vxe toolbar export parity). */
+    onExport?: () => void;
+    /** Fired with parsed CSV rows by the import button. */
+    onImport?: (rows: Array<Record<string, unknown>>) => void;
+    /** Custom action buttons rendered after the built-ins. */
+    buttons?: IrisTableToolbarButton[];
+    /** Batch action rendered while `selectable === 'multi'` and rows are selected. */
+    batch?: IrisTableToolbarBatch;
+}
 type IrisTableEditor = 'text' | 'number';
 /** Aggregation op for a column's summary/footer cell. */
 type IrisTableAggregateOp = 'sum' | 'avg' | 'min' | 'max' | 'count';
+/** 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[]>;
+/**
+ * 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;
+}
+/**
+ * Right-click context menu (vxe-grid contextMenu parity). 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.
+ */
+interface IrisTableContextMenuConfig<Row = Record<string, unknown>> {
+    items: (params: IrisTableContextMenuParams<Row>) => Array<{
+        key: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+    onSelect: (key: string, params: IrisTableContextMenuParams<Row>) => void;
+}
 interface IrisTableColumn<Row = Record<string, unknown>> {
     /** Stable unique column identifier; used for slot names and sort state. */
     key: string;
@@ -4245,8 +4389,30 @@ interface IrisTableColumn<Row = Record<string, unknown>> {
     title: string;
     /** Path inside the row to read the default cell value from. Defaults to `key`. */
     dataIndex?: keyof Row | string;
+    /**
+     * Single-line cell formula (batch EK, 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, summary, range copy and CSV export (all via the
+     * `getCellValue` choke point). Errors / unknown fields → null (empty
+     * cell). An `editable` formula column is DISPLAY-ONLY: inline editing and
+     * row mode ignore it. Overrides `dataIndex`.
+     */
+    formula?: string;
+    /** Format the masked display value; copyWithFormat uses this string. */
+    formatter?: (value: unknown, row: Row) => unknown;
+    /** Mask the display/copy value before the formatter. */
+    mask?: 'sensitive' | ((value: unknown) => string);
+    /** Copy/export the raw value instead of the masked value (formatter copy remains masked). */
+    exportRaw?: boolean;
     /** Allow sorting by this column. */
     sortable?: boolean;
+    /** Show a header filter trigger + checkbox panel (vxe filterConfig parity). 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[];
     /** Initial width (px or CSS length). */
     width?: number | string;
     /** Minimum width when resizing. Default 60. */
@@ -4316,374 +4482,672 @@ interface IrisTableVirtualOptions {
 }
 /** Map of column key → current width in px (after any resizing). */
 type IrisTableColumnWidths = Record<string, number>;
+/** Column visibility map (vxe columnConfig.visible parity): column key → visible. Default true. */
+type IrisTableColumnVisibility = Record<string, boolean>;
+/** Params delivered to `IrisTableProps.spanMethod` (vxe span-method parity). */
+interface IrisTableSpanMethodParams {
+    /** 0-based row index over the body rows. */
+    rowIndex: number;
+    /** 0-based leaf-column index (seq / selection / drag tracks excluded). */
+    columnIndex: number;
+}
+/** Span result returned by `IrisTableProps.spanMethod` (vxe span-method parity): both dimensions default to 1; values > 1 make the cell span adjacent cells, which then render null. */
+interface IrisTableSpan {
+    rowspan?: number;
+    colspan?: number;
+}
+/** Column drag-sort (vxe columnDragConfig parity). Reorders leaf columns on drop; the parent owns columns (pass the reordered array back). Grouped headers are NOT supported (documented simplification). */
+interface IrisTableColumnDrag<Row = Record<string, unknown>> {
+    /** Called with the reordered column array after a drop. */
+    onReorder: (columns: IrisTableColumn<Row>[]) => void;
+}
+/** Row drag-sort (vxe rowDragConfig parity). Renders a drag handle per row; a drop reorders the table's LOCAL rows and reports through `onDataChange` (plus this callback, React parity). */
+interface IrisTableRowDrag<Row = Record<string, unknown>> {
+    /** Called with the reordered row array after a drop. */
+    onReorder: (rows: Row[]) => void;
+}
+/** Snapshot returned by `IrisTableExpose.getProxyInfo` (vxe getProxyInfo parity). */
+interface IrisTableProxyInfo {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+/** Imperative handle exposed by IrisTable (vxe loadData/reloadData/commitProxy/getProxyInfo parity, batch Y). */
+interface IrisTableExpose<Row = Record<string, unknown>> {
+    /** Replace the live row list WITHOUT a query (vxe loadData parity): writes the local rows ref (proxy liveData / local override) and fires `onDataChange`. In proxy mode the controller's total/page stay unchanged until the next query. */
+    loadData: (rows: Row[]) => void;
+    /** Re-fetch the current page (vxe reloadData parity — alias of the proxy refetch). */
+    reloadData: () => void;
+    /** Merge params into the proxy query and fire the request (vxe commitProxy parity). */
+    commitProxy: (overrides: Partial<IrisTableProxyQueryParams>) => void;
+    /** Proxy state snapshot: page/pageSize/total; null without a proxy (vxe getProxyInfo parity). */
+    getProxyInfo: () => IrisTableProxyInfo | null;
+    /** Remove rows by row-key without issuing a query; missing keys are no-ops. */
+    removeRows: (keys: Array<string | number>) => void;
+    /** Snapshot (copy) of the currently filtered + sorted body rows. */
+    getFilteredData: () => Row[];
+    /** Serialize the current filtered/sorted row view using visible leaf columns. */
+    exportCurrentViewCsv: () => string;
+    /** Serialize the current view plus named bare row sets as CSV segments. */
+    exportMultiCsv: () => string;
+    /** Compare two exported-state JSON strings; never throws on invalid input. */
+    compareStates: (a: string, b: string) => string;
+    /** Scroll the rendered row with `key` into view; missing/virtualized rows are no-ops. */
+    scrollToRow: (key: string | number) => void;
+    /** Scroll and transiently highlight the rendered row with `key`; the target clears after 2s. */
+    goToRow: (key: string | number) => void;
+    /** Audit trail snapshot (batch EN, iris 独有 — mirror react batch AT): newest-first entries (seq/at/type/rowKey/column/old→new) — an empty array when `auditLog` is off or nothing was committed yet. */
+    getAuditLog: () => ReadonlyArray<AuditLogEntry>;
+    /** Wipe every audit entry (batch EN, iris 独有): the seq counter never resets — audit integrity. No-op without `auditLog` (the ring is already empty). */
+    clearAuditLog: () => void;
+}
 
-/**
- * Data-driven table. Renders as a CSS-grid layout under the hood (no native
- * `<table>` element) so it can support virtual scrolling and column resize
- * uniformly. ARIA roles (`role="table" / "row" / "columnheader" / "cell"`)
- * are wired explicitly for screen readers.
- *
- * **Features**:
- *   - Column-driven rendering with optional `#header.<key>` and `#cell.<key>` slots
- *   - Row activation via `rowClick` and `rowDblclick` events
- *   - Sorting (controlled or uncontrolled, cycles `none → asc → desc → none`)
- *   - Row selection (single / multi) with master checkbox + indeterminate
- *   - **Column resize** (`resizable-columns`) — draggable handle on each
- *     column boundary, `v-model:columnWidths` exposes the map
- *   - **Virtual scrolling** (`:virtual-scroll="{ itemHeight, height }"`) —
- *     renders only the visible row window; viable for 100k+ rows
- *
- * @example
- *   <IrisTable
- *     :columns="cols"
- *     :data="rows"
- *     row-key="id"
- *     selectable="multi"
- *     resizable-columns
- *     :virtual-scroll="{ itemHeight: 36, height: 480 }"
- *   />
- */
+/** Data-driven CSS-grid table with explicit ARIA roles, sorting, selection,
+ * column resizing, virtual scrolling, and header/cell slots. */
 declare const IrisTable: vue.DefineComponent<vue.ExtractPropTypes<{
-    striped: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly multiSort: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    editConfig: {
-        type: PropType<{
+    readonly multiSortState: {
+        readonly type: vue.PropType<IrisTableSortState[]>;
+        readonly default: undefined;
+    };
+    readonly defaultMultiSort: {
+        readonly type: vue.PropType<IrisTableSortState[]>;
+        readonly default: undefined;
+    };
+    readonly striped: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly editConfig: {
+        readonly type: vue.PropType<{
             trigger?: "click" | "dblclick" | "manual";
             showAsterisk?: boolean;
             autoClear?: boolean;
+            mode?: "cell" | "row";
         }>;
-        default: undefined;
+        readonly default: undefined;
     };
-    bordered: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly bordered: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
     };
-    /** Enable per-column resize handles. Combine with `v-model:columnWidths` for persistence. */
-    resizableColumns: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly density: {
+        readonly type: vue.PropType<IrisTableDensity>;
+        readonly default: "comfortable";
     };
-    /** Controlled column widths in px. */
-    columnWidths: {
-        type: PropType<IrisTableColumnWidths>;
-        default: undefined;
+    readonly densityToggle: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /** Enable virtual scrolling for the body. */
-    virtualScroll: {
-        type: PropType<IrisTableVirtualOptions>;
-        default: undefined;
+    readonly editPreview: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /** Show the loading state instead of rows. */
-    loading: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly pattern: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /** Show the error state instead of rows (takes precedence over loading). */
-    error: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly patternFill: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    onRetry: {
-        type: PropType<(() => void) | undefined>;
-        default: undefined;
+    readonly views: {
+        readonly type: vue.PropType<IrisTableViewConfig>;
+        readonly default: undefined;
     };
-    /** Render only the horizontally-visible columns (+ pinned + overscan) for wide tables. */
-    columnVirtualization: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly onActiveViewChange: {
+        readonly type: vue.PropType<(key: string | null) => void>;
+        readonly default: undefined;
     };
-    /**
-     * Enable WAI-ARIA grid keyboard navigation: the table becomes `role="grid"`
-     * and Arrow / Home / End / Page Up·Down move a roving cell focus across the
-     * data cells. Off by default; opt-in and additive (no effect on mouse / Tab
-     * behavior). Pairs best without virtualization (the focused cell must be
-     * rendered) and does not hijack keystrokes while a cell is being edited.
-     */
-    keyboardNavigation: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly tableTabs: {
+        readonly type: vue.PropType<IrisTableTab[]>;
+        readonly default: undefined;
     };
-    /**
-     * Enable rectangular cell-range selection (Excel-style). Click starts a
-     * range; Shift+Click or Shift+Arrow extends it; Escape clears it.
-     * Cells within the range get `data-iris-cell-selected="true"`.
-     */
-    cellRange: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly pinnedDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /**
-     * Render an expandable detail panel beneath a row. Providing this adds a
-     * leading expand-toggle column; clicking it reveals a full-width detail row.
-     * (Not applied in the virtual-scroll path.)
-     */
-    renderDetail: {
-        type: PropType<IrisTableRenderDetail<Record<string, unknown>>>;
-        default: undefined;
+    readonly onColumnPinnedChange: {
+        readonly type: vue.PropType<(key: string, side: "left" | "right" | null) => void>;
+        readonly default: undefined;
     };
-    /** Which rows can expand a detail panel. Defaults to all rows when `renderDetail` is set. */
-    rowExpandable: {
-        type: PropType<IrisTableRowExpandable<Record<string, unknown>>>;
-        default: undefined;
+    readonly onPinnedCountChange: {
+        readonly type: vue.PropType<(count: number) => void>;
+        readonly default: undefined;
     };
-    /** Initially-expanded row keys (uncontrolled). */
-    defaultExpandedRowKeys: {
-        type: PropType<Array<string | number>>;
-        default: undefined;
+    readonly autoDetectTypes: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /**
-     * Read a row's child rows to render the table as a TREE. Providing this
-     * enables tree mode: `data` is treated as the root rows, each row's first
-     * cell gains a depth indent + an expand/collapse toggle (when it has
-     * children), and the expand state reuses `defaultExpandedRowKeys` /
-     * `expandedRowsChange`. Column sort reorders siblings hierarchically (each
-     * level sorted, structure kept), and tree rows virtualize like flat rows
-     * when `virtualScroll` is set (unless `renderDetail` is also used, since
-     * detail panels are variable-height).
-     */
-    getSubRows: {
-        type: PropType<(row: Record<string, unknown>) => Array<Record<string, unknown>> | undefined>;
-        default: undefined;
+    readonly responsive: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /**
-     * Cascade multi-row selection through the complete tree supplied by
-     * `getSubRows`. Selecting a branch selects every descendant (including
-     * collapsed rows); partially selected branches render indeterminate.
-     * Ignored outside tree mode and for non-multi selection.
-     */
-    treeSelectionCascade: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly exportNames: {
+        readonly type: vue.PropType<Array<{
+            key: string;
+            ref: () => Array<Record<string, unknown>>;
+        }>>;
+        readonly default: undefined;
+    };
+    readonly resizableColumns: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly columnWidths: {
+        readonly type: vue.PropType<IrisTableColumnWidths>;
+        readonly default: undefined;
+    };
+    readonly virtualScroll: {
+        readonly type: vue.PropType<IrisTableVirtualOptions>;
+        readonly default: undefined;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly error: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly printable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly importPreview: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onRetry: {
+        readonly type: vue.PropType<(() => void) | undefined>;
+        readonly default: undefined;
+    };
+    readonly columnVirtualization: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly keyboardNavigation: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly cellRange: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly clipConfig: {
+        readonly type: vue.PropType<IrisTableClipConfig>;
+        readonly default: undefined;
+    };
+    readonly renderDetail: {
+        readonly type: vue.PropType<IrisTableRenderDetail<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly rowExpandable: {
+        readonly type: vue.PropType<IrisTableRowExpandable<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly defaultExpandedRowKeys: {
+        readonly type: vue.PropType<Array<string | number>>;
+        readonly default: undefined;
+    };
+    readonly getSubRows: {
+        readonly type: vue.PropType<(row: Record<string, unknown>) => Array<Record<string, unknown>> | undefined>;
+        readonly default: undefined;
+    };
+    readonly treeSelectionCascade: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    selectable: {
-        type: PropType<"none" | "single" | "multi">;
+    readonly proxyConfig: {
+        readonly type: vue.PropType<IrisTableProxyConfig<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly formConfig: {
+        readonly type: vue.PropType<IrisTableFormConfig>;
+        readonly default: undefined;
+    };
+    readonly toolbar: {
+        readonly type: vue.PropType<IrisTableToolbarConfig>;
+        readonly default: undefined;
+    };
+    readonly auditLog: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly columnVisibility: {
+        readonly type: vue.PropType<IrisTableColumnVisibility>;
+        readonly default: undefined;
+    };
+    readonly filters: {
+        readonly type: vue.PropType<Record<string, string>>;
+        readonly default: undefined;
+    };
+    readonly filterValues: {
+        readonly type: vue.PropType<IrisTableFilterValues>;
+        readonly default: undefined;
+    };
+    readonly onFilterValuesChange: {
+        readonly type: vue.PropType<(next: IrisTableFilterValues) => void>;
+        readonly default: undefined;
+    };
+    readonly contextMenu: {
+        readonly type: vue.PropType<IrisTableContextMenuConfig<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly lazyLoad: {
+        readonly type: vue.PropType<(row: Record<string, unknown>, load: (children: Array<Record<string, unknown>>) => void) => void>;
+        readonly default: undefined;
+    };
+    readonly seq: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly seqStartIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 1;
+    };
+    readonly spanMethod: {
+        readonly type: vue.PropType<(params: IrisTableSpanMethodParams) => IrisTableSpan | null>;
+        readonly default: undefined;
+    };
+    readonly columnDrag: {
+        readonly type: vue.PropType<IrisTableColumnDrag>;
+        readonly default: undefined;
+    };
+    readonly rowDrag: {
+        readonly type: vue.PropType<IrisTableRowDrag>;
+        readonly default: undefined;
+    };
+    readonly onDataChange: {
+        readonly type: vue.PropType<(rows: Array<Record<string, unknown>>) => void>;
+        readonly default: undefined;
+    };
+    readonly selectable: {
+        type: vue.PropType<"none" | "single" | "multi">;
         default: string;
     };
-    selection: {
-        type: PropType<Array<string | number>>;
+    readonly selection: {
+        type: vue.PropType<Array<string | number>>;
         default: undefined;
     };
-    defaultSelection: {
-        type: PropType<Array<string | number>>;
+    readonly defaultSelection: {
+        type: vue.PropType<Array<string | number>>;
         default: undefined;
     };
-    sort: {
-        type: PropType<IrisTableSortState | null>;
+    readonly sort: {
+        type: vue.PropType<IrisTableSortState | null>;
         default: undefined;
     };
-    defaultSort: {
-        type: PropType<IrisTableSortState | null>;
+    readonly defaultSort: {
+        type: vue.PropType<IrisTableSortState | null>;
         default: undefined;
     };
-    columns: {
-        type: PropType<IrisTableColumn<Record<string, unknown>>[]>;
-        required: true;
+    readonly columns: {
+        readonly type: vue.PropType<IrisTableColumn<Record<string, unknown>>[]>;
+        readonly required: true;
     };
-    data: {
-        type: PropType<Array<Record<string, unknown>>>;
-        required: false;
-        default: undefined;
+    readonly data: {
+        readonly type: vue.PropType<Array<Record<string, unknown>>>;
+        readonly required: false;
+        readonly default: undefined;
     };
-    rowKey: {
-        type: StringConstructor;
-        default: string;
+    readonly rowKey: {
+        readonly type: StringConstructor;
+        readonly default: "id";
     };
 }>, () => VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+}> | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     'update:selection': (_value: Array<string | number>) => true;
     'update:sort': (_value: IrisTableSortState | null) => true;
+    'update:multiSortState': (_value: IrisTableSortState[]) => true;
+    multiSortChange: (_value: IrisTableSortState[]) => true;
     'update:columnWidths': (_value: IrisTableColumnWidths) => true;
+    /** Controlled columnVisibility channel (parent owns the map). */
+    'update:columnVisibility': (_value: IrisTableColumnVisibility) => true;
     rowClick: (_row: Record<string, unknown>, _index: number) => true;
     rowDblclick: (_row: Record<string, unknown>, _index: number) => true;
     cellEdit: (_payload: IrisTableCellEditEvent<Record<string, unknown>>) => true;
     expandedRowsChange: (_keys: Array<string | number>) => true;
 }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    striped: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly multiSort: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    editConfig: {
-        type: PropType<{
+    readonly multiSortState: {
+        readonly type: vue.PropType<IrisTableSortState[]>;
+        readonly default: undefined;
+    };
+    readonly defaultMultiSort: {
+        readonly type: vue.PropType<IrisTableSortState[]>;
+        readonly default: undefined;
+    };
+    readonly striped: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly editConfig: {
+        readonly type: vue.PropType<{
             trigger?: "click" | "dblclick" | "manual";
             showAsterisk?: boolean;
             autoClear?: boolean;
+            mode?: "cell" | "row";
         }>;
-        default: undefined;
+        readonly default: undefined;
     };
-    bordered: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly bordered: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
     };
-    /** Enable per-column resize handles. Combine with `v-model:columnWidths` for persistence. */
-    resizableColumns: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly density: {
+        readonly type: vue.PropType<IrisTableDensity>;
+        readonly default: "comfortable";
     };
-    /** Controlled column widths in px. */
-    columnWidths: {
-        type: PropType<IrisTableColumnWidths>;
-        default: undefined;
+    readonly densityToggle: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /** Enable virtual scrolling for the body. */
-    virtualScroll: {
-        type: PropType<IrisTableVirtualOptions>;
-        default: undefined;
+    readonly editPreview: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /** Show the loading state instead of rows. */
-    loading: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly pattern: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /** Show the error state instead of rows (takes precedence over loading). */
-    error: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly patternFill: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    onRetry: {
-        type: PropType<(() => void) | undefined>;
-        default: undefined;
+    readonly views: {
+        readonly type: vue.PropType<IrisTableViewConfig>;
+        readonly default: undefined;
     };
-    /** Render only the horizontally-visible columns (+ pinned + overscan) for wide tables. */
-    columnVirtualization: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly onActiveViewChange: {
+        readonly type: vue.PropType<(key: string | null) => void>;
+        readonly default: undefined;
     };
-    /**
-     * Enable WAI-ARIA grid keyboard navigation: the table becomes `role="grid"`
-     * and Arrow / Home / End / Page Up·Down move a roving cell focus across the
-     * data cells. Off by default; opt-in and additive (no effect on mouse / Tab
-     * behavior). Pairs best without virtualization (the focused cell must be
-     * rendered) and does not hijack keystrokes while a cell is being edited.
-     */
-    keyboardNavigation: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly tableTabs: {
+        readonly type: vue.PropType<IrisTableTab[]>;
+        readonly default: undefined;
     };
-    /**
-     * Enable rectangular cell-range selection (Excel-style). Click starts a
-     * range; Shift+Click or Shift+Arrow extends it; Escape clears it.
-     * Cells within the range get `data-iris-cell-selected="true"`.
-     */
-    cellRange: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly pinnedDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /**
-     * Render an expandable detail panel beneath a row. Providing this adds a
-     * leading expand-toggle column; clicking it reveals a full-width detail row.
-     * (Not applied in the virtual-scroll path.)
-     */
-    renderDetail: {
-        type: PropType<IrisTableRenderDetail<Record<string, unknown>>>;
-        default: undefined;
+    readonly onColumnPinnedChange: {
+        readonly type: vue.PropType<(key: string, side: "left" | "right" | null) => void>;
+        readonly default: undefined;
     };
-    /** Which rows can expand a detail panel. Defaults to all rows when `renderDetail` is set. */
-    rowExpandable: {
-        type: PropType<IrisTableRowExpandable<Record<string, unknown>>>;
-        default: undefined;
+    readonly onPinnedCountChange: {
+        readonly type: vue.PropType<(count: number) => void>;
+        readonly default: undefined;
     };
-    /** Initially-expanded row keys (uncontrolled). */
-    defaultExpandedRowKeys: {
-        type: PropType<Array<string | number>>;
-        default: undefined;
+    readonly autoDetectTypes: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /**
-     * Read a row's child rows to render the table as a TREE. Providing this
-     * enables tree mode: `data` is treated as the root rows, each row's first
-     * cell gains a depth indent + an expand/collapse toggle (when it has
-     * children), and the expand state reuses `defaultExpandedRowKeys` /
-     * `expandedRowsChange`. Column sort reorders siblings hierarchically (each
-     * level sorted, structure kept), and tree rows virtualize like flat rows
-     * when `virtualScroll` is set (unless `renderDetail` is also used, since
-     * detail panels are variable-height).
-     */
-    getSubRows: {
-        type: PropType<(row: Record<string, unknown>) => Array<Record<string, unknown>> | undefined>;
-        default: undefined;
+    readonly responsive: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    /**
-     * Cascade multi-row selection through the complete tree supplied by
-     * `getSubRows`. Selecting a branch selects every descendant (including
-     * collapsed rows); partially selected branches render indeterminate.
-     * Ignored outside tree mode and for non-multi selection.
-     */
-    treeSelectionCascade: {
-        type: BooleanConstructor;
-        default: boolean;
+    readonly exportNames: {
+        readonly type: vue.PropType<Array<{
+            key: string;
+            ref: () => Array<Record<string, unknown>>;
+        }>>;
+        readonly default: undefined;
+    };
+    readonly resizableColumns: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly columnWidths: {
+        readonly type: vue.PropType<IrisTableColumnWidths>;
+        readonly default: undefined;
+    };
+    readonly virtualScroll: {
+        readonly type: vue.PropType<IrisTableVirtualOptions>;
+        readonly default: undefined;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly error: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly printable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly importPreview: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onRetry: {
+        readonly type: vue.PropType<(() => void) | undefined>;
+        readonly default: undefined;
+    };
+    readonly columnVirtualization: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly keyboardNavigation: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly cellRange: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly clipConfig: {
+        readonly type: vue.PropType<IrisTableClipConfig>;
+        readonly default: undefined;
+    };
+    readonly renderDetail: {
+        readonly type: vue.PropType<IrisTableRenderDetail<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly rowExpandable: {
+        readonly type: vue.PropType<IrisTableRowExpandable<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly defaultExpandedRowKeys: {
+        readonly type: vue.PropType<Array<string | number>>;
+        readonly default: undefined;
+    };
+    readonly getSubRows: {
+        readonly type: vue.PropType<(row: Record<string, unknown>) => Array<Record<string, unknown>> | undefined>;
+        readonly default: undefined;
+    };
+    readonly treeSelectionCascade: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly proxyConfig: {
+        readonly type: vue.PropType<IrisTableProxyConfig<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly formConfig: {
+        readonly type: vue.PropType<IrisTableFormConfig>;
+        readonly default: undefined;
+    };
+    readonly toolbar: {
+        readonly type: vue.PropType<IrisTableToolbarConfig>;
+        readonly default: undefined;
+    };
+    readonly auditLog: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
     };
-    selectable: {
-        type: PropType<"none" | "single" | "multi">;
+    readonly columnVisibility: {
+        readonly type: vue.PropType<IrisTableColumnVisibility>;
+        readonly default: undefined;
+    };
+    readonly filters: {
+        readonly type: vue.PropType<Record<string, string>>;
+        readonly default: undefined;
+    };
+    readonly filterValues: {
+        readonly type: vue.PropType<IrisTableFilterValues>;
+        readonly default: undefined;
+    };
+    readonly onFilterValuesChange: {
+        readonly type: vue.PropType<(next: IrisTableFilterValues) => void>;
+        readonly default: undefined;
+    };
+    readonly contextMenu: {
+        readonly type: vue.PropType<IrisTableContextMenuConfig<Record<string, unknown>>>;
+        readonly default: undefined;
+    };
+    readonly lazyLoad: {
+        readonly type: vue.PropType<(row: Record<string, unknown>, load: (children: Array<Record<string, unknown>>) => void) => void>;
+        readonly default: undefined;
+    };
+    readonly seq: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly seqStartIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 1;
+    };
+    readonly spanMethod: {
+        readonly type: vue.PropType<(params: IrisTableSpanMethodParams) => IrisTableSpan | null>;
+        readonly default: undefined;
+    };
+    readonly columnDrag: {
+        readonly type: vue.PropType<IrisTableColumnDrag>;
+        readonly default: undefined;
+    };
+    readonly rowDrag: {
+        readonly type: vue.PropType<IrisTableRowDrag>;
+        readonly default: undefined;
+    };
+    readonly onDataChange: {
+        readonly type: vue.PropType<(rows: Array<Record<string, unknown>>) => void>;
+        readonly default: undefined;
+    };
+    readonly selectable: {
+        type: vue.PropType<"none" | "single" | "multi">;
         default: string;
     };
-    selection: {
-        type: PropType<Array<string | number>>;
+    readonly selection: {
+        type: vue.PropType<Array<string | number>>;
         default: undefined;
     };
-    defaultSelection: {
-        type: PropType<Array<string | number>>;
+    readonly defaultSelection: {
+        type: vue.PropType<Array<string | number>>;
         default: undefined;
     };
-    sort: {
-        type: PropType<IrisTableSortState | null>;
+    readonly sort: {
+        type: vue.PropType<IrisTableSortState | null>;
         default: undefined;
     };
-    defaultSort: {
-        type: PropType<IrisTableSortState | null>;
+    readonly defaultSort: {
+        type: vue.PropType<IrisTableSortState | null>;
         default: undefined;
     };
-    columns: {
-        type: PropType<IrisTableColumn<Record<string, unknown>>[]>;
-        required: true;
+    readonly columns: {
+        readonly type: vue.PropType<IrisTableColumn<Record<string, unknown>>[]>;
+        readonly required: true;
     };
-    data: {
-        type: PropType<Array<Record<string, unknown>>>;
-        required: false;
-        default: undefined;
+    readonly data: {
+        readonly type: vue.PropType<Array<Record<string, unknown>>>;
+        readonly required: false;
+        readonly default: undefined;
     };
-    rowKey: {
-        type: StringConstructor;
-        default: string;
+    readonly rowKey: {
+        readonly type: StringConstructor;
+        readonly default: "id";
     };
 }>> & Readonly<{
     "onUpdate:selection"?: ((_value: (string | number)[]) => any) | undefined;
-    onExpandedRowsChange?: ((_keys: (string | number)[]) => any) | undefined;
     "onUpdate:sort"?: ((_value: IrisTableSortState | null) => any) | undefined;
-    onCellEdit?: ((_payload: IrisTableCellEditEvent<Record<string, unknown>>) => any) | undefined;
+    "onUpdate:multiSortState"?: ((_value: IrisTableSortState[]) => any) | undefined;
+    onMultiSortChange?: ((_value: IrisTableSortState[]) => any) | undefined;
     "onUpdate:columnWidths"?: ((_value: IrisTableColumnWidths) => any) | undefined;
+    "onUpdate:columnVisibility"?: ((_value: IrisTableColumnVisibility) => any) | undefined;
     onRowClick?: ((_row: Record<string, unknown>, _index: number) => any) | undefined;
     onRowDblclick?: ((_row: Record<string, unknown>, _index: number) => any) | undefined;
+    onCellEdit?: ((_payload: IrisTableCellEditEvent<Record<string, unknown>>) => any) | undefined;
+    onExpandedRowsChange?: ((_keys: (string | number)[]) => any) | undefined;
 }>, {
-    sort: IrisTableSortState | null;
-    data: Record<string, unknown>[];
-    error: boolean;
-    loading: boolean;
-    rowKey: string;
-    striped: boolean;
-    editConfig: {
+    readonly sort: IrisTableSortState | null;
+    readonly data: Record<string, unknown>[];
+    readonly pattern: boolean;
+    readonly error: boolean;
+    readonly loading: boolean;
+    readonly filters: Record<string, string>;
+    readonly toolbar: IrisTableToolbarConfig;
+    readonly density: IrisTableDensity;
+    readonly formConfig: IrisTableFormConfig;
+    readonly selectable: "none" | "single" | "multi";
+    readonly proxyConfig: IrisTableProxyConfig<Record<string, unknown>>;
+    readonly rowKey: string;
+    readonly seq: boolean;
+    readonly multiSort: boolean;
+    readonly multiSortState: IrisTableSortState[];
+    readonly defaultMultiSort: IrisTableSortState[];
+    readonly striped: boolean;
+    readonly editConfig: {
         trigger?: "click" | "dblclick" | "manual";
         showAsterisk?: boolean;
         autoClear?: boolean;
-    };
-    bordered: boolean;
-    resizableColumns: boolean;
-    columnWidths: IrisTableColumnWidths;
-    virtualScroll: IrisTableVirtualOptions;
-    onRetry: (() => void) | undefined;
-    columnVirtualization: boolean;
-    keyboardNavigation: boolean;
-    cellRange: boolean;
-    renderDetail: IrisTableRenderDetail<Record<string, unknown>>;
-    rowExpandable: IrisTableRowExpandable<Record<string, unknown>>;
-    defaultExpandedRowKeys: (string | number)[];
-    getSubRows: (row: Record<string, unknown>) => Array<Record<string, unknown>> | undefined;
-    treeSelectionCascade: boolean;
-    selectable: "none" | "single" | "multi";
-    selection: (string | number)[];
-    defaultSelection: (string | number)[];
-    defaultSort: IrisTableSortState | null;
+        mode?: "cell" | "row";
+    };
+    readonly bordered: boolean;
+    readonly densityToggle: boolean;
+    readonly editPreview: boolean;
+    readonly patternFill: boolean;
+    readonly views: _iris_ui_kit_core.TableViewConfig;
+    readonly onActiveViewChange: (key: string | null) => void;
+    readonly tableTabs: _iris_ui_kit_core.TableTab[];
+    readonly pinnedDrag: boolean;
+    readonly onColumnPinnedChange: (key: string, side: "left" | "right" | null) => void;
+    readonly onPinnedCountChange: (count: number) => void;
+    readonly autoDetectTypes: boolean;
+    readonly responsive: boolean;
+    readonly exportNames: {
+        key: string;
+        ref: () => Array<Record<string, unknown>>;
+    }[];
+    readonly resizableColumns: boolean;
+    readonly columnWidths: IrisTableColumnWidths;
+    readonly virtualScroll: IrisTableVirtualOptions;
+    readonly printable: boolean;
+    readonly importPreview: boolean;
+    readonly onRetry: (() => void) | undefined;
+    readonly columnVirtualization: boolean;
+    readonly keyboardNavigation: boolean;
+    readonly cellRange: boolean;
+    readonly clipConfig: IrisTableClipConfig;
+    readonly renderDetail: IrisTableRenderDetail<Record<string, unknown>>;
+    readonly rowExpandable: IrisTableRowExpandable<Record<string, unknown>>;
+    readonly defaultExpandedRowKeys: (string | number)[];
+    readonly getSubRows: (row: Record<string, unknown>) => Array<Record<string, unknown>> | undefined;
+    readonly treeSelectionCascade: boolean;
+    readonly auditLog: boolean;
+    readonly columnVisibility: IrisTableColumnVisibility;
+    readonly filterValues: IrisTableFilterValues;
+    readonly onFilterValuesChange: (next: IrisTableFilterValues) => void;
+    readonly contextMenu: IrisTableContextMenuConfig<Record<string, unknown>>;
+    readonly lazyLoad: (row: Record<string, unknown>, load: (children: Array<Record<string, unknown>>) => void) => void;
+    readonly seqStartIndex: number;
+    readonly spanMethod: (params: IrisTableSpanMethodParams) => IrisTableSpan | null;
+    readonly columnDrag: IrisTableColumnDrag<Record<string, unknown>>;
+    readonly rowDrag: IrisTableRowDrag<Record<string, unknown>>;
+    readonly onDataChange: (rows: Array<Record<string, unknown>>) => void;
+    readonly selection: (string | number)[];
+    readonly defaultSelection: (string | number)[];
+    readonly defaultSort: IrisTableSortState | null;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 /** Public input/event surface inferred from the runtime Vue component. */
 type IrisTableProps = InstanceType<typeof IrisTable>['$props'];
@@ -4696,6 +5160,7 @@ type IrisTableProps = InstanceType<typeof IrisTable>['$props'];
  * characters, prepend the U+FEFF BOM before writing — `downloadCsv` does this.
  */
 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;
@@ -5824,8 +6289,8 @@ declare const IrisDescriptions: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{}>, {
     items: IrisDescriptionsItem[];
     layout: IrisDescriptionsLayout;
-    columns: number;
     bordered: boolean;
+    columns: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 interface IrisTransferItem {
@@ -8387,4 +8852,4 @@ declare const IrisDateRangePicker: vue.DefineComponent<vue.ExtractPropTypes<{
     weekStartsOn: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-export { type AccordionContext, AccordionContextKey, type DialogContext, DialogContextKey, type DragState, type DrawerContext, DrawerContextKey, type DropdownContext, DropdownContextKey, IrisAccordion, IrisAccordionItem, type IrisAccordionValue, IrisAffix, IrisAlert, type IrisAlertTone, IrisAnchor, type IrisAnchorItem, IrisAspectRatio, IrisAvatar, type IrisAvatarShape, type IrisAvatarSize, IrisBackTop, IrisBadge, type IrisBadgeSize, type IrisBadgeTone, type IrisBadgeVariant, IrisBanner, type IrisBannerTone, IrisBreadcrumb, IrisBreadcrumbItem, IrisButton, type IrisButtonProps, type IrisButtonSize, type IrisButtonType, type IrisButtonVariant, IrisCalendar, IrisCard, type IrisCardPadding, type IrisCardVariant, IrisCarousel, IrisCascader, type IrisCascaderNode, type IrisCascaderSize, IrisCheckbox, type IrisCheckboxSize, type IrisCheckboxValue, IrisChip, type IrisChipSize, type IrisChipTone, type IrisChipVariant, IrisColorPicker, IrisCombobox, type IrisComboboxOption, type IrisComboboxSize, type IrisCommandItem, IrisCommandPalette, IrisCopyButton, type IrisCopyButtonSize, IrisCountdown, type IrisCountdownSize, IrisDatePicker, type IrisDateRange, IrisDateRangePicker, IrisDescriptions, type IrisDescriptionsItem, type IrisDescriptionsLayout, IrisDialog, IrisDialogClose, IrisDialogContent, IrisDialogDescription, IrisDialogTitle, IrisDialogTrigger, IrisDivider, type IrisDividerOrientation, type IrisDividerSpacing, IrisDragger, type IrisDraggerPosition, IrisDrawer, IrisDrawerClose, IrisDrawerContent, type IrisDrawerSide, IrisDrawerTitle, IrisDrawerTrigger, IrisDropdown, IrisDropdownItem, IrisDropdownMenu, IrisDropdownSeparator, IrisDropdownTrigger, IrisEmptyState, IrisFieldset, IrisFileUpload, type IrisFileUploadFile, IrisFloatButton, type IrisFloatButtonAction, type IrisFloatButtonShape, IrisFormField, IrisGauge, type IrisGaugeStatus, IrisIcon, IrisImage, IrisInput, type IrisInputSize, type IrisInputType, IrisKbd, type IrisKbdSize, IrisList, type IrisListItem, IrisMarquee, type IrisMarqueeDirection, IrisMasonry, type IrisMentionOption, IrisMentions, IrisMenu, IrisMenuContent, IrisMenuItem, IrisMenuSeparator, IrisMenuSub, IrisMenuTrigger, IrisNumberInput, type IrisNumberInputSize, IrisOtpInput, type IrisOtpInputSize, type IrisOtpInputType, IrisPagination, type IrisPaginationSize, IrisPasswordInput, type IrisPasswordInputSize, IrisPopover, IrisPopoverContent, IrisPopoverTrigger, IrisProgress, IrisProgressCircle, type IrisProgressCircleStatus, type IrisProgressSize, type IrisProgressTone, IrisRadio, IrisRadioGroup, type IrisRadioSize, IrisRangeSlider, type IrisRangeSliderValue, IrisRating, type IrisRatingSize, IrisResizer, type IrisResizerHandle, type IrisResizerSize, IrisResult, type IrisResultStatus, IrisRibbon, type IrisRibbonPlacement, IrisScrollArea, type IrisScrollAreaAxis, IrisSegmented, type IrisSegmentedOption, type IrisSegmentedSize, IrisSelect, type IrisListItem as IrisSelectItem, type IrisSelectProps, type IrisSelectSize, IrisSkeleton, type IrisSkeletonShape, IrisSlider, type IrisSliderOrientation, IrisSlot, IrisSpinner, type IrisSpinnerSize, IrisSplitButton, type IrisSplitButtonAction, type IrisSplitButtonSize, type IrisSplitButtonVariant, IrisSplitter, type IrisSplitterOrientation, IrisStatistic, type IrisStatisticSize, type IrisStatisticTrend, type IrisStepStatus, IrisStepper, type IrisStepperOrientation, IrisStepperStep, IrisSwitch, type IrisSwitchSize, IrisTable, type IrisTableAggregateOp, type IrisTableCellEditEvent, type IrisTableColumn, type IrisTableColumnWidths, type IrisTableEditor, type IrisTableProps, type IrisTableRenderDetail, type IrisTableRowExpandable, type IrisTableSortDirection, type IrisTableSortState, type IrisTableVirtualOptions, IrisTabs, IrisTabsContent, IrisTabsList, type IrisTabsOrientation, IrisTabsTrigger, IrisTagInput, IrisTextarea, type IrisTextareaSize, IrisTimePicker, type IrisTimePickerFormat, type IrisTimeValue, IrisTimeline, type IrisTimelineItem, type IrisTimelineVariant, type IrisToast, type IrisToastInput, type IrisToastPosition, type IrisToastVariant, IrisToastViewport, IrisToggleGroup, IrisToggleGroupItem, type IrisToggleGroupOrientation, type IrisToggleGroupType, type IrisToggleGroupVariant, IrisToolbar, type IrisToolbarOrientation, IrisTooltip, IrisTour, type IrisTourStep, IrisTransfer, type IrisTransferItem, type IrisTransferVirtualOptions, IrisTree, type IrisTreeNode, IrisTreeSelect, type IrisTreeSelectNode, type IrisTreeSelectSize, type IrisTreeSelectionMode, IrisVirtualScroll, type IrisVirtualScrollAlign, type IrisVirtualScrollExposed, IrisVisuallyHidden, IrisWatermark, type MenuContext, MenuContextKey, type PopoverContext, PopoverContextKey, type StepperContext, StepperContextKey, type TabsContext, TabsContextKey, type ToggleGroupContext, ToggleGroupContextKey, type UseDragOptions, type UseToastReturn, __PROGRESS_STYLE_ID, __SKELETON_STYLE_ID, __SPINNER_STYLE_ID, __resetProgressStyles, __resetSkeletonStyles, __resetSpinnerStyles, clearToasts, composeRefs, defaultFilter, dismissToast, downloadCsv, downloadExcel, exportCsv, exportExcel, findFirstElement, formatBytes, formatRemaining, getToasts, mergeSlotProps, pushToast, subscribeToasts, useDisposableScope, useDrag, useReconnectingSource, useResilientFetcher, useStore, useStoreSelector, useToast };
+export { type AccordionContext, AccordionContextKey, type DialogContext, DialogContextKey, type DragState, type DrawerContext, DrawerContextKey, type DropdownContext, DropdownContextKey, IrisAccordion, IrisAccordionItem, type IrisAccordionValue, IrisAffix, IrisAlert, type IrisAlertTone, IrisAnchor, type IrisAnchorItem, IrisAspectRatio, IrisAvatar, type IrisAvatarShape, type IrisAvatarSize, IrisBackTop, IrisBadge, type IrisBadgeSize, type IrisBadgeTone, type IrisBadgeVariant, IrisBanner, type IrisBannerTone, IrisBreadcrumb, IrisBreadcrumbItem, IrisButton, type IrisButtonProps, type IrisButtonSize, type IrisButtonType, type IrisButtonVariant, IrisCalendar, IrisCard, type IrisCardPadding, type IrisCardVariant, IrisCarousel, IrisCascader, type IrisCascaderNode, type IrisCascaderSize, IrisCheckbox, type IrisCheckboxSize, type IrisCheckboxValue, IrisChip, type IrisChipSize, type IrisChipTone, type IrisChipVariant, IrisColorPicker, IrisCombobox, type IrisComboboxOption, type IrisComboboxSize, type IrisCommandItem, IrisCommandPalette, IrisCopyButton, type IrisCopyButtonSize, IrisCountdown, type IrisCountdownSize, IrisDatePicker, type IrisDateRange, IrisDateRangePicker, IrisDescriptions, type IrisDescriptionsItem, type IrisDescriptionsLayout, IrisDialog, IrisDialogClose, IrisDialogContent, IrisDialogDescription, IrisDialogTitle, IrisDialogTrigger, IrisDivider, type IrisDividerOrientation, type IrisDividerSpacing, IrisDragger, type IrisDraggerPosition, IrisDrawer, IrisDrawerClose, IrisDrawerContent, type IrisDrawerSide, IrisDrawerTitle, IrisDrawerTrigger, IrisDropdown, IrisDropdownItem, IrisDropdownMenu, IrisDropdownSeparator, IrisDropdownTrigger, IrisEmptyState, IrisFieldset, IrisFileUpload, type IrisFileUploadFile, IrisFloatButton, type IrisFloatButtonAction, type IrisFloatButtonShape, IrisFormField, IrisGauge, type IrisGaugeStatus, IrisIcon, IrisImage, IrisInput, type IrisInputSize, type IrisInputType, IrisKbd, type IrisKbdSize, IrisList, type IrisListItem, IrisMarquee, type IrisMarqueeDirection, IrisMasonry, type IrisMentionOption, IrisMentions, IrisMenu, IrisMenuContent, IrisMenuItem, IrisMenuSeparator, IrisMenuSub, IrisMenuTrigger, IrisNumberInput, type IrisNumberInputSize, IrisOtpInput, type IrisOtpInputSize, type IrisOtpInputType, IrisPagination, type IrisPaginationSize, IrisPasswordInput, type IrisPasswordInputSize, IrisPopover, IrisPopoverContent, IrisPopoverTrigger, IrisProgress, IrisProgressCircle, type IrisProgressCircleStatus, type IrisProgressSize, type IrisProgressTone, IrisRadio, IrisRadioGroup, type IrisRadioSize, IrisRangeSlider, type IrisRangeSliderValue, IrisRating, type IrisRatingSize, IrisResizer, type IrisResizerHandle, type IrisResizerSize, IrisResult, type IrisResultStatus, IrisRibbon, type IrisRibbonPlacement, IrisScrollArea, type IrisScrollAreaAxis, IrisSegmented, type IrisSegmentedOption, type IrisSegmentedSize, IrisSelect, type IrisListItem as IrisSelectItem, type IrisSelectProps, type IrisSelectSize, IrisSkeleton, type IrisSkeletonShape, IrisSlider, type IrisSliderOrientation, IrisSlot, IrisSpinner, type IrisSpinnerSize, IrisSplitButton, type IrisSplitButtonAction, type IrisSplitButtonSize, type IrisSplitButtonVariant, IrisSplitter, type IrisSplitterOrientation, IrisStatistic, type IrisStatisticSize, type IrisStatisticTrend, type IrisStepStatus, IrisStepper, type IrisStepperOrientation, IrisStepperStep, IrisSwitch, type IrisSwitchSize, IrisTable, type IrisTableAggregateOp, type IrisTableCellEditEvent, type IrisTableClipConfig, type IrisTableColumn, type IrisTableColumnDrag, type IrisTableColumnVisibility, type IrisTableColumnWidths, type IrisTableContextMenuConfig, type IrisTableContextMenuParams, type IrisTableEditor, type IrisTableExpose, type IrisTableFilterOption, type IrisTableFilterValues, type IrisTableFormConfig, type IrisTableFormField, type IrisTableNamedView, type IrisTableProps, type IrisTableProxyConfig, type IrisTableProxyInfo, type IrisTableProxyQueryParams, type IrisTableRenderDetail, type IrisTableRowDrag, type IrisTableRowExpandable, type IrisTableSortDirection, type IrisTableSortState, type IrisTableSpan, type IrisTableSpanMethodParams, type IrisTableTab, type IrisTableToolbarBatch, type IrisTableToolbarButton, type IrisTableToolbarConfig, type IrisTableViewConfig, type IrisTableViewSnapshot, type IrisTableVirtualOptions, IrisTabs, IrisTabsContent, IrisTabsList, type IrisTabsOrientation, IrisTabsTrigger, IrisTagInput, IrisTextarea, type IrisTextareaSize, IrisTimePicker, type IrisTimePickerFormat, type IrisTimeValue, IrisTimeline, type IrisTimelineItem, type IrisTimelineVariant, type IrisToast, type IrisToastInput, type IrisToastPosition, type IrisToastVariant, IrisToastViewport, IrisToggleGroup, IrisToggleGroupItem, type IrisToggleGroupOrientation, type IrisToggleGroupType, type IrisToggleGroupVariant, IrisToolbar, type IrisToolbarOrientation, IrisTooltip, IrisTour, type IrisTourStep, IrisTransfer, type IrisTransferItem, type IrisTransferVirtualOptions, IrisTree, type IrisTreeNode, IrisTreeSelect, type IrisTreeSelectNode, type IrisTreeSelectSize, type IrisTreeSelectionMode, IrisVirtualScroll, type IrisVirtualScrollAlign, type IrisVirtualScrollExposed, IrisVisuallyHidden, IrisWatermark, type MenuContext, MenuContextKey, type PopoverContext, PopoverContextKey, type StepperContext, StepperContextKey, type TabsContext, TabsContextKey, type ToggleGroupContext, ToggleGroupContextKey, type UseDragOptions, type UseToastReturn, __PROGRESS_STYLE_ID, __SKELETON_STYLE_ID, __SPINNER_STYLE_ID, __resetProgressStyles, __resetSkeletonStyles, __resetSpinnerStyles, clearToasts, composeRefs, defaultFilter, dismissToast, downloadCsv, downloadExcel, exportCsv, exportExcel, findFirstElement, formatBytes, formatRemaining, getToasts, mergeSlotProps, pushToast, subscribeToasts, useDisposableScope, useDrag, useReconnectingSource, useResilientFetcher, useStore, useStoreSelector, useToast };