@siyahi/ui 0.0.0-stage → 0.1.0-next.3

package/dist/components/registry/niko-table/components/data-table-column-sort.js

@@ -0,0 +1,36 @@
+import { useColumnHeaderContext } from "./data-table-column-header.js";
+import { useDataTable } from "../core/data-table-context.js";
+import { TableColumnSortMenu, TableColumnSortOptions } from "../filters/table-column-sort.js";
+import "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/registry/niko-table/components/data-table-column-sort.tsx
+/**
+* Sorting options for column header menu using context.
+*/
+function DataTableColumnSortOptions(props) {
+	const { column } = useColumnHeaderContext(true);
+	const { table } = useDataTable();
+	return /* @__PURE__ */ jsx(TableColumnSortOptions, {
+		column,
+		table,
+		...props
+	});
+}
+DataTableColumnSortOptions.displayName = "DataTableColumnSortOptions";
+/**
+* Sorting menu for column header using context.
+*
+* Standalone button variant for inline use outside dropdown menus.
+*/
+function DataTableColumnSortMenu(props) {
+	const { column } = useColumnHeaderContext(true);
+	const { table } = useDataTable();
+	return /* @__PURE__ */ jsx(TableColumnSortMenu, {
+		column,
+		table,
+		...props
+	});
+}
+DataTableColumnSortMenu.displayName = "DataTableColumnSortMenu";
+//#endregion
+export { DataTableColumnSortMenu, DataTableColumnSortOptions };

package/dist/components/registry/niko-table/components/data-table-column-title.d.ts

@@ -0,0 +1,12 @@
+import { TableColumnTitle } from "../filters/table-column-title.js";
+import React from "react";
+import { RowData } from "@tanstack/react-table";
+//#region src/components/registry/niko-table/components/data-table-column-title.d.ts
+/**
+ * Renders the column title using context.
+ */
+export declare function DataTableColumnTitle<TData extends RowData, TValue>(props: Omit<React.ComponentProps<typeof TableColumnTitle>, "column">): React.JSX.Element;
+export declare namespace DataTableColumnTitle {
+  var displayName: string;
+}
+//#endregion

package/dist/components/registry/niko-table/components/data-table-column-title.js

@@ -0,0 +1,18 @@
+import { useColumnHeaderContext } from "./data-table-column-header.js";
+import { TableColumnTitle } from "../filters/table-column-title.js";
+import "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/registry/niko-table/components/data-table-column-title.tsx
+/**
+* Renders the column title using context.
+*/
+function DataTableColumnTitle(props) {
+	const { column } = useColumnHeaderContext(true);
+	return /* @__PURE__ */ jsx(TableColumnTitle, {
+		column,
+		...props
+	});
+}
+DataTableColumnTitle.displayName = "DataTableColumnTitle";
+//#endregion
+export { DataTableColumnTitle };

package/dist/components/registry/niko-table/components/data-table-empty-state.d.ts

