@siyahi/ui 0.1.9-next.31 → 0.1.9-next.33

package/dist/components/registry/heatmap/weekday-heatmap.d.ts

@@ -20,43 +20,43 @@ export type WeekdayExtraColumnSpec = {
   compute: (data: WeekdayHourlyActivity[]) => number[];
 };
 export type WeekdayHeatmapLabels = {
-  hours?: string[];
-  endHour?: string | null;
-  weekdays?: string[];
-  stat?: string;
-  cellLabel?: string;
-  heatmapLabel?: string;
-  legendLabel?: string;
-  legendLevelLabel?: string;
+  hours?: string[] | undefined;
+  endHour?: string | null | undefined;
+  weekdays?: string[] | undefined;
+  stat?: string | undefined;
+  cellLabel?: string | undefined;
+  heatmapLabel?: string | undefined;
+  legendLabel?: string | undefined;
+  legendLevelLabel?: string | undefined;
 };
 export type ColorConfig = {
-  empty?: string;
-  scale?: string;
+  empty?: string | undefined;
+  scale?: string | undefined;
 };
 export type WeekdayHeatmapProps = HTMLAttributes<HTMLDivElement> & {
   data: WeekdayHourlyActivity[];
-  weekStart?: Day;
+  weekStart?: Day | undefined;
   /** Displayed hours, in order; defaults to the full day. */
-  hours?: readonly WeekdayHour[];
+  hours?: readonly WeekdayHour[] | undefined;
   /** Displayed days, in order; defaults to the full week from weekStart. */
-  weekdays?: readonly WeekdayIndex[];
-  use12Hour?: boolean;
-  blockSize?: number;
-  blockMargin?: number;
-  blockRadius?: number;
-  blockAspectRatio?: number;
-  levels?: number;
-  isNormalized?: boolean;
-  colors?: ColorConfig;
-  locale?: Locale;
-  labels?: WeekdayHeatmapLabels;
-  fontSize?: number;
+  weekdays?: readonly WeekdayIndex[] | undefined;
+  use12Hour?: boolean | undefined;
+  blockSize?: number | undefined;
+  blockMargin?: number | undefined;
+  blockRadius?: number | undefined;
+  blockAspectRatio?: number | undefined;
+  levels?: number | undefined;
+  isNormalized?: boolean | undefined;
+  colors?: ColorConfig | undefined;
+  locale?: Locale | undefined;
+  labels?: WeekdayHeatmapLabels | undefined;
+  fontSize?: number | undefined;
   emptyState?: ReactNode;
-  totalCount?: number;
-  extraRow?: WeekdayExtraRowSpec;
-  extraColumn?: WeekdayExtraColumnSpec;
-  style?: CSSProperties;
-  className?: string;
+  totalCount?: number | undefined;
+  extraRow?: WeekdayExtraRowSpec | undefined;
+  extraColumn?: WeekdayExtraColumnSpec | undefined;
+  style?: CSSProperties | undefined;
+  className?: string | undefined;
   children: ReactNode;
 };
 /**
@@ -93,58 +93,58 @@ export type WeekdayHeatmapProps = HTMLAttributes<HTMLDivElement> & {
 export declare const WeekdayHeatmap: ({ data, weekStart, hours, weekdays: displayedWeekdays, use12Hour, blockSize: blockSizeProp, blockMargin, blockRadius, blockAspectRatio, levels: levelsProp, isNormalized, colors, locale, labels: labelsProp, fontSize, emptyState, totalCount: totalCountProp, extraRow, extraColumn, style, className, children, ...props }: WeekdayHeatmapProps) => string | number | bigint | true | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null;
 export type WeekdayHeatmapBlockProps = HTMLAttributes<SVGRectElement> & {
   /** The cell the page has picked: drawn with a ring and announced as pressed. */
-  selected?: boolean;
+  selected?: boolean | undefined;
   activity: WeekdayHourlyActivityWithLevel;
