@nu-grid/nuxt 0.1.1

package/dist/runtime/types/_internal/composable-returns.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Return type interfaces for internal composables.
+ * These explicit types solve TS4058 errors where TypeScript cannot name
+ * 'GroupColumnDefBase' from @tanstack/table-core in generated declarations.
+ *
+ * By using these explicit return types, TypeScript emits our type names
+ * instead of expanding TableColumn and encountering the unexported type.
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+import type { ComputedRef } from 'vue';
+import type { NuGridActionMenuOptions, NuGridColumn, NuGridRowSelectOptions } from '../index.js';
+/**
+ * Return type for useNuGridActionMenu composable
+ * @internal
+ */
+export interface UseNuGridActionMenuReturn<T extends TableData> {
+    isEnabled: ComputedRef<boolean>;
+    hasActionMenuColumn: ComputedRef<boolean>;
+    actionMenuColumn: NuGridColumn<T> | null;
+    appendActionMenuColumn: (columns: NuGridColumn<T>[]) => NuGridColumn<T>[];
+    isHidden: ComputedRef<boolean>;
+    isInteractive: ComputedRef<boolean>;
+    parsedOptions: ComputedRef<NuGridActionMenuOptions<T> | null>;
+}
+/**
+ * Return type for useNuGridRowSelection composable
+ * @internal
+ */
+export interface UseNuGridRowSelectionReturn<T extends TableData> {
+    isEnabled: ComputedRef<boolean>;
+    hasSelectionColumn: ComputedRef<boolean>;
+    normalizedMode: ComputedRef<'single' | 'multi' | null>;
+    enableMultiRowSelection: ComputedRef<boolean>;
+    enableRowSelection: ComputedRef<boolean | ((row: Row<T>) => boolean)>;
+    selectionColumn: NuGridColumn<T> | null;
+    prependSelectionColumn: (columns: NuGridColumn<T>[]) => NuGridColumn<T>[];
+    isHidden: ComputedRef<boolean>;
+    isInteractive: ComputedRef<boolean>;
+    rowSelectionEnabled: ComputedRef<((row: Row<T>) => boolean) | undefined>;
+    parsedOptions: ComputedRef<NuGridRowSelectOptions<T> | null>;
+}
+/**
+ * Return type for useNuGridColumns composable
+ * @internal
+ */
+export interface UseNuGridColumnsReturn<T extends TableData> {
+    columns: ComputedRef<NuGridColumn<T>[]>;
+    rowSelection: UseNuGridRowSelectionReturn<T> | null;
+    actionMenu: UseNuGridActionMenuReturn<T> | null;
+}

package/dist/runtime/types/_internal/config.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @internal
+ */
+import type { ComponentConfig } from '@nuxt/ui';
+import type { AppConfig } from 'nuxt/schema';
+import type { nuGridTheme } from '../../themes/index.js';
+/**
+ * NuGrid component configuration type
+ * @internal
+ */
+export type NuGridConfig = ComponentConfig<typeof nuGridTheme, AppConfig, 'table'>;
+/**
+ * UI slots type - re-exported from useNuGridUI for convenience
+ * @internal
+ */
+export type { NuGridUISlots } from '../../composables/_internal/useNuGridUI.js';

package/dist/runtime/types/_internal/contexts/add-row.d.ts