@@ -0,0 +1,108 @@
+import React from "react";
+//#region src/components/registry/niko-table/components/data-table-empty-state.d.ts
+export interface DataTableEmptyStateProps {
+  children: React.ReactNode;
+  isFiltered: boolean;
+  className?: string;
+}
+/**
+ * Root component for empty state composition.
+ * Provides context to child components about filter state.
+ *
+ * @internal - Used by DataTableEmptyBody and DataTableVirtualizedEmptyBody
+ */
+export declare function DataTableEmptyState({ children, isFiltered, className }: DataTableEmptyStateProps): React.JSX.Element;
+export interface DataTableEmptyIconProps {
+  children: React.ReactNode;
+  className?: string;
+}
+/**
+ * Icon component for empty state. Memoized so table-state changes don't re-render it.
+ *
+ * @example
+ * <DataTableEmptyIcon>
+ *   <PackageOpen />
+ * </DataTableEmptyIcon>
+ */
+export declare const DataTableEmptyIcon: React.MemoExoticComponent<({ children, className }: DataTableEmptyIconProps) => React.JSX.Element>;
+export interface DataTableEmptyMessageProps {
+  children: React.ReactNode;
+  className?: string;
+}
+/**
+ * Message component for empty state. Memoized; renders only when not filtered.
+ *
+ * @example
+ * <DataTableEmptyMessage>
+ *   <p className="font-semibold">No products found</p>
+ *   <p className="text-sm text-muted-foreground">
+ *     Get started by adding your first product
+ *   </p>
+ * </DataTableEmptyMessage>
+ */
+export declare const DataTableEmptyMessage: React.MemoExoticComponent<({ children, className }: DataTableEmptyMessageProps) => React.JSX.Element | null>;
+export interface DataTableEmptyFilteredMessageProps {
+  children: React.ReactNode;
+  className?: string;
+}
+/**
+ * Filtered-state message — renders only when a filter is active. Memoized.
+ *
+ * @example
+ * <DataTableEmptyFilteredMessage>
+ *   No matches found for your search
+ * </DataTableEmptyFilteredMessage>
+ */
+export declare const DataTableEmptyFilteredMessage: React.MemoExoticComponent<({ children, className }: DataTableEmptyFilteredMessageProps) => React.JSX.Element | null>;
+export interface DataTableEmptyActionsProps {
+  children: React.ReactNode;
+  className?: string;
+}
+/**
+ * Actions component for empty state.
+ * Displays action buttons or links (e.g., "Add Item", "Clear Filters").
+ * Memoized to prevent unnecessary re-renders.
+ *
+ * @example
+ * <DataTableEmptyActions>
+ *   <Button onClick={handleAdd}>Add Product</Button>
+ * </DataTableEmptyActions>
+ */
+export declare const DataTableEmptyActions: React.MemoExoticComponent<({ children, className }: DataTableEmptyActionsProps) => React.JSX.Element>;
+export interface DataTableEmptyTitleProps {
+  children: React.ReactNode;
+  className?: string;
+}
+/**
+ * Title component for empty state messages.
+ * Convenience wrapper for consistent title styling.
+ * Memoized to prevent unnecessary re-renders.
+ *
+ * @example
+ * <DataTableEmptyMessage>
+ *   <DataTableEmptyTitle>No products found</DataTableEmptyTitle>
+ *   <DataTableEmptyDescription>
+ *     Get started by adding your first product
+ *   </DataTableEmptyDescription>
+ * </DataTableEmptyMessage>
+ */
+export declare const DataTableEmptyTitle: React.MemoExoticComponent<({ children, className }: DataTableEmptyTitleProps) => React.JSX.Element>;
+export interface DataTableEmptyDescriptionProps {
+  children: React.ReactNode;
+  className?: string;
+}
+/**
+ * Description component for empty state messages.
+ * Convenience wrapper for consistent description styling.
+ * Memoized to prevent unnecessary re-renders.
+ *
+ * @example
+ * <DataTableEmptyMessage>
+ *   <DataTableEmptyTitle>No products found</DataTableEmptyTitle>
+ *   <DataTableEmptyDescription>
+ *     Get started by adding your first product
+ *   </DataTableEmptyDescription>
+ * </DataTableEmptyMessage>
+ */
+export declare const DataTableEmptyDescription: React.MemoExoticComponent<({ children, className }: DataTableEmptyDescriptionProps) => React.JSX.Element>;
+//#endregion

package/dist/components/registry/niko-table/components/data-table-empty-state.js

