@agentero/design-system 0.24.3 → 0.24.5

package/src/data-table/data-table.d.ts

@@ -37,35 +37,18 @@ type DataTableRootProps<TData extends RowData> = DataTableProps<TData> & {
      * framework link (e.g. Next.js `Link`) for client-side navigation. */
     linkComponent?: ElementType;
 };
-type DataTableTableProps = PropsWithChildren<{
-    /** Row density: `sm` (48px), `md` (64px), `lg` (88px). Defaults to `'md'`. */
-    size?: TableRootProps['size'];
-    /** Which edges stay sticky on scroll. Defaults to `'header'`. */
-    sticky?: TableRootProps['sticky'];
-    /** Embedded-in-page style: drops the row dividers and tightens the edge gutter to 1rem. Defaults to `true`. */
-    embed?: TableRootProps['embed'];
-    /** Wrap the table in a bordered, rounded container (standalone "card" look). Defaults to `false`. */
-    enclosed?: TableRootProps['enclosed'];
-}>;
 /**
- * Offset/limit pagination state shape, for callers driving server-side paging.
+ * Root of the DataTable, the data-driven table compound built on TanStack Table
+ * and the `Table` primitive. It builds the TanStack table instance from
+ * `data`/`columns` (plus any TanStack options) and shares it with the
+ * subcomponents.
  *
- * @property {number} offset - Zero-based index of the first item on the page.
- * @property {number} limit - Number of items per page.
- */
-export type PaginationState = {
-    offset: number;
-    limit: number;
-};
-/**
- * Data-driven table compound built on TanStack Table and the `Table` primitive.
- * Compose `Root` (owns the table instance) with `ToolBar`, `Table` (headers/rows,
- * sorting, navigation, empty state), and `Footer` + `Pagination`. For hand-rendered
- * rows without TanStack, drop to the `Table` primitive.
+ * Compose `Root` with `ToolBar`, `Table` (headers/rows, sorting, navigation,
+ * empty state), and `Footer` + `Pagination`. For hand-rendered rows without
+ * TanStack, drop to the `Table` primitive.
  *
- * @summary Data-driven table compound (sorting, toolbar, pagination) over TanStack
+ * @summary DataTable root that builds the table instance and shares context
  * @see {@link https://tanstack.com/table/latest|TanStack Table}
- * @namespace DataTable
  *
  * @example
  * ```tsx
@@ -94,26 +77,78 @@ export type PaginationState = {
  * </DataTable.Root>
  * ```
  */