-  extra?: "row" | "column";
-  highlighted?: boolean;
-  onCellClick?: (activity: WeekdayHourlyActivityWithLevel) => void;
-  onCellHover?: (activity: WeekdayHourlyActivityWithLevel | null) => void;
-  className?: string;
+  extra?: "row" | "column" | undefined;
+  highlighted?: boolean | undefined;
+  onCellClick?: ((activity: WeekdayHourlyActivityWithLevel) => void) | undefined;
+  onCellHover?: ((activity: WeekdayHourlyActivityWithLevel | null) => void) | undefined;
+  className?: string | undefined;
 };
 export declare function WeekdayHeatmapBlock({ ref, activity, extra, highlighted, selected, onCellClick, onCellHover, onClick, onKeyDown, onMouseEnter, onMouseLeave, className, style: styleProp, ...props }: WeekdayHeatmapBlockProps & {
-  ref?: React.RefObject<SVGRectElement | null>;
+  ref?: React.RefObject<SVGRectElement | null> | undefined;
 }): import("react").JSX.Element | null;
 export declare namespace WeekdayHeatmapBlock {
   var displayName: string;
 }
 export type WeekdayHeatmapBodyProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
-  hideHourLabels?: boolean;
-  hideWeekdayLabels?: boolean;
-  className?: string;
-  labelClassName?: string;
+  hideHourLabels?: boolean | undefined;
+  hideWeekdayLabels?: boolean | undefined;
+  className?: string | undefined;
+  labelClassName?: string | undefined;
   children: (props: {
     activity: WeekdayHourlyActivityWithLevel;
     weekdayIndex: number;
   }) => ReactNode;
-  renderExtraRow?: (props: {
+  renderExtraRow?: ((props: {
     activity: WeekdayHourlyActivityWithLevel;
     weekdayIndex: number;
-  }) => ReactNode;
-  renderExtraColumn?: (props: {
+  }) => ReactNode) | undefined;
+  renderExtraColumn?: ((props: {
     activity: WeekdayHourlyActivityWithLevel;
     weekdayIndex: number;
-  }) => ReactNode;
+  }) => ReactNode) | undefined;
 };
 export declare const WeekdayHeatmapBody: ({ hideHourLabels, hideWeekdayLabels, className, labelClassName, children, renderExtraRow, renderExtraColumn, ...props }: WeekdayHeatmapBodyProps) => import("react").JSX.Element;
 export type WeekdayHeatmapFooterProps = HTMLAttributes<HTMLDivElement>;
 export declare const WeekdayHeatmapFooter: ({ className, ...props }: WeekdayHeatmapFooterProps) => import("react").JSX.Element;
 export type WeekdayHeatmapStatProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
-  compute?: (data: WeekdayHourlyActivityWithLevel[]) => number | string;
-  label?: string;
-  children?: (result: {
+  compute?: ((data: WeekdayHourlyActivityWithLevel[]) => number | string) | undefined;
+  label?: string | undefined;
+  children?: ((result: {
     value: number | string;
     data: WeekdayHourlyActivityWithLevel[];
-  }) => ReactNode;
+  }) => ReactNode) | undefined;
 };
 export declare const WeekdayHeatmapStat: ({ compute, label, className, children, ...props }: WeekdayHeatmapStatProps) => import("react").JSX.Element;
 export type WeekdayHeatmapLegendProps = Omit<HTMLAttributes<HTMLFieldSetElement>, "children"> & {
   labels?: {
-    less?: string;
-    more?: string;
-  };
-  children?: (props: {
+    less?: string | undefined;
+    more?: string | undefined;
+  } | undefined;
+  children?: ((props: {
     level: number;
-  }) => ReactNode;
+  }) => ReactNode) | undefined;
 };
 export declare const WeekdayHeatmapLegend: ({ labels: labelsProp, className, children, ...props }: WeekdayHeatmapLegendProps) => import("react").JSX.Element;
 //#endregion

package/dist/components/registry/minidev/copy-button.d.ts

@@ -4,8 +4,8 @@ import { VariantProps } from "class-variance-authority";
 //#region src/components/registry/minidev/copy-button.d.ts
 declare function CopyButton({ value, className, variant, size, label, copiedLabel, ...props }: {
   value: string;
-  label?: string;
-  copiedLabel?: string;
+  label?: string | undefined;
+  copiedLabel?: string | undefined;
 } & React$1.ComponentProps<"button"> & VariantProps<typeof buttonVariants>): React$1.JSX.Element;
 //#endregion
 export { CopyButton };

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