@@ -0,0 +1,148 @@
+"use client";
+import { cn } from "../../../../lib/utils.js";
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/registry/niko-table/components/data-table-empty-state.tsx
+/**
+* niko-table — created by Semir N. (Semkoo, https://github.com/Semkoo) with AI assistance.
+*
+* Before reporting anything: please check the changelog first.
+*  - In-repo: ./CHANGELOG.md
+*  - Docs site: https://niko-table.com/changelog
+*
+* Found a bug or have a fix? Open an issue or PR on GitHub so other
+* users (and future LLMs reading this code) benefit:
+* https://github.com/Semkoo/niko-table-registry
+*/
+const DataTableEmptyStateContext = React.createContext(null);
+function useDataTableEmptyState() {
+	const context = React.useContext(DataTableEmptyStateContext);
+	if (!context) throw new Error("Empty state components must be used within DataTableEmptyState");
+	return context;
+}
+/**
+* Root component for empty state composition.
+* Provides context to child components about filter state.
+*
+* @internal - Used by DataTableEmptyBody and DataTableVirtualizedEmptyBody
+*/
+function DataTableEmptyState({ children, isFiltered, className }) {
+	return /* @__PURE__ */ jsx(DataTableEmptyStateContext.Provider, {
+		value: { isFiltered },
+		children: /* @__PURE__ */ jsx("div", {
+			className: cn("flex flex-col items-center justify-center gap-3 py-4", className),
+			children
+		})
+	});
+}
+/**
+* Icon component for empty state. Memoized so table-state changes don't re-render it.
+*
+* @example
+* <DataTableEmptyIcon>
+*   <PackageOpen />
+* </DataTableEmptyIcon>
+*/
+const DataTableEmptyIcon = React.memo(function DataTableEmptyIcon({ children, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("text-muted-foreground/50", className),
+		children
+	});
+});
+DataTableEmptyIcon.displayName = "DataTableEmptyIcon";
+/**
+* Message component for empty state. Memoized; renders only when not filtered.
+*
+* @example
+* <DataTableEmptyMessage>
+*   <p className="font-semibold">No products found</p>
+*   <p className="text-sm text-muted-foreground">
+*     Get started by adding your first product
+*   </p>
+* </DataTableEmptyMessage>
+*/
+const DataTableEmptyMessage = React.memo(function DataTableEmptyMessage({ children, className }) {
+	const { isFiltered } = useDataTableEmptyState();
+	if (isFiltered) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex flex-col items-center gap-1 text-center text-muted-foreground", className),
+		children
+	});
+});
+DataTableEmptyMessage.displayName = "DataTableEmptyMessage";
+/**
+* Filtered-state message — renders only when a filter is active. Memoized.
+*
+* @example
+* <DataTableEmptyFilteredMessage>
+*   No matches found for your search
+* </DataTableEmptyFilteredMessage>
+*/
+const DataTableEmptyFilteredMessage = React.memo(function DataTableEmptyFilteredMessage({ children, className }) {
+	const { isFiltered } = useDataTableEmptyState();
+	if (!isFiltered) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex flex-col items-center gap-1 text-center text-muted-foreground", className),
+		children
+	});
+});
+DataTableEmptyFilteredMessage.displayName = "DataTableEmptyFilteredMessage";
+/**
+* Actions component for empty state.
+* Displays action buttons or links (e.g., "Add Item", "Clear Filters").
+* Memoized to prevent unnecessary re-renders.
+*
+* @example
+* <DataTableEmptyActions>
+*   <Button onClick={handleAdd}>Add Product</Button>
+* </DataTableEmptyActions>
+*/
+const DataTableEmptyActions = React.memo(function DataTableEmptyActions({ children, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("mt-2 flex gap-2", className),
+		children
+	});
+});
+DataTableEmptyActions.displayName = "DataTableEmptyActions";
+/**
+* Title component for empty state messages.
+* Convenience wrapper for consistent title styling.
+* Memoized to prevent unnecessary re-renders.
+*
+* @example
+* <DataTableEmptyMessage>
+*   <DataTableEmptyTitle>No products found</DataTableEmptyTitle>
+*   <DataTableEmptyDescription>
+*     Get started by adding your first product
+*   </DataTableEmptyDescription>
+* </DataTableEmptyMessage>
+*/
+const DataTableEmptyTitle = React.memo(function DataTableEmptyTitle({ children, className }) {
+	return /* @__PURE__ */ jsx("p", {
+		className: cn("font-semibold", className),
+		children
+	});
+});
+DataTableEmptyTitle.displayName = "DataTableEmptyTitle";
+/**
+* Description component for empty state messages.
+* Convenience wrapper for consistent description styling.
+* Memoized to prevent unnecessary re-renders.
+*
+* @example
+* <DataTableEmptyMessage>
+*   <DataTableEmptyTitle>No products found</DataTableEmptyTitle>
+*   <DataTableEmptyDescription>
+*     Get started by adding your first product
+*   </DataTableEmptyDescription>
+* </DataTableEmptyMessage>
+*/
+const DataTableEmptyDescription = React.memo(function DataTableEmptyDescription({ children, className }) {
+	return /* @__PURE__ */ jsx("p", {
+		className: cn("text-sm text-muted-foreground", className),
+		children
+	});
+});
+DataTableEmptyDescription.displayName = "DataTableEmptyDescription";
+//#endregion
+export { DataTableEmptyActions, DataTableEmptyDescription, DataTableEmptyFilteredMessage, DataTableEmptyIcon, DataTableEmptyMessage, DataTableEmptyState, DataTableEmptyTitle };