@@ -0,0 +1,25 @@
+import type { TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+import type { ComputedRef, Ref, VNode } from 'vue';
+export type NuGridAddRowPosition = 'none' | 'top' | 'bottom';
+export type NuGridAddRowState = 'idle' | 'focused' | 'editing';
+export interface NuGridAddRowFinalizeResult {
+    success: boolean;
+    messages?: string[];
+}
+export type NuGridAddRowIndicatorSlot<T extends TableData = TableData> = (props: {
+    row: Row<T>;
+    text: string;
+}) => VNode[];
+export interface NuGridAddRowContext<T extends TableData = TableData> {
+    showAddNewRow: ComputedRef<boolean>;
+    addRowPosition: ComputedRef<NuGridAddRowPosition>;
+    addRowState: ComputedRef<NuGridAddRowState>;
+    addNewText: ComputedRef<string>;
+    indicatorSlot?: NuGridAddRowIndicatorSlot<T>;
+    isAddRowRow: (row: Row<T>) => boolean;
+    finalizeAddRow: (row: Row<T>) => NuGridAddRowFinalizeResult;
+    resetAddRow: (row: Row<T>) => void;
+    isFinalizing?: Ref<boolean>;
+    finalizingRowId?: Ref<string | null>;
+}

package/dist/runtime/types/_internal/contexts/animation.d.ts

@@ -0,0 +1,24 @@
+import type { ComputedRef } from 'vue';
+/**
+ * Animation context
+ * Provides animation configuration to child components
+ */
+export interface NuGridAnimationContext {
+    /**
+     * Whether row animations are enabled
+     */
+    enabled: ComputedRef<boolean>;
+    /**
+     * Animation duration in milliseconds
+     */
+    duration: ComputedRef<number>;
+    /**
+     * CSS easing function
+     */
+    easing: ComputedRef<string>;
+    /**
+     * Trigger a row reorder animation
+     * Called automatically when row order changes, but can be called manually
+     */
+    animateReorder: () => Promise<void>;
+}

package/dist/runtime/types/_internal/contexts/core.d.ts

@@ -0,0 +1,24 @@
+import type { TableData } from '@nuxt/ui';
+import type { Cell, Row, Table } from '@tanstack/vue-table';
+import type { Primitive } from 'reka-ui';
+import type { ComputedRef, Ref } from 'vue';
+import type { NuGridUISlots } from '../../../composables/_internal/useNuGridUI.js';
+import type { NuGridConfig } from '../../config.js';
+/**
+ * Core context - essential table API and UI
+ * Always needed by all components
+ */
+export interface NuGridCoreContext<T extends TableData = TableData> {
+    tableRef: Ref<HTMLDivElement | null>;
+    rootRef: Ref<InstanceType<typeof Primitive> | null | undefined>;
+    tableApi: Table<T>;
+    ui: ComputedRef<NuGridUISlots>;
+    propsUi: ComputedRef<NuGridConfig['slots'] | undefined>;
+    hasFooter: ComputedRef<boolean>;
+    rows: ComputedRef<Row<T>[]>;
+    /** Custom row slot for replacing default cell rendering */
+    rowSlot?: (props: {
+        row: Row<T>;
+        cells: Cell<T, unknown>[];
+    }) => any;
+}

package/dist/runtime/types/_internal/contexts/drag.d.ts

@@ -0,0 +1,13 @@
+import type { TableData } from '@nuxt/ui';
+import type { ComputedRef } from 'vue';
+import type { RowDragOptions } from '../../../composables/_internal/useNuGridRowDragDrop.js';
+import type { NuGridColumnDragDrop, NuGridRowDragDrop } from '../../drag-drop.js';
+/**
+ * Drag & Drop context
+ * Column and row drag operations
+ */
+export interface NuGridDragContext<T extends TableData = TableData> {
+    dragFns: NuGridColumnDragDrop<T>;
+    rowDragFns: NuGridRowDragDrop<T>;
+    rowDragOptions: ComputedRef<RowDragOptions>;
+}

package/dist/runtime/types/_internal/contexts/focus.d.ts

@@ -0,0 +1,11 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridCellEditing } from '../cell-editing.js';
+import type { NuGridFocus } from '../focus.js';
+/**
+ * Focus & Editing context
+ * Cell focus navigation and editing
+ */
+export interface NuGridFocusContext<T extends TableData = TableData> {
+    focusFns: NuGridFocus<T>;
+    cellEditingFns: NuGridCellEditing<T>;
+}

package/dist/runtime/types/_internal/contexts/grouping.d.ts

@@ -0,0 +1,9 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridGroupingFns } from '../grouping.js';
+/**
+ * Grouping context
+ * Row grouping functionality (optional)
+ */
+export interface NuGridGroupingContext<T extends TableData = TableData> {
+    groupingFns: NuGridGroupingFns<T> | null;
+}

package/dist/runtime/types/_internal/contexts/index.d.ts