@@ -18,7 +18,7 @@ import { RowData } from "@tanstack/react-table";
  */
 export declare function DataTableColumnActions<TData extends RowData, TValue>(props: Omit<React.ComponentProps<typeof TableColumnActions>, "isActive"> & {
   /** Override to manually set active state */
-  isActive?: boolean;
+  isActive?: boolean | undefined;
 }): React.JSX.Element;
 export declare namespace DataTableColumnActions {
   var displayName: string;

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

@@ -5,7 +5,7 @@ import React from "react";
  */
 export declare function DataTableColumnFilter({ children, className }: {
   children?: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }): React.JSX.Element | null;
 export declare namespace DataTableColumnFilter {
   var displayName: string;

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

@@ -3,7 +3,7 @@ import React from "react";
 export interface DataTableEmptyStateProps {
   children: React.ReactNode;
   isFiltered: boolean;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Root component for empty state composition.
@@ -14,7 +14,7 @@ export interface DataTableEmptyStateProps {
 export declare function DataTableEmptyState({ children, isFiltered, className }: DataTableEmptyStateProps): React.JSX.Element;
 export interface DataTableEmptyIconProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Icon component for empty state. Memoized so table-state changes don't re-render it.
@@ -27,7 +27,7 @@ export interface DataTableEmptyIconProps {
 export declare const DataTableEmptyIcon: React.MemoExoticComponent<({ children, className }: DataTableEmptyIconProps) => React.JSX.Element>;
 export interface DataTableEmptyMessageProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Message component for empty state. Memoized; renders only when not filtered.
@@ -43,7 +43,7 @@ export interface DataTableEmptyMessageProps {
 export declare const DataTableEmptyMessage: React.MemoExoticComponent<({ children, className }: DataTableEmptyMessageProps) => React.JSX.Element | null>;
 export interface DataTableEmptyFilteredMessageProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Filtered-state message — renders only when a filter is active. Memoized.
@@ -56,7 +56,7 @@ export interface DataTableEmptyFilteredMessageProps {
 export declare const DataTableEmptyFilteredMessage: React.MemoExoticComponent<({ children, className }: DataTableEmptyFilteredMessageProps) => React.JSX.Element | null>;
 export interface DataTableEmptyActionsProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Actions component for empty state.
@@ -71,7 +71,7 @@ export interface DataTableEmptyActionsProps {
 export declare const DataTableEmptyActions: React.MemoExoticComponent<({ children, className }: DataTableEmptyActionsProps) => React.JSX.Element>;
 export interface DataTableEmptyTitleProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Title component for empty state messages.
@@ -89,7 +89,7 @@ export interface DataTableEmptyTitleProps {
 export declare const DataTableEmptyTitle: React.MemoExoticComponent<({ children, className }: DataTableEmptyTitleProps) => React.JSX.Element>;
 export interface DataTableEmptyDescriptionProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Description component for empty state messages.

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

@@ -11,28 +11,28 @@ type DataTableFacetedFilterProps<TData extends RowData, TValue> = Omit<TableFace
   /**
    * Optional title override (if not provided, will use column.meta.label)
    */
-  title?: string;
+  title?: string | undefined;
   /**
    * Static options (if provided, will be used instead of dynamic generation)
    */
-  options?: Option[];
+  options?: Option[] | undefined;
   /**
    * Whether to show counts for each option
    * @default true
    */
-  showCounts?: boolean;
+  showCounts?: boolean | undefined;
   /**
    * Whether to update counts based on other active filters
    * @default true
    */
-  dynamicCounts?: boolean;
+  dynamicCounts?: boolean | undefined;
   /**
    * 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;
+  limitToFilteredRows?: boolean | undefined;
 };
 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 {

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

@@ -69,7 +69,7 @@ export interface DataTableGroupedRowsProps<TData extends RowData = RowData> {
    * row for that group. Table-level gating is better expressed by simply not
    * nesting this component.
    */
-  enabledFor?: (row: DataTableRow<TData>) => boolean;
+  enabledFor?: ((row: DataTableRow<TData>) => boolean) | undefined;
 }
 /**
  * Declarative, composable group rows for niko-table bodies.

package/dist/components/registry/niko-table/components/data-table-row-context-menu-slot.d.ts

@@ -19,7 +19,7 @@ export interface DataTableRowContextMenuSlotProps<TData extends RowData> {
    * menu (e.g. locked/browse-only rows). Table-level gating (e.g. "no manage
    * permission") is better done by simply not rendering the slot at all.
    */
-  enabledFor?: (row: TData) => boolean;
+  enabledFor?: ((row: TData) => boolean) | undefined;
 }
 /**
  * Declarative, composable row context menu for niko-table bodies.

package/dist/components/registry/niko-table/components/data-table-row-context-menu.d.ts

@@ -23,7 +23,7 @@ export interface DataTableRowContextMenuProps {
    */
   children: React$1.ReactNode;
   /** Extra className for the popup surface. */
-  className?: string;
+  className?: string | undefined;
 }
 /**
  * Attaches a right-click context menu to a single data-table row.

package/dist/components/registry/niko-table/config/feature-detection.d.ts

@@ -4,18 +4,18 @@ import { ReactNode } from "react";
  * Feature requirements that components can declare
  */
 export interface FeatureRequirements {
-  enableFilters?: boolean;
-  enablePagination?: boolean;
-  enableRowSelection?: boolean;
-  enableSorting?: boolean;
-  enableMultiSort?: boolean;
-  enableGrouping?: boolean;
-  enableExpanding?: boolean;
-  enableColumnResizing?: boolean;
-  manualSorting?: boolean;
-  manualPagination?: boolean;
-  manualFiltering?: boolean;
-  pageCount?: number;
+  enableFilters?: boolean | undefined;
+  enablePagination?: boolean | undefined;
+  enableRowSelection?: boolean | undefined;
+  enableSorting?: boolean | undefined;
+  enableMultiSort?: boolean | undefined;
+  enableGrouping?: boolean | undefined;
+  enableExpanding?: boolean | undefined;
+  enableColumnResizing?: boolean | undefined;
+  manualSorting?: boolean | undefined;
+  manualPagination?: boolean | undefined;
+  manualFiltering?: boolean | undefined;
+  pageCount?: number | undefined;
 }
 /**
  * Walks the React tree to aggregate feature requirements declared by child
@@ -23,7 +23,7 @@ export interface FeatureRequirements {
  */
 export declare function detectFeaturesFromChildren(children: ReactNode, columns?: Array<{
   header?: unknown;
-  enableColumnFilter?: boolean;
+  enableColumnFilter?: boolean | undefined;
 }>): FeatureRequirements;
 /**
  * Register a component's feature requirements

package/dist/components/registry/niko-table/core/data-table-context.d.ts

@@ -9,7 +9,7 @@ export type DataTableContextState = {
 export type ScrollAlign = "auto" | "start" | "center" | "end";
 /** Scroll a row into view by its position in the current row model. */
 export type ScrollRowIntoView = (index: number, opts?: {
-  align?: ScrollAlign;
+  align?: ScrollAlign | undefined;
 }) => void;
 /**
  * The active-selection SPAN for a grid-style cross-highlight — EVERY column
@@ -34,9 +34,9 @@ export interface ActiveSelection {
 export type ActiveCell = ActiveSelection | null;
 export interface FlashRowsOptions {
   /** How long the highlight lasts, ms. Default 1400. */
-  durationMs?: number;
+  durationMs?: number | undefined;
   /** Scroll the first flashed row into view first. Default true. */
-  scrollIntoView?: boolean;
+  scrollIntoView?: boolean | undefined;
 }
 /**
  * Briefly highlight rows (by id) so users see what just changed — e.g. after a
@@ -163,8 +163,8 @@ export interface CompactColumns {
 interface DataTableProviderProps<TData extends RowData> {
   children: React.ReactNode;
   table: DataTableInstance<TData>;
-  columns?: DataTableColumnDef<TData>[];
-  isLoading?: boolean;
+  columns?: DataTableColumnDef<TData>[] | undefined;
+  isLoading?: boolean | undefined;
   isCompact: boolean;
   onWidthChange: (width: number) => void;
   compactColumns: CompactColumns | null;

package/dist/components/registry/niko-table/core/data-table-error-boundary.d.ts

@@ -12,17 +12,17 @@ export interface DataTableErrorBoundaryProps {
   /**
    * Callback fired when an error is caught
    */
-  onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+  onError?: ((error: Error, errorInfo: React.ErrorInfo) => void) | undefined;
   /**
    * Whether to show a reset button
    * @default true
    */
-  showResetButton?: boolean;
+  showResetButton?: boolean | undefined;
   /**
    * Custom reset button text
    * @default "Try Again"
    */
-  resetButtonText?: string;
+  resetButtonText?: string | undefined;
 }
 interface DataTableErrorBoundaryState {
   hasError: boolean;

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

@@ -38,12 +38,12 @@ export interface GroupedBodyRowProps<TData extends RowData = RowData> {
    * usually a different height from a leaf row, so it has to be measured
    * rather than assumed — without this the rows below it drift.
    */
-  measureRef?: (node: HTMLTableRowElement | null) => void;
+  measureRef?: ((node: HTMLTableRowElement | null) => void) | undefined;
   /**
    * Virtualized bodies only: the row's index in the virtual window, which the
    * virtualizer reads back off the DOM as `data-index`.
    */
-  virtualIndex?: number;
+  virtualIndex?: number | undefined;
 }
 export declare const GroupedBodyRow: <TData extends RowData = RowData>(props: GroupedBodyRowProps<TData>) => React.JSX.Element;
 //#endregion

package/dist/components/registry/niko-table/core/data-table-root.d.ts

@@ -1,16 +1,17 @@
 import { DataTableFeatures } from "../lib/data-table-features.js";
 import { DataTableColumns, GlobalFilter } from "../types/index.js";
+import { Optional } from "../../../../lib/optional.js";
 import React from "react";
 import { ColumnFiltersState, ColumnOrderState, ColumnVisibilityState, ExpandedState, GroupingState, PaginationState, ReactTable, RowData, RowSelectionState, SortingState, TableOptions, Updater } from "@tanstack/react-table";
 //#region src/components/registry/niko-table/core/data-table-root.d.ts
 export interface DataTableConfig {
-  enablePagination?: boolean;
-  enableFilters?: boolean;
-  enableSorting?: boolean;
-  enableRowSelection?: boolean;
-  enableMultiSort?: boolean;
-  enableGrouping?: boolean;
-  enableExpanding?: boolean;
+  enablePagination?: boolean | undefined;
+  enableFilters?: boolean | undefined;
+  enableSorting?: boolean | undefined;
+  enableRowSelection?: boolean | undefined;
+  enableMultiSort?: boolean | undefined;
+  enableGrouping?: boolean | undefined;
+  enableExpanding?: boolean | undefined;
   /**
    * Enable drag-to-resize column widths (opt-in; off by default so existing
    * tables are unaffected). When on, columns render at `column.getSize()` and a
@@ -18,41 +19,41 @@ export interface DataTableConfig {
    * `<DataTableColumnResize />` inside the root to enable via feature detection.
    * Double-click a grip to autosize; columns opt out with `enableResizing: false`.
    */
-  enableColumnResizing?: boolean;
+  enableColumnResizing?: boolean | undefined;
   /**
    * When grouping is active, how grouped columns are placed in the column flow.
    * TanStack default: `'reorder'` (move grouped columns to the start).
    * `'remove'` hides them; `false` leaves them in place.
    */
-  groupedColumnMode?: false | "reorder" | "remove";
-  manualSorting?: boolean;
-  manualPagination?: boolean;
-  manualFiltering?: boolean;
-  pageCount?: number;
-  initialPageSize?: number;
-  initialPageIndex?: number;
-  autoResetPageIndex?: boolean;
-  autoResetExpanded?: boolean;
+  groupedColumnMode?: false | "reorder" | "remove" | undefined;
+  manualSorting?: boolean | undefined;
+  manualPagination?: boolean | undefined;
+  manualFiltering?: boolean | undefined;
+  pageCount?: number | undefined;
+  initialPageSize?: number | undefined;
+  initialPageIndex?: number | undefined;
+  autoResetPageIndex?: boolean | undefined;
+  autoResetExpanded?: boolean | undefined;
 }
-interface TableRootProps<TData extends RowData> extends Omit<Partial<TableOptions<DataTableFeatures, TData>>, "columns" | "data" | "getRowId" | "key"> {
-  table?: ReactTable<DataTableFeatures, TData>;
-  columns?: DataTableColumns<TData>;
-  data?: TData[];
+interface TableRootProps<TData extends RowData> extends Omit<Optional<TableOptions<DataTableFeatures, TData>>, "columns" | "data" | "getRowId" | "key"> {
+  table?: ReactTable<DataTableFeatures, TData> | undefined;
+  columns?: DataTableColumns<TData> | undefined;
+  data?: TData[] | undefined;
   children: React.ReactNode;
-  className?: string;
-  config?: DataTableConfig;
-  getRowId?: (originalRow: TData, index: number) => string;
-  isLoading?: boolean;
-  onGlobalFilterChange?: (value: GlobalFilter) => void;
-  onPaginationChange?: (updater: Updater<PaginationState>) => void;
-  onSortingChange?: (updater: Updater<SortingState>) => void;
-  onColumnVisibilityChange?: (updater: Updater<ColumnVisibilityState>) => void;
-  onColumnFiltersChange?: (updater: Updater<ColumnFiltersState>) => void;
-  onRowSelectionChange?: (updater: Updater<RowSelectionState>) => void;
-  onExpandedChange?: (updater: Updater<ExpandedState>) => void;
-  onGroupingChange?: (updater: Updater<GroupingState>) => void;
-  onColumnOrderChange?: (updater: Updater<ColumnOrderState>) => void;
-  onRowSelection?: (selectedRows: TData[]) => void;
+  className?: string | undefined;
+  config?: DataTableConfig | undefined;
+  getRowId?: ((originalRow: TData, index: number) => string) | undefined;
+  isLoading?: boolean | undefined;
+  onGlobalFilterChange?: ((value: GlobalFilter) => void) | undefined;
+  onPaginationChange?: ((updater: Updater<PaginationState>) => void) | undefined;
+  onSortingChange?: ((updater: Updater<SortingState>) => void) | undefined;
+  onColumnVisibilityChange?: ((updater: Updater<ColumnVisibilityState>) => void) | undefined;
+  onColumnFiltersChange?: ((updater: Updater<ColumnFiltersState>) => void) | undefined;
+  onRowSelectionChange?: ((updater: Updater<RowSelectionState>) => void) | undefined;
+  onExpandedChange?: ((updater: Updater<ExpandedState>) => void) | undefined;
+  onGroupingChange?: ((updater: Updater<GroupingState>) => void) | undefined;
+  onColumnOrderChange?: ((updater: Updater<ColumnOrderState>) => void) | undefined;
+  onRowSelection?: ((selectedRows: TData[]) => void) | undefined;
 }
 export declare function DataTableRoot<TData extends RowData>({ table: externalTable, columns, data, children, className, isLoading, ...rest }: TableRootProps<TData>): React.JSX.Element;
 export declare namespace DataTableRoot {

package/dist/components/registry/niko-table/core/data-table-structure.d.ts

@@ -3,21 +3,21 @@ import React from "react";
 import { RowData } from "@tanstack/react-table";
 //#region src/components/registry/niko-table/core/data-table-structure.d.ts
 export interface DataTableHeaderProps {
-  className?: string;
+  className?: string | undefined;
   /**
    * Makes the header sticky at the top when scrolling.
    * @default true
    */
-  sticky?: boolean;
+  sticky?: boolean | undefined;
 }
 export declare const DataTableHeader: React.MemoExoticComponent<({ className, sticky }: DataTableHeaderProps) => React.JSX.Element | null>;
 export interface DataTableBodyProps<TData extends RowData> {
   children?: React.ReactNode;
-  className?: string;
-  onScroll?: (event: ScrollEvent) => void;
-  onScrolledTop?: () => void;
-  onScrolledBottom?: () => void;
-  scrollThreshold?: number;
+  className?: string | undefined;
+  onScroll?: ((event: ScrollEvent) => void) | undefined;
+  onScrolledTop?: (() => void) | undefined;
+  onScrolledBottom?: (() => void) | undefined;
+  scrollThreshold?: number | undefined;
   /**
    * Click is dispatched per-row from each cell's onClick. The event's
    * `currentTarget` is the `<td>` cell — typed as `HTMLElement` to
@@ -25,12 +25,12 @@ export interface DataTableBodyProps<TData extends RowData> {
    * `<tbody>`). Consumers needing the row element can
    * `event.target.closest("tr[data-row-id]")`.
    */
-  onRowClick?: (row: TData, event: React.MouseEvent<HTMLElement>) => void;
+  onRowClick?: ((row: TData, event: React.MouseEvent<HTMLElement>) => void) | undefined;
   /**
    * Return a per-row memo invalidation key. When this key changes for a
    * specific row, only that row re-renders.
    */
-  getRowMemoKey?: (row: TData) => string;
+  getRowMemoKey?: ((row: TData) => string) | undefined;
   /**
    * Attach a native right-click context menu to each row. Return the menu
    * items (`ContextMenuItem`, `ContextMenuSeparator`, `ContextMenuSub`, …)
@@ -39,16 +39,23 @@ export interface DataTableBodyProps<TData extends RowData> {
    *
    * Wrap the callback in `useCallback` so memoized rows don't re-render.
    */
-  renderRowContextMenu?: (row: TData) => React.ReactNode;
+  renderRowContextMenu?: ((row: TData) => React.ReactNode) | undefined;
+  /**
+   * Mark the row that needs a look, such as a holding in deep loss: return
+   * `"negative"` or `"warning"` and the row takes a faint wash of that
+   * colour, as a `TableRow` with `data-tone` does; `undefined` leaves it
+   * plain. The page decides, never the sign. Mark one or two rows.
+   */
+  getRowTone?: ((row: TData) => "negative" | "warning" | undefined) | undefined;
 }
-export declare function DataTableBody<TData extends RowData>({ children, className, onScroll, onScrolledTop, onScrolledBottom, scrollThreshold, onRowClick, getRowMemoKey, renderRowContextMenu }: DataTableBodyProps<TData>): React.JSX.Element;
+export declare function DataTableBody<TData extends RowData>({ children, className, onScroll, onScrolledTop, onScrolledBottom, scrollThreshold, onRowClick, getRowMemoKey, renderRowContextMenu, getRowTone }: DataTableBodyProps<TData>): React.JSX.Element;
 export declare namespace DataTableBody {
   var displayName: string;
 }
 export interface DataTableEmptyBodyProps {
   children?: React.ReactNode;
-  colSpan?: number;
-  className?: string;
+  colSpan?: number | undefined;
+  className?: string | undefined;
 }
 /**
  * Empty state component for data tables.
@@ -79,16 +86,16 @@ export declare namespace DataTableEmptyBody {
 }
 export interface DataTableSkeletonProps {
   children?: React.ReactNode;
-  colSpan?: number;
+  colSpan?: number | undefined;
   /**
    * Number of skeleton rows to display.
    * @default 5
    * @recommendation Set this to match your page size for better UX (e.g., if page size is 10, set rows={10})
    */
-  rows?: number;
-  className?: string;
-  cellClassName?: string;
-  skeletonClassName?: string;
+  rows?: number | undefined;
+  className?: string | undefined;
+  cellClassName?: string | undefined;
+  skeletonClassName?: string | undefined;
 }
 export declare function DataTableSkeleton({ children, colSpan, rows, className, cellClassName, skeletonClassName }: DataTableSkeletonProps): React.JSX.Element | null;
 export declare namespace DataTableSkeleton {
@@ -96,8 +103,8 @@ export declare namespace DataTableSkeleton {
 }
 export interface DataTableLoadingProps {
   children?: React.ReactNode;
-  colSpan?: number;
-  className?: string;
+  colSpan?: number | undefined;
+  className?: string | undefined;
 }
 export declare function DataTableLoading({ children, colSpan, className }: DataTableLoadingProps): React.JSX.Element | null;
 export declare namespace DataTableLoading {
@@ -116,8 +123,8 @@ export interface DataTableLoadingMoreProps {
    * customize the label per-table (e.g. "Loading more venues…").
    */
   children?: React.ReactNode;
-  colSpan?: number;
-  className?: string;
+  colSpan?: number | undefined;
+  className?: string | undefined;
 }
 /**
  * Composable "loading more" row for infinite-scroll tables. Renders