package/dist/components/registry/niko-table/components/data-table-faceted-filter.d.ts

@@ -0,0 +1,46 @@
+import { Option } from "../types/index.js";
+import { TableFacetedFilterProps } from "../filters/table-faceted-filter.js";
+import * as React$1 from "react";
+import { RowData } from "@tanstack/react-table";
+//#region src/components/registry/niko-table/components/data-table-faceted-filter.d.ts
+type DataTableFacetedFilterProps<TData extends RowData, TValue> = Omit<TableFacetedFilterProps<TData, TValue>, "column" | "options"> & {
+  /**
+   * The accessor key of the column to filter (matches column definition)
+   */
+  accessorKey: keyof TData & string;
+  /**
+   * Optional title override (if not provided, will use column.meta.label)
+   */
+  title?: string;
+  /**
+   * Static options (if provided, will be used instead of dynamic generation)
+   */
+  options?: Option[];
+  /**
+   * Whether to show counts for each option
+   * @default true
+   */
+  showCounts?: boolean;
+  /**
+   * Whether to update counts based on other active filters
+   * @default true
+   */
+  dynamicCounts?: boolean;
+  /**
+   * If true, only show options that exist in the currently filtered table rows.
+   * If false, show all options from the entire dataset (useful for multi-select filters
+   * where you want to see all possible options even if they're not in the current filtered results).
+   * @default !multiple (true for single-select, false for multi-select)
+   */
+  limitToFilteredRows?: boolean;
+};
+export declare function DataTableFacetedFilter<TData extends RowData, TValue = unknown>({ accessorKey, options, showCounts, dynamicCounts, limitToFilteredRows, title, multiple, trigger, ...props }: DataTableFacetedFilterProps<TData, TValue>): React$1.JSX.Element | null;
+export declare namespace DataTableFacetedFilter {
+  var displayName: string;
+}
+export declare function DataTableFacetedFilterContent<TData extends RowData, TValue = unknown>({ accessorKey, options, showCounts, dynamicCounts, limitToFilteredRows, title, multiple, onValueChange }: DataTableFacetedFilterProps<TData, TValue>): React$1.JSX.Element | null;
+export declare namespace DataTableFacetedFilterContent {
+  var displayName: string;
+}
+//#endregion
+export {};

package/dist/components/registry/niko-table/components/data-table-faceted-filter.js