@@ -0,0 +1,15 @@
+export type { NuGridAddRowContext, NuGridAddRowPosition, NuGridAddRowState } from './add-row.js';
+export type { NuGridAnimationContext } from './animation.js';
+export type { NuGridCoreContext } from './core.js';
+export type { NuGridDragContext } from './drag.js';
+export type { NuGridFocusContext } from './focus.js';
+export type { NuGridGroupingContext } from './grouping.js';
+export type { NuGridInteractionRouterContext } from './interaction-router.js';
+export type { NuGridMultiRowContext } from './multi-row.js';
+export type { NuGridPagingContext } from './paging.js';
+export type { NuGridPerformanceContext } from './performance.js';
+export type { NuGridResizeContext } from './resize.js';
+export type { NuGridRowInteractionsContext } from './row-interactions.js';
+export type { NuGridScrollStateContext } from './scroll-state.js';
+export type { NuGridUIConfigContext } from './ui-config.js';
+export type { NuGridVirtualizationContext } from './virtualization.js';

package/dist/runtime/types/_internal/contexts/interaction-router.d.ts

@@ -0,0 +1,5 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridInteractionRouter } from '../interaction-router.js';
+export interface NuGridInteractionRouterContext<T extends TableData = TableData> {
+    interactionRouter: NuGridInteractionRouter<T>;
+}

package/dist/runtime/types/_internal/contexts/multi-row.d.ts

@@ -0,0 +1,40 @@
+import type { Column } from '@tanstack/vue-table';
+import type { ComputedRef } from 'vue';
+/**
+ * Information about a row 0 column slot for aligned mode
+ */
+export interface Row0ColumnSlot {
+    /** Column ID */
+    id: string;
+    /** Column width */
+    width: number;
+    /** Column minimum width */
+    minWidth: number;
+    /** Whether this column is pinned */
+    pinned: 'left' | 'right' | false;
+    /** The column reference for pinning calculations */
+    column: Column<any, unknown>;
+}
+/**
+ * Multi-row context
+ * Provides multi-row configuration to child components
+ */
+export interface NuGridMultiRowContext {
+    /**
+     * Whether multi-row mode is enabled
+     */
+    enabled: ComputedRef<boolean>;
+    /**
+     * Number of visual rows per data item
+     */
+    rowCount: ComputedRef<number>;
+    /**
+     * Whether columns should align with row 0 columns
+     */
+    alignColumns: ComputedRef<boolean>;
+    /**
+     * Row 0 column slots for aligned mode
+     * Contains width and pinning info for each column in row 0
+     */
+    row0Columns: ComputedRef<Row0ColumnSlot[]>;
+}

package/dist/runtime/types/_internal/contexts/paging.d.ts

@@ -0,0 +1,39 @@
+import type { ComputedRef } from 'vue';
+/**
+ * Paging context
+ * Provides paging state and controls to child components
+ */
+export interface NuGridPagingContext {
+    /** Whether paging is enabled */
+    enabled: ComputedRef<boolean>;
+    /** Current page size (rows per page) */
+    pageSize: ComputedRef<number>;
+    /** Current page index (0-based) */
+    pageIndex: ComputedRef<number>;
+    /** Total number of rows (after filtering) */
+    totalRows: ComputedRef<number>;
+    /** Total number of pages */
+    totalPages: ComputedRef<number>;
+    /** Page size selector options */
+    pageSizeOptions: ComputedRef<number[]>;
+    /** Whether to show the built-in paging panel */
+    showPanel: ComputedRef<boolean>;
+    /** Whether auto page size is enabled */
+    autoPageSize: ComputedRef<boolean>;
+    /** Navigate to a specific page (0-based index) */
+    setPageIndex: (index: number) => void;
+    /** Set the page size */
+    setPageSize: (size: number) => void;
+    /** Navigate to the first page */
+    firstPage: () => void;
+    /** Navigate to the last page */
+    lastPage: () => void;
+    /** Navigate to the next page */
+    nextPage: () => void;
+    /** Navigate to the previous page */
+    previousPage: () => void;
+    /** Check if can go to next page */
+    canNextPage: ComputedRef<boolean>;
+    /** Check if can go to previous page */
+    canPreviousPage: ComputedRef<boolean>;
+}

package/dist/runtime/types/_internal/contexts/performance.d.ts