-export declare const DataTable: {
-    Root: {
-        <TData extends RowData>({ children, isLoading, onRowClick, rowHref, linkComponent, ...tableOptions }: PropsWithChildren<DataTableRootProps<TData>>): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
-    ToolBar: {
-        ({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
-    Table: {
-        ({ children, size, sticky, embed, enclosed }: DataTableTableProps): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
-    Footer: {
-        ({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
-    Pagination: {
-        (props: PaginationProps): import("react/jsx-runtime").JSX.Element;
-        displayName: string;
-    };
+export declare const Root: {
+    <TData extends RowData>({ children, isLoading, onRowClick, rowHref, linkComponent, ...tableOptions }: PropsWithChildren<DataTableRootProps<TData>>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * Toolbar strip above the table for search, filters, and actions. Its `px-4`
+ * matches the table's edge cells so toolbar and column content align.
+ *
+ * @summary Toolbar row above the table for filters and actions
+ */
+export declare const ToolBar: {
+    ({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+type DataTableTableProps = PropsWithChildren<{
+    /** Row density: `sm` (48px), `md` (64px), `lg` (88px). Defaults to `'md'`. */
+    size?: TableRootProps['size'];
+    /** Which edges stay sticky on scroll. Defaults to `'header'`. */
+    sticky?: TableRootProps['sticky'];
+    /** Embedded-in-page style: drops the row dividers and tightens the edge gutter to 1rem. Defaults to `true`. */
+    embed?: TableRootProps['embed'];
+    /** Wrap the table in a bordered, rounded container (standalone "card" look). Defaults to `false`. */
+    enclosed?: TableRootProps['enclosed'];
+}>;
+/**
+ * Renders the headers and rows from the table instance. Sortable columns toggle
+ * sorting on click; rows become clickable when `onRowClick` or `rowHref` is set.
+ * Pass a custom empty state as children. `size`/`sticky`/`embed` forward to
+ * `Table.Root`.
+ *
+ * @summary Renders headers and rows, with sorting and row navigation
+ *
+ * @example
+ * ```tsx
+ * <DataTable.Table>
+ *   <CustomEmptyState />
+ * </DataTable.Table>
+ * ```
+ */
+export declare const DataTableTable: {
+    ({ children, size, sticky, embed, enclosed }: DataTableTableProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * Offset/limit pagination state shape, for callers driving server-side paging.
+ *
+ * @property {number} offset - Zero-based index of the first item on the page.
+ * @property {number} limit - Number of items per page.
+ */
+export type PaginationState = {
+    offset: number;
+    limit: number;
+};
+/**
+ * Footer strip below the table, typically holding pagination. Separated from
+ * the table body by a top border and right-aligns its content.
+ *
+ * @summary Footer row below the table for pagination
+ */
+export declare const Footer: {
+    ({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * Pagination control wired to the table: scrolls the table viewport back to the
+ * top whenever the page changes, then forwards to the caller's `onPageChange`.
+ * Place it inside `DataTable.Footer`.
+ *
+ * @summary Table-aware pagination that scrolls to top on page change
+ */
+export declare const DataTablePagination: {
+    (props: PaginationProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
 };
 export {};

package/src/data-table/data-table.js

@@ -1,51 +1,51 @@
 "use client";
 import { cn as e } from "../../lib/utils.js";
-import { IconArrowUpward as t, IconSwapVert as n } from "./icons.js";
-import { Table as r } from "./table.js";
-import { Pagination as i } from "../pagination/pagination.js";
-import { tv as a } from "tailwind-variants";
-import { Fragment as o, jsx as s, jsxs as c } from "react/jsx-runtime";
-import { Fragment as l, createContext as u, use as d, useRef as f } from "react";
-import { flexRender as p, getCoreRowModel as m, useReactTable as h } from "@tanstack/react-table";
+import { Pagination as t } from "../pagination/pagination.js";
+import { IconArrowUpward as n, IconSwapVert as r } from "./icons.js";
+import { TableBody as i, TableCell as a, TableHead as o, TableHeader as s, TableRoot as c, TableRow as l } from "./table.js";
+import { tv as u } from "tailwind-variants";
+import { Fragment as d, jsx as f, jsxs as p } from "react/jsx-runtime";
+import { Fragment as m, createContext as h, use as g, useRef as _ } from "react";
+import { flexRender as v, getCoreRowModel as y, useReactTable as b } from "@tanstack/react-table";
 //#region src/data-table/data-table.tsx
-var g = u(null), _ = () => {
-	let e = d(g);
+var x = h(null), S = () => {
+	let e = g(x);
 	if (!e) throw Error("useDataTable must be used within a DataTable.Root");
 	return e;
-}, v = ({ children: e, isLoading: t = !1, onRowClick: n, rowHref: r, linkComponent: i = "a", ...a }) => /* @__PURE__ */ s(g, {
+}, C = ({ children: e, isLoading: t = !1, onRowClick: n, rowHref: r, linkComponent: i = "a", ...a }) => /* @__PURE__ */ f(x, {
 	value: {
-		table: h({
+		table: b({
 			...a,
-			getCoreRowModel: m()
+			getCoreRowModel: y()
 		}),
 		isLoading: t,
-		scrollRef: f(null),
+		scrollRef: _(null),
 		onRowClick: n,
 		rowHref: r,
 		linkComponent: i
 	},
-	children: /* @__PURE__ */ s("div", {
+	children: /* @__PURE__ */ f("div", {
 		"data-slot": "data-table-root",
 		className: "flex min-h-0 flex-1 flex-col",
 		children: e
 	})
 });
-v.displayName = "DataTable.Root";
-var y = ({ children: e }) => /* @__PURE__ */ s("div", {
+C.displayName = "DataTable.Root";
+var w = ({ children: e }) => /* @__PURE__ */ f("div", {
 	"data-slot": "data-table-toolbar",
 	role: "toolbar",
 	className: "flex gap-2 border-b border-border-default-base-primary px-4 py-3",
 	children: e
 });
-y.displayName = "DataTable.ToolBar";
-var b = a({
+w.displayName = "DataTable.ToolBar";
+var T = u({
 	base: "size-4 transition-transform duration-200",
 	variants: { direction: {
 		asc: "",
 		desc: "rotate-180",
 		false: ""
 	} }
-}), x = a({
+}), E = u({
 	base: "flex w-full appearance-none items-center bg-transparent p-0 text-left [font:inherit]",
 	variants: {
 		canSort: {
@@ -57,103 +57,96 @@ var b = a({
 			left: "justify-start"
 		}
 	}
-}), S = (e) => !!e.closest("a, button, [role=\"menu\"]"), C = ({ children: i = /* @__PURE__ */ s(w, {}), size: a = "md", sticky: u = "header", embed: d = !0, enclosed: f = !1 }) => {
-	let { table: m, isLoading: h, scrollRef: g, onRowClick: v, rowHref: y, linkComponent: C } = _(), T = m.getAllColumns().length;
-	return /* @__PURE__ */ s("div", {
+}), D = (e) => !!e.closest("a, button, [role=\"menu\"]"), O = ({ children: t = /* @__PURE__ */ f(k, {}), size: u = "md", sticky: h = "header", embed: g = !0, enclosed: _ = !1 }) => {
+	let { table: y, isLoading: b, scrollRef: x, onRowClick: C, rowHref: w, linkComponent: O } = S(), A = y.getAllColumns().length;
+	return /* @__PURE__ */ f("div", {
 		"data-slot": "data-table-loading-overlay",
-		className: e("flex min-h-0 flex-1 flex-col transition-opacity duration-150", h && "opacity-50"),
-		children: /* @__PURE__ */ c(r.Root, {
-			size: a,
-			sticky: u,
-			embed: d,
-			enclosed: f,
-			ref: g,
-			children: [/* @__PURE__ */ s(r.Head, { children: m.getHeaderGroups().map((e) => /* @__PURE__ */ s(r.Row, { children: e.headers.map((e) => {
-				let i = e.column.columnDef.meta, a = e.column.getCanSort(), l = e.column.getIsSorted(), u = i?.style?.textAlign === "right" || i?.className?.includes("text-right") ? "right" : "left", d = e.isPlaceholder ? null : /* @__PURE__ */ c(o, { children: [p(e.column.columnDef.header, e.getContext()), a && /* @__PURE__ */ s("span", {
+		className: e("flex min-h-0 flex-1 flex-col transition-opacity duration-150", b && "opacity-50"),
+		children: /* @__PURE__ */ p(c, {
+			size: u,
+			sticky: h,
+			embed: g,
+			enclosed: _,
+			ref: x,
+			children: [/* @__PURE__ */ f(o, { children: y.getHeaderGroups().map((e) => /* @__PURE__ */ f(l, { children: e.headers.map((e) => {
+				let t = e.column.columnDef.meta, i = e.column.getCanSort(), a = e.column.getIsSorted(), o = t?.style?.textAlign === "right" || t?.className?.includes("text-right") ? "right" : "left", c = e.isPlaceholder ? null : /* @__PURE__ */ p(d, { children: [v(e.column.columnDef.header, e.getContext()), i && /* @__PURE__ */ f("span", {
 					className: "size-4",
-					children: l ? /* @__PURE__ */ s(t, { className: b({ direction: l }) }) : /* @__PURE__ */ s(n, { className: "size-4" })
+					children: a ? /* @__PURE__ */ f(n, { className: T({ direction: a }) }) : /* @__PURE__ */ f(r, { className: "size-4" })
 				})] });
-				return /* @__PURE__ */ s(r.Header, {
-					...i,
-					"aria-sort": a ? l === "asc" ? "ascending" : l === "desc" ? "descending" : "none" : void 0,
-					children: a ? /* @__PURE__ */ s("button", {
+				return /* @__PURE__ */ f(s, {
+					...t,
+					"aria-sort": i ? a === "asc" ? "ascending" : a === "desc" ? "descending" : "none" : void 0,
+					children: i ? /* @__PURE__ */ f("button", {
 						type: "button",
-						className: x({
+						className: E({
 							canSort: !0,
-							align: u
+							align: o
 						}),
 						onClick: e.column.getToggleSortingHandler(),
 						title: e.column.getNextSortingOrder() === "asc" ? "Sort ascending" : e.column.getNextSortingOrder() === "desc" ? "Sort descending" : "Clear sort",
-						children: d
-					}) : /* @__PURE__ */ s("div", {
-						className: x({
+						children: c
+					}) : /* @__PURE__ */ f("div", {
+						className: E({
 							canSort: !1,
-							align: u
+							align: o
 						}),
-						children: d
+						children: c
 					})
 				}, e.id);
-			}) }, e.id)) }), /* @__PURE__ */ s(r.Body, { children: m.getRowModel().rows.length ? m.getRowModel().rows.map((t) => {
-				let n = y?.(t.original), i = !!v || !!n;
-				return /* @__PURE__ */ s(l, { children: /* @__PURE__ */ s(r.Row, {
-					className: e("has-aria-expanded:bg-bg-default-base-secondary", i && "cursor-pointer"),
-					onClick: i ? (e) => {
-						S(e.target) || !e.currentTarget.contains(e.target) || (v ? v(t.original) : n && e.currentTarget.querySelector("[data-row-link]")?.click());
+			}) }, e.id)) }), /* @__PURE__ */ f(i, { children: y.getRowModel().rows.length ? y.getRowModel().rows.map((t) => {
+				let n = w?.(t.original), r = !!C || !!n;
+				return /* @__PURE__ */ f(m, { children: /* @__PURE__ */ f(l, {
+					className: e("has-aria-expanded:bg-bg-default-base-secondary", r && "cursor-pointer"),
+					onClick: r ? (e) => {
+						D(e.target) || !e.currentTarget.contains(e.target) || (C ? C(t.original) : n && e.currentTarget.querySelector("[data-row-link]")?.click());
 					} : void 0,
 					children: t.getVisibleCells().map((e, t) => {
-						let i = e.column.columnDef.meta;
-						return /* @__PURE__ */ c(r.Cell, {
-							...i,
-							children: [t === 0 && n && /* @__PURE__ */ s(C, {
+						let r = e.column.columnDef.meta;
+						return /* @__PURE__ */ p(a, {
+							...r,
+							children: [t === 0 && n && /* @__PURE__ */ f(O, {
 								href: n,
 								"data-row-link": !0,
 								className: "hidden",
 								tabIndex: -1,
 								"aria-hidden": "true"
-							}), p(e.column.columnDef.cell, e.getContext())]
+							}), v(e.column.columnDef.cell, e.getContext())]
 						}, e.id);
 					})
 				}) }, t.id);
-			}) : h ? null : /* @__PURE__ */ s(r.Row, { children: /* @__PURE__ */ s(r.Cell, {
-				colSpan: T,
-				children: /* @__PURE__ */ s("div", {
+			}) : b ? null : /* @__PURE__ */ f(l, { children: /* @__PURE__ */ f(a, {
+				colSpan: A,
+				children: /* @__PURE__ */ f("div", {
 					"data-slot": "table-empty-state",
 					className: "whitespace-normal",
-					children: i
+					children: t
 				})
 			}) }) })]
 		})
 	});
 };
-C.displayName = "DataTable.Table";
-var w = () => /* @__PURE__ */ s("div", {
+O.displayName = "DataTable.Table";
+var k = () => /* @__PURE__ */ f("div", {
 	className: "mb-6 flex flex-col items-center gap-4",
-	children: /* @__PURE__ */ s("div", {
+	children: /* @__PURE__ */ f("div", {
 		className: "text-lg",
-		children: /* @__PURE__ */ s("b", { children: "No results." })
+		children: /* @__PURE__ */ f("b", { children: "No results." })
 	})
-}), T = ({ children: e }) => /* @__PURE__ */ s("div", {
+}), A = ({ children: e }) => /* @__PURE__ */ f("div", {
 	"data-slot": "data-table-pagination",
 	className: "flex justify-end border-t border-border-default-base-primary px-6 py-3",
 	children: e
 });
-T.displayName = "DataTable.Footer";
-var E = (e) => {
-	let { scrollRef: t } = _();
-	return /* @__PURE__ */ s(i, {
+A.displayName = "DataTable.Footer";
+var j = (e) => {
+	let { scrollRef: n } = S();
+	return /* @__PURE__ */ f(t, {
 		...e,
-		onPageChange: (n) => {
-			t.current?.scrollTo({ top: 0 }), e.onPageChange(n);
+		onPageChange: (t) => {
+			n.current?.scrollTo({ top: 0 }), e.onPageChange(t);
 		}
 	});
 };
-E.displayName = "DataTable.Pagination";
-var D = {
-	Root: v,
-	ToolBar: y,
-	Table: C,
-	Footer: T,
-	Pagination: E
-};
+j.displayName = "DataTable.Pagination";
 //#endregion
-export { D as DataTable, _ as useDataTable };
+export { j as DataTablePagination, O as DataTableTable, A as Footer, C as Root, w as ToolBar, S as useDataTable };

package/src/data-table/index.d.ts

@@ -1,4 +1,177 @@
-export { Table, tableRecipe } from './table';
+export { tableRecipe } from './table';
 export type { TableRootProps } from './table';
-export { DataTable, useDataTable } from './data-table';
+export { useDataTable } from './data-table';
 export type { DataTableColumnMeta, PaginationState } from './data-table';
+export declare const Table: {
+    Root: {
+        ({ children, ref, ...variants }: import('react').PropsWithChildren<import('./table').TableRootProps>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Head: {
+        ({ children, ...props }: import('react').PropsWithChildren<import('react').HTMLAttributes<HTMLTableSectionElement>>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        ({ children, ...props }: import('react').PropsWithChildren<import('react').HTMLAttributes<HTMLTableSectionElement>>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Row: {
+        ({ className, ...props }: import('react').ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        ({ className, ...props }: import('react').PropsWithChildren<import('react').HTMLAttributes<HTMLTableCellElement>>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Cell: {
+        ({ className, ...props }: import('react').PropsWithChildren<import('react').TdHTMLAttributes<HTMLTableCellElement>>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    ExpandButton: {
+        ({ toggleExpanded, isExpanded, className, ...props }: {
+            toggleExpanded: () => void;
+            isExpanded: boolean;
+        } & {
+            children?: import('react').ReactNode;
+            variant?: import('../button').ButtonVariantType;
+            size?: import('../button').ButtonSizeType;
+            status?: "danger";
+            loading?: boolean;
+            disabled?: boolean;
+            iconOnly?: boolean;
+            rounded?: boolean;
+            align?: "center" | "start" | "end" | "justify";
+            fitContent?: boolean;
+            ref?: import('react').Ref<HTMLButtonElement | HTMLAnchorElement>;
+        } & import('react').ButtonHTMLAttributes<HTMLButtonElement> & {
+            asChild?: boolean;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    ExpandedRow: {
+        ({ className, ...props }: import('react').PropsWithChildren<import('react').HTMLAttributes<HTMLTableRowElement>>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    RowActions: {
+        ({ children }: import('react').PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export declare const DataTable: {
+    Root: {
+        <TData extends import('@tanstack/table-core').RowData>({ children, isLoading, onRowClick, rowHref, linkComponent, ...tableOptions }: import('react').PropsWithChildren<{
+            data: TData[];
+            meta?: import('@tanstack/table-core').TableMeta<TData> | undefined;
+            columns: import('@tanstack/table-core').ColumnDef<TData, any>[];
+            state?: Partial<import('@tanstack/table-core').TableState> | undefined;
+            onStateChange?: ((updater: import('@tanstack/table-core').Updater<import('@tanstack/table-core').TableState>) => void) | undefined;
+            renderFallbackValue?: any;
+            _features?: import('@tanstack/table-core').TableFeature[] | undefined;
+            autoResetAll?: boolean | undefined;
+            debugAll?: boolean | undefined;
+            debugCells?: boolean | undefined;
+            debugColumns?: boolean | undefined;
+            debugHeaders?: boolean | undefined;
+            debugRows?: boolean | undefined;
+            debugTable?: boolean | undefined;
+            defaultColumn?: Partial<import('@tanstack/table-core').ColumnDef<TData, unknown>> | undefined;
+            getRowId?: ((originalRow: TData, index: number, parent?: import('@tanstack/table-core').Row<TData> | undefined) => string) | undefined;
+            getSubRows?: ((originalRow: TData, index: number) => TData[] | undefined) | undefined;
+            initialState?: import('@tanstack/table-core').InitialTableState | undefined;
+            mergeOptions?: ((defaultOptions: import('@tanstack/table-core').TableOptions<TData>, options: Partial<import('@tanstack/table-core').TableOptions<TData>>) => import('@tanstack/table-core').TableOptions<TData>) | undefined;
+            enableHiding?: boolean | undefined;
+            onColumnVisibilityChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').VisibilityState> | undefined;
+            onColumnOrderChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').ColumnOrderState> | undefined;
+            enableColumnPinning?: boolean | undefined;
+            enablePinning?: boolean | undefined;
+            onColumnPinningChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').ColumnPinningState> | undefined;
+            enableRowPinning?: boolean | ((row: import('@tanstack/table-core').Row<TData>) => boolean) | undefined;
+            keepPinnedRows?: boolean | undefined;
+            onRowPinningChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').RowPinningState> | undefined;
+            getFacetedMinMaxValues?: ((table: import('@tanstack/table-core').Table<TData>, columnId: string) => () => undefined | [number, number]) | undefined;
+            getFacetedRowModel?: ((table: import('@tanstack/table-core').Table<TData>, columnId: string) => () => import('@tanstack/table-core').RowModel<TData>) | undefined;
+            getFacetedUniqueValues?: ((table: import('@tanstack/table-core').Table<TData>, columnId: string) => () => Map<any, number>) | undefined;
+            enableColumnFilters?: boolean | undefined;
+            enableFilters?: boolean | undefined;
+            filterFromLeafRows?: boolean | undefined;
+            getFilteredRowModel?: ((table: import('@tanstack/table-core').Table<any>) => () => import('@tanstack/table-core').RowModel<any>) | undefined;
+            manualFiltering?: boolean | undefined;
+            maxLeafRowFilterDepth?: number | undefined;
+            onColumnFiltersChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').ColumnFiltersState> | undefined;
+            filterFns?: Record<string, import('@tanstack/table-core').FilterFn<any>> | undefined;
+            enableGlobalFilter?: boolean | undefined;
+            getColumnCanGlobalFilter?: ((column: import('@tanstack/table-core').Column<TData, unknown>) => boolean) | undefined;
+            globalFilterFn?: import('@tanstack/table-core').FilterFnOption<TData> | undefined;
+            onGlobalFilterChange?: import('@tanstack/table-core').OnChangeFn<any> | undefined;
+            enableMultiRemove?: boolean | undefined;
+            enableMultiSort?: boolean | undefined;
+            enableSorting?: boolean | undefined;
+            enableSortingRemoval?: boolean | undefined;
+            getSortedRowModel?: ((table: import('@tanstack/table-core').Table<any>) => () => import('@tanstack/table-core').RowModel<any>) | undefined;
+            isMultiSortEvent?: ((e: unknown) => boolean) | undefined;
+            manualSorting?: boolean | undefined;
+            maxMultiSortColCount?: number | undefined;
+            onSortingChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').SortingState> | undefined;
+            sortDescFirst?: boolean | undefined;
+            sortingFns?: Record<string, import('@tanstack/table-core').SortingFn<any>> | undefined;
+            enableGrouping?: boolean | undefined;
+            getGroupedRowModel?: ((table: import('@tanstack/table-core').Table<any>) => () => import('@tanstack/table-core').RowModel<any>) | undefined;
+            groupedColumnMode?: false | "reorder" | "remove" | undefined;
+            manualGrouping?: boolean | undefined;
+            onGroupingChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').GroupingState> | undefined;
+            aggregationFns?: Record<string, import('@tanstack/table-core').AggregationFn<any>> | undefined;
+            autoResetExpanded?: boolean | undefined;
+            enableExpanding?: boolean | undefined;
+            getExpandedRowModel?: ((table: import('@tanstack/table-core').Table<any>) => () => import('@tanstack/table-core').RowModel<any>) | undefined;
+            getIsRowExpanded?: ((row: import('@tanstack/table-core').Row<TData>) => boolean) | undefined;
+            getRowCanExpand?: ((row: import('@tanstack/table-core').Row<TData>) => boolean) | undefined;
+            manualExpanding?: boolean | undefined;
+            onExpandedChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').ExpandedState> | undefined;
+            paginateExpandedRows?: boolean | undefined;
+            columnResizeMode?: import('@tanstack/table-core').ColumnResizeMode | undefined;
+            enableColumnResizing?: boolean | undefined;
+            columnResizeDirection?: import('@tanstack/table-core').ColumnResizeDirection | undefined;
+            onColumnSizingChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').ColumnSizingState> | undefined;
+            onColumnSizingInfoChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').ColumnSizingInfoState> | undefined;
+            autoResetPageIndex?: boolean | undefined;
+            getPaginationRowModel?: ((table: import('@tanstack/table-core').Table<any>) => () => import('@tanstack/table-core').RowModel<any>) | undefined;
+            manualPagination?: boolean | undefined;
+            onPaginationChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').PaginationState> | undefined;
+            pageCount?: number | undefined;
+            rowCount?: number | undefined;
+            enableMultiRowSelection?: boolean | ((row: import('@tanstack/table-core').Row<TData>) => boolean) | undefined;
+            enableRowSelection?: boolean | ((row: import('@tanstack/table-core').Row<TData>) => boolean) | undefined;
+            enableSubRowSelection?: boolean | ((row: import('@tanstack/table-core').Row<TData>) => boolean) | undefined;
+            onRowSelectionChange?: import('@tanstack/table-core').OnChangeFn<import('@tanstack/table-core').RowSelectionState> | undefined;
+        } & {
+            isLoading?: boolean;
+            onRowClick?: ((row: TData) => void) | undefined;
+            rowHref?: ((row: TData) => string) | undefined;
+            linkComponent?: import('react').ElementType;
+        }>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    ToolBar: {
+        ({ children }: import('react').PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Table: {
+        ({ children, size, sticky, embed, enclosed }: {
+            size?: import('./table').TableRootProps["size"];
+            sticky?: import('./table').TableRootProps["sticky"];
+            embed?: import('./table').TableRootProps["embed"];
+            enclosed?: import('./table').TableRootProps["enclosed"];
+        } & {
+            children?: import('react').ReactNode | undefined;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        ({ children }: import('react').PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Pagination: {
+        (props: import('../pagination').PaginationProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};

package/src/data-table/index.js

@@ -1,3 +1,22 @@
-import { Table as e, tableRecipe as t } from "./table.js";
-import { DataTable as n, useDataTable as r } from "./data-table.js";
-export { n as DataTable, e as Table, t as tableRecipe, r as useDataTable };
+import { TableBody as e, TableCell as t, TableExpandButton as n, TableExpandedRow as r, TableHead as i, TableHeader as a, TableRoot as o, TableRow as s, TableRowActions as c, tableRecipe as l } from "./table.js";
+import { DataTablePagination as u, DataTableTable as d, Footer as f, Root as p, ToolBar as m, useDataTable as h } from "./data-table.js";
+//#region src/data-table/index.ts
+var g = {
+	Root: o,
+	Head: i,
+	Body: e,
+	Row: s,
+	Header: a,
+	Cell: t,
+	ExpandButton: n,
+	ExpandedRow: r,
+	RowActions: c
+}, _ = {
+	Root: p,
+	ToolBar: m,
+	Table: d,
+	Footer: f,
+	Pagination: u
+};
+//#endregion
+export { _ as DataTable, g as Table, l as tableRecipe, h as useDataTable };