@@ -0,0 +1,133 @@
+import { useGeneratedOptionsForColumn } from "../hooks/use-generated-options.js";
+import { useDataTable } from "../core/data-table-context.js";
+import { useDerivedColumnTitle } from "../hooks/use-derived-column-title.js";
+import { TableFacetedFilter, TableFacetedFilterContent, useTableFacetedFilter } from "../filters/table-faceted-filter.js";
+import { buildFacetedOptions } from "../lib/build-faceted-options.js";
+import * as React$1 from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/registry/niko-table/components/data-table-faceted-filter.tsx
+function useFacetedOptions({ table, accessorKey, options, showCounts, dynamicCounts, limitToFilteredRows, precomputedOptions }) {
+	const column = table.getColumn(accessorKey);
+	const metaGenerated = precomputedOptions?.[accessorKey] ?? [];
+	const needsFallbackGeneration = !precomputedOptions;
+	const perColumnGenerated = useGeneratedOptionsForColumn(table, needsFallbackGeneration ? accessorKey : "__noop__", {
+		showCounts,
+		dynamicCounts,
+		limitToFilteredRows
+	});
+	const resolvedMetaGenerated = needsFallbackGeneration ? perColumnGenerated : metaGenerated;
+	const state = table.state;
+	const columnFilters = state.columnFilters;
+	const globalFilter = state.globalFilter;
+	const coreRows = table.getCoreRowModel().rows;
+	return React$1.useMemo(() => {
+		if (!column) return [];
+		const meta = column.columnDef.meta;
+		const autoOptionsFormat = meta?.autoOptionsFormat ?? true;
+		const formatOptionLabel = meta?.formatOptionLabel;
+		if (options && options.length > 0) return buildFacetedOptions(table, coreRows, accessorKey, columnFilters, globalFilter, {
+			staticOptions: options,
+			limitToFilteredRows,
+			dynamicCounts,
+			showCounts,
+			autoOptionsFormat,
+			formatOptionLabel
+		});
+		if (resolvedMetaGenerated.length > 0) return resolvedMetaGenerated;
+		return buildFacetedOptions(table, coreRows, accessorKey, columnFilters, globalFilter, {
+			limitToFilteredRows,
+			dynamicCounts,
+			showCounts,
+			autoOptionsFormat,
+			formatOptionLabel
+		});
+	}, [
+		column,
+		options,
+		resolvedMetaGenerated,
+		table,
+		coreRows,
+		accessorKey,
+		columnFilters,
+		globalFilter,
+		limitToFilteredRows,
+		dynamicCounts,
+		showCounts
+	]);
+}
+/**
+* Shared setup for the two exported wrapper components. Keeps column lookup,
+* title derivation, and options resolution in one place so the wrappers stay
+* thin.
+*/
+function useFacetedFilterSetup({ accessorKey, options, showCounts, dynamicCounts, limitToFilteredRows, title }) {
+	const { table, generatedOptionsMap } = useDataTable();
+	const column = table.getColumn(accessorKey);
+	return {
+		table,
+		column,
+		derivedTitle: useDerivedColumnTitle(column, accessorKey, title),
+		dynamicOptions: useFacetedOptions({
+			table,
+			accessorKey,
+			options,
+			showCounts,
+			dynamicCounts,
+			limitToFilteredRows,
+			precomputedOptions: generatedOptionsMap
+		})
+	};
+}
+function DataTableFacetedFilter({ accessorKey, options, showCounts = true, dynamicCounts = true, limitToFilteredRows, title, multiple, trigger, ...props }) {
+	const { column, derivedTitle, dynamicOptions } = useFacetedFilterSetup({
+		accessorKey,
+		options,
+		showCounts,
+		dynamicCounts,
+		limitToFilteredRows: limitToFilteredRows ?? !multiple,
+		title
+	});
+	if (!column) {
+		console.warn(`Column with accessorKey "${accessorKey}" not found in table columns`);
+		return null;
+	}
+	return /* @__PURE__ */ jsx(TableFacetedFilter, {
+		column,
+		options: dynamicOptions,
+		title: derivedTitle,
+		multiple,
+		trigger,
+		...props
+	});
+}
+/**
+* @required displayName is required for auto feature detection
+* @see "feature-detection.ts"
+*/
+DataTableFacetedFilter.displayName = "DataTableFacetedFilter";
+function DataTableFacetedFilterContent({ accessorKey, options, showCounts = true, dynamicCounts = true, limitToFilteredRows, title, multiple, onValueChange }) {
+	const { column, derivedTitle, dynamicOptions } = useFacetedFilterSetup({
+		accessorKey,
+		options,
+		showCounts,
+		dynamicCounts,
+		limitToFilteredRows: limitToFilteredRows ?? !multiple,
+		title
+	});
+	const { selectedValues, onItemSelect, onReset } = useTableFacetedFilter({
+		column,
+		onValueChange,
+		multiple
+	});
+	if (!column) return null;
+	return /* @__PURE__ */ jsx(TableFacetedFilterContent, {
+		title: derivedTitle,
+		options: dynamicOptions,
+		selectedValues,
+		onItemSelect,
+		onReset
+	});
+}
+DataTableFacetedFilterContent.displayName = "DataTableFacetedFilterContent";
+//#endregion
+export { DataTableFacetedFilter, DataTableFacetedFilterContent };

package/dist/components/registry/niko-table/components/data-table-grouped-rows.d.ts