@@ -0,0 +1,15 @@
+import type { TableData } from '@nuxt/ui';
+import type { Cell, Column, HeaderGroup, Row } from '@tanstack/vue-table';
+import type { ComputedRef } from 'vue';
+/**
+ * Performance context
+ * Cached TanStack Table API results and helper functions
+ */
+export interface NuGridPerformanceContext<T extends TableData = TableData> {
+    headerGroups: ComputedRef<HeaderGroup<T>[]>;
+    headerGroupsLength: ComputedRef<number>;
+    footerGroups: ComputedRef<HeaderGroup<T>[]>;
+    allLeafColumns: ComputedRef<Column<T, unknown>[]>;
+    getVisibleCells: (row: Row<T>) => Cell<T, unknown>[];
+    shouldHaveBorder: (row: Row<T>, cellIndex: number, side: 'left' | 'right') => boolean;
+}

package/dist/runtime/types/_internal/contexts/resize.d.ts

@@ -0,0 +1,12 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridColumnResize } from '../../resize.js';
+/**
+ * Column Resize context
+ * Column and column group resizing
+ */
+export interface NuGridResizeContext<T extends TableData = TableData> {
+    handleResizeStart: NuGridColumnResize<T>['handleResizeStart'];
+    handleGroupResizeStart: NuGridColumnResize<T>['handleGroupResizeStart'];
+    resizingGroupId: NuGridColumnResize<T>['resizingGroupId'];
+    resizingColumnId: NuGridColumnResize<T>['resizingColumnId'];
+}

package/dist/runtime/types/_internal/contexts/row-interactions.d.ts

@@ -0,0 +1,12 @@
+import type { TableData } from '@nuxt/ui';
+import type { ComputedRef } from 'vue';
+import type { NuGridRowInteractions } from '../../row-interactions.js';
+import type { NuGridRowSelectOptions } from '../../row-selection.js';
+/**
+ * Row Interactions context
+ * Row selection and interaction handlers
+ */
+export interface NuGridRowInteractionsContext<T extends TableData = TableData> {
+    rowInteractions: NuGridRowInteractions<T>;
+    rowSelectionMode: ComputedRef<boolean | 'single' | 'multi' | NuGridRowSelectOptions | undefined>;
+}

package/dist/runtime/types/_internal/contexts/scroll-state.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef, Ref } from 'vue';
+/**
+ * Scroll state context - provides scroll position and settling information
+ * Used by LazyCell to defer rendering until scroll settles
+ */
+export interface NuGridScrollStateContext {
+    /** Whether the user is currently scrolling */
+    isScrolling: Ref<boolean>;
+    /** Whether scrolling has settled (stopped for a brief delay) */
+    isSettled: Ref<boolean>;
+    /** Current vertical scroll position */
+    scrollTop: Ref<number>;
+    /** Current horizontal scroll position */
+    scrollLeft: Ref<number>;
+    /** Viewport height of the container */
+    viewportHeight: ComputedRef<number>;
+    /** Total scrollable height */
+    scrollHeight: ComputedRef<number>;
+    /** Reference to the scroll container element */
+    containerRef: Ref<HTMLElement | null>;
+}

package/dist/runtime/types/_internal/contexts/ui-config.d.ts

@@ -0,0 +1,21 @@
+import type { TableData } from '@nuxt/ui';
+import type { ComputedRef } from 'vue';
+import type { NuGridUIReturn } from '../../../composables/_internal/useNuGridUI.js';
+import type { NuGridColumnMenuItemsCallback } from '../../column.js';
+import type { NuGridColumnMenuButton } from '../../option-groups.js';
+import type { NuGridScrollbars } from '../../props.js';
+import type { NuGridSortIcon } from '../../sort-icon.js';
+/**
+ * UI Configuration context
+ * Styling, scrollbars, column menu, and sort icons
+ */
+export interface NuGridUIConfigContext<T extends TableData = TableData> {
+    sortIcons: ComputedRef<NuGridSortIcon | undefined>;
+    scrollbarClass: ComputedRef<string>;
+    scrollbarThemeClass: ComputedRef<string>;
+    scrollbarAttr: ComputedRef<NuGridScrollbars>;
+    getColumnMenuItems?: ComputedRef<NuGridColumnMenuItemsCallback<T> | undefined>;
+    showColumnVisibility: ComputedRef<boolean>;
+    columnMenuButton: ComputedRef<NuGridColumnMenuButton | undefined>;
+    checkboxTheme: NuGridUIReturn['checkboxTheme'];
+}

package/dist/runtime/types/_internal/contexts/virtualization.d.ts