@@ -0,0 +1,111 @@
+import { DataTableRow } from "../types/index.js";
+import React from "react";
+import { RowData } from "@tanstack/react-table";
+//#region src/components/registry/niko-table/components/data-table-grouped-rows.d.ts
+/**
+ * What a custom group-row child reads from context.
+ *
+ * Everything a group row needs is here, so the child stays a plain component
+ * rather than a function of arguments — the same contract `useDataTableRow`
+ * gives a row menu.
+ */
+export interface DataTableGroupRowContextValue<TData extends RowData = RowData> {
+  /** The grouped row itself (`row.getIsGrouped()` is true). */
+  row: DataTableRow<TData>;
+  /** Value the rows underneath share, already resolved from the grouped column. */
+  groupValue: unknown;
+  /** `groupValue` as a display string; empty when the value is null/undefined. */
+  groupLabel: string;
+  /** How many rows this group holds. */
+  count: number;
+  /** Whether the group is currently open. */
+  isExpanded: boolean;
+  /** Open/close the group. */
+  toggle: () => void;
+  /** Position in the current display model (post sort/filter/group). */
+  displayIndex: number;
+  /** Shared `columnId -> width`, so a custom row still lines up with its leaves. */
+  columnWidths: ReadonlyMap<string, number | string | undefined>;
+}
+/** Provider — used by the body, not by callers. */
+export declare function DataTableGroupRowProvider({ value, children }: {
+  value: DataTableGroupRowContextValue;
+  children: React.ReactNode;
+}): React.JSX.Element;
+/**
+ * Read the group row a custom `<DataTableGroupedRows>` child is rendering for.
+ *
+ * @example
+ * function RegionGroupRow() {
+ *   const { groupLabel, count, isExpanded, toggle } = useDataTableGroupRow()
+ *   return (
+ *     <TableCell colSpan={4} onClick={toggle}>
+ *       {groupLabel} — {count} in region {isExpanded ? "▾" : "▸"}
+ *     </TableCell>
+ *   )
+ * }
+ */
+export declare function useDataTableGroupRow<TData extends RowData = RowData>(): DataTableGroupRowContextValue<TData>;
+export interface DataTableGroupedRowsProps<TData extends RowData = RowData> {
+  /**
+   * Optional replacement for the built-in group row. Composed as a child, not
+   * passed as a render prop or a callback:
+   *
+   *   <DataTableGroupedRows>
+   *     <RegionGroupRow />
+   *   </DataTableGroupedRows>
+   *
+   * The child renders the row's cells; the body owns the surrounding
+   * `<TableRow>` so column geometry, parity and data attributes stay
+   * consistent with the leaf rows. Read the group from `useDataTableGroupRow()`.
+   *
+   * Omit it and the built-in row renders: a chevron, the group value, and a
+   * `· N rows` count, with aggregated cells from each column's
+   * `aggregatedCell` / `aggregationFn`.
+   */
+  children?: React.ReactNode;
+  /**
+   * Optional per-group predicate — return `false` to fall back to the built-in
+   * row for that group. Table-level gating is better expressed by simply not
+   * nesting this component.
+   */
+  enabledFor?: (row: DataTableRow<TData>) => boolean;
+}
+/**
+ * Declarative, composable group rows for niko-table bodies.
+ *
+ * Nest it inside a `DataTableBody` so grouping reads as part of the table's
+ * JSX tree. It renders nothing itself — its presence is what turns grouping
+ * on (feature detection maps it to `enableGrouping` + `enableExpanding`), and
+ * the body renders a group row wherever TanStack's grouped row model produces
+ * one.
+ *
+ * This is the whole opt-in. There is no `enableGrouping` config flag to set
+ * and no renderer to wire up: compose the component, or don't.
+ *
+ * @example
+ * // Built-in group row
+ * <DataTableBody>
+ *   <DataTableGroupedRows />
+ * </DataTableBody>
+ *
+ * @example
+ * // Your own, reading the group from context
+ * <DataTableBody>
+ *   <DataTableGroupedRows>
+ *     <RegionGroupRow />
+ *   </DataTableGroupedRows>
+ * </DataTableBody>
+ */
+export declare function DataTableGroupedRows<TData extends RowData = RowData>(_props: DataTableGroupedRowsProps<TData>): null;
+export declare namespace DataTableGroupedRows {
+  var displayName: string;
+}
+/**
+ * Body-side: find a nested `<DataTableGroupedRows>` among `children`.
+ *
+ * Matches on `displayName` as well as reference, because re-exports and HMR
+ * both break reference equality.
+ */
+export declare function resolveGroupedRowsSlot<TData extends RowData = RowData>(children: React.ReactNode): DataTableGroupedRowsProps<TData> | undefined;
+//#endregion