@@ -0,0 +1,16 @@
+import type { TableData } from '@nuxt/ui';
+import type { ComputedRef, Ref } from 'vue';
+import type { GroupVirtualRowItem, NuGridVirtualizer } from '../virtualization.js';
+/**
+ * Virtualization context
+ * Virtual scrolling and sticky positioning
+ */
+export interface NuGridVirtualizationContext<T extends TableData = TableData> {
+    virtualizer: Ref<NuGridVirtualizer> | null;
+    virtualizationEnabled: ComputedRef<boolean>;
+    virtualRowItems: ComputedRef<GroupVirtualRowItem<T>[]>;
+    measuredVirtualSizes: ComputedRef<Map<number, number> | null>;
+    getVirtualItemHeight: (index: number) => number;
+    stickyOffsets: ComputedRef<Map<number, number>>;
+    stickyEnabled: ComputedRef<boolean>;
+}

package/dist/runtime/types/_internal/drag-drop.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Header, Row } from '@tanstack/vue-table';
+import type { MaybeRef, Ref } from 'vue';
+/**
+ * Type for nugrid-dragfns injection
+ * Provides column drag and drop functionality
+ * @internal
+ */
+export interface NuGridColumnDragDrop<T extends TableData = TableData> {
+    draggedColumnId: MaybeRef<string | null>;
+    dropTargetColumnId: MaybeRef<string | null>;
+    dropPosition: MaybeRef<'left' | 'right'>;
+    isDraggingOutside: Ref<boolean>;
+    handleColumnDragStart: (e: DragEvent, columnId: string) => void;
+    handleColumnDragOver: (e: DragEvent, columnId: string) => void;
+    handleColumnDrop: (e: DragEvent, columnId: string) => void;
+    handleColumnDragEnd: () => void;
+    handleColumnDragLeave: (e: DragEvent) => void;
+    handleColumnDragEnter: () => void;
+    isHeaderDraggable: (header: Header<T, any>) => boolean;
+    headerDragHandleProps: (header: Header<T, any>) => Record<string, unknown>;
+    headerDragProps: (header: Header<T, any>) => Record<string, unknown>;
+}
+/**
+ * Type for nugrid-rowdragfns injection
+ * Provides row drag and drop functionality
+ * @internal
+ */
+export interface NuGridRowDragDrop<T extends TableData = TableData> {
+    draggedRowId: Ref<string | null>;
+    draggedRowData: Ref<T | null>;
+    dropTargetRowId: Ref<string | null>;
+    dropPosition: Ref<'before' | 'after'>;
+    dragSourceGridId: Ref<string | null>;
+    isDraggingOutside: Ref<boolean>;
+    handleRowDragStart: (e: DragEvent, row: Row<T>) => void;
+    handleRowDragOver: (e: DragEvent, row: Row<T>) => void;
+    handleRowDrop: (e: DragEvent, row: Row<T>) => void;
+    handleRowDragEnd: () => void;
+    handleRowDragLeave: (e: DragEvent) => void;
+    handleRowDragEnter: () => void;
+    isRowDraggable: (row: Row<T>) => boolean;
+    rowDragHandleProps: (row: Row<T>) => Record<string, unknown>;
+    rowDragProps: (row: Row<T>) => Record<string, unknown>;
+}

package/dist/runtime/types/_internal/focus.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+import type { Ref } from 'vue';
+/**
+ * Focused cell position
+ * @internal
+ */
+export interface NuGridFocusedCell {
+    rowIndex: number;
+    columnIndex: number;
+    groupId?: string;
+    suppressOutline?: boolean;
+}
+/**
+ * Type for nugrid-focusfns injection
+ * Provides cell and row focus management
+ * @internal
+ */
+export interface NuGridFocus<T extends TableData = TableData> {
+    focusedCell: Ref<NuGridFocusedCell | null>;
+    gridHasFocus: Ref<boolean>;
+    onCellClick: (e: Event, row: Row<T>, columnIndex: number) => void;
+    onCellKeyDown: (e: KeyboardEvent) => void;
+    onCellKeyUp: (e: KeyboardEvent) => void;
+    getRowTabIndex: (row: Row<T>) => number;
+    shouldRowHandleKeydown: (row: Row<T>) => boolean;
+    getCellTabIndex: (row: Row<T>, cellIndex: number) => number;
+    shouldCellHandleKeydown: (row: Row<T>, cellIndex: number) => boolean;
+    isActiveRow: (row: Row<T>) => boolean;
+    isFocusedRow: (row: Row<T>) => boolean;
+    isFocusedCell: (row: Row<T>, cellIndex: number) => boolean;
+    rowFocusProps: (row: Row<T>) => Record<string, unknown>;
+    cellFocusProps: (row: Row<T>, cellIndex: number) => Record<string, unknown>;
+    focusCell: (targetRow: Row<T>, newRowIndex: number, newColumnIndex: number) => void;
+    findFirstFocusableColumn: (row: Row<T>) => number;
+    /** Get a cell element by row ID and column index (uses internal cache for performance) */
+    getCellElement: (rowId: string, columnIndex: number) => HTMLElement | null;
+    /** Ensure footer rows are visible when scrolling to bottom of grid */
+    ensureFootersVisible: (scrollContainer: HTMLElement) => void;
+    /** Scroll to a cell and focus it, with proper scroll management */
+    scrollToCellAndFocus: (options: {
+        cellElement: HTMLElement;
+        rowId: string;
+        rowIndex: number;
+        columnIndex: number;
+        behavior?: 'instant' | 'smooth';
+        skipHorizontalScroll?: boolean;
+        onComplete?: () => void;
+    }) => void;
+    /** Update focused cell and emit focus events */
+    setFocusedCell: (newValue: NuGridFocusedCell | null, options?: {
+        suppressEvents?: boolean;
+    }) => void;
+    /**
+     * Focus a row by its ID, scrolling to make it visible
+     * @param rowId - The ID of the row to focus, or null to clear focus
+     * @param options - Optional settings for focus behavior
+     * @returns true if row was found and focused, false if row ID not found
+     */
+    focusRowById: (rowId: string | null, options?: {
+        columnIndex?: number;
+        /** Scroll alignment: 'nearest' just makes visible, 'top' scrolls row to top, 'center' centers the row */
+        align?: 'nearest' | 'top' | 'center';
+    }) => boolean;
+}

package/dist/runtime/types/_internal/grouping.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+import type { ComputedRef, Ref } from 'vue';
+import type { GroupingVirtualRowHeights, GroupVirtualRowItem, NuGridVirtualizer } from './virtualization.js';
+/**
+ * Type for grouping functions returned by useNuGridGrouping
+ * Provides group management and virtualization for grouped tables
+ * @internal
+ */
+export interface NuGridGroupingFns<T extends TableData = TableData> {
+    /** All rows from the table (grouped or ungrouped) */
+    rows: ComputedRef<Row<T>[]>;
+    /** Group header rows only */
+    groupRows: ComputedRef<Row<T>[]>;
+    /** Rows organized by group ID */
+    groupedRows: ComputedRef<Record<string, Row<T>[]>>;
+    /** Group expansion state */
+    groupExpanded: Ref<Record<string, boolean>>;
+    /** Toggle a group's expanded state */
+    toggleGroup: (groupId: string) => void;
+    /** Check if a group is expanded */
+    isGroupExpanded: (groupId: string) => boolean;
+    /** Virtual row items for virtualization */
+    virtualRowItems: ComputedRef<GroupVirtualRowItem<T>[]>;
+    /** Virtualizer instance */
+    virtualizer: Ref<NuGridVirtualizer> | null;
+    /** Whether virtualization is enabled */
+    virtualizationEnabled: ComputedRef<boolean>;
+    /** Flattened list of navigable rows for keyboard navigation */
+    navigableRows: ComputedRef<Row<T>[]>;
+    /** Row heights configuration for grouping */
+    groupingRowHeights: ComputedRef<Required<GroupingVirtualRowHeights>>;
+    /** Number of header groups */
+    headerGroupCount: ComputedRef<number>;
+    /** Active sticky row indexes */
+    activeStickyIndexes: Ref<number[]>;
+    /** Total height of active sticky elements */
+    activeStickyHeight: ComputedRef<number>;
+    /** Measured virtual item sizes for dynamic heights */
+    measuredVirtualSizes: ComputedRef<Map<number, number> | null>;
+    /** Get height for a virtual item (measured or fallback) */
+    getVirtualItemHeight: (index: number) => number;
+    /** Cumulative top offsets for sticky headers */
+    stickyOffsets: ComputedRef<Map<number, number>>;
+}