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

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,14 +39,14 @@ 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;
+  getRowTone?: ((row: TData) => "negative" | "warning" | undefined) | undefined;
 }
 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 {
@@ -54,8 +54,8 @@ export declare namespace DataTableBody {
 }
 export interface DataTableEmptyBodyProps {
   children?: React.ReactNode;
-  colSpan?: number;
-  className?: string;
+  colSpan?: number | undefined;
+  className?: string | undefined;
 }
 /**
  * Empty state component for data tables.
@@ -86,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 {
@@ -103,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 {
@@ -123,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

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

@@ -8,20 +8,20 @@ export interface DataTableContainerProps extends React.AriaAttributes {
    * and applied as inline styles to ensure scroll event callbacks work reliably.
    * For other height utilities, use the height/maxHeight props directly.
    */
-  className?: string;
+  className?: string | undefined;
   /**
    * Sets the height of the table container.
    * When provided, enables vertical scrolling and allows DataTableBody/DataTableVirtualizedBody
    * to use onScroll, onScrolledTop, and onScrolledBottom callbacks.
    * Takes precedence over height utilities in className.
    */
-  height?: number | string;
+  height?: number | string | undefined;
   /**
    * Sets the maximum height of the table container.
    * Defaults to the height value if not specified.
    * Takes precedence over max-height utilities in className.
    */
-  maxHeight?: number | string;
+  maxHeight?: number | string | undefined;
 }
 export declare function DataTable({ children, className, height, maxHeight, "aria-label": label, "aria-labelledby": labelledBy }: DataTableContainerProps): React.JSX.Element;
 export declare namespace DataTable {

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

@@ -2,25 +2,25 @@ import React from "react";
 //#region src/components/registry/niko-table/filters/table-column-actions.d.ts
 export interface TableColumnActionsProps {
   children: React.ReactNode;
-  className?: string;
+  className?: string | undefined;
   /**
    * Optional label shown at the top of the dropdown.
    * @default "Column Actions"
    */
-  label?: string;
+  label?: string | undefined;
   /**
    * Whether to show a visual indicator when actions are active.
    */
-  isActive?: boolean;
+  isActive?: boolean | undefined;
   /**
    * Custom trigger element. If not provided, uses a MoreVertical icon button.
    */
-  trigger?: React.ReactElement;
+  trigger?: React.ReactElement | undefined;
   /**
    * Alignment of the dropdown content.
    * @default "end"
    */
-  align?: "start" | "center" | "end";
+  align?: "start" | "center" | "end" | undefined;
 }
 /**
  * A simple dropdown container for composing column actions.

package/dist/components/registry/niko-table/filters/table-column-sort.d.ts

@@ -15,10 +15,10 @@ import { RowData } from "@tanstack/react-table";
  */
 export declare function TableColumnSortOptions<TData extends RowData, TValue>({ column, table: propTable, variant: propVariant, withSeparator }: {
   column: DataTableColumn<TData, TValue>;
-  table?: DataTableInstance<TData>;
-  variant?: SortIconVariant;
+  table?: DataTableInstance<TData> | undefined;
+  variant?: SortIconVariant | undefined;
   /** Whether to render a separator before the options. @default true */
-  withSeparator?: boolean;
+  withSeparator?: boolean | undefined;
 }): React.JSX.Element;
 export declare namespace TableColumnSortOptions {
   var displayName: string;
@@ -41,9 +41,9 @@ export declare namespace TableColumnSortOptions {
  */
 export declare function TableColumnSortMenu<TData extends RowData, TValue>({ column, table: propTable, variant: propVariant, className }: {
   column: DataTableColumn<TData, TValue>;
-  table?: DataTableInstance<TData>;
-  variant?: SortIconVariant;
-  className?: string;
+  table?: DataTableInstance<TData> | undefined;
+  variant?: SortIconVariant | undefined;
+  className?: string | undefined;
 }): React.JSX.Element | null;
 export declare namespace TableColumnSortMenu {
   var displayName: string;

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

@@ -7,8 +7,8 @@ import { RowData } from "@tanstack/react-table";
  */
 export declare function TableColumnTitle<TData extends RowData, TValue>({ column, title, className, children }: {
   column: DataTableColumn<TData, TValue>;
-  title?: string;
-  className?: string;
+  title?: string | undefined;
+  className?: string | undefined;
   children?: React.ReactNode;
 }): React.JSX.Element;
 export declare namespace TableColumnTitle {

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

@@ -3,24 +3,24 @@ import * as React$1 from "react";
 import { RowData } from "@tanstack/react-table";
 //#region src/components/registry/niko-table/filters/table-faceted-filter.d.ts
 export interface TableFacetedFilterProps<TData extends RowData, TValue> {
-  column?: DataTableColumn<TData, TValue>;
-  title?: string;
+  column?: DataTableColumn<TData, TValue> | undefined;
+  title?: string | undefined;
   options: Option[];
-  multiple?: boolean;
+  multiple?: boolean | undefined;
   /**
    * Callback fired when filter value changes
    * Useful for server-side filtering or external state management
    */
-  onValueChange?: (value: string[] | undefined) => void;
+  onValueChange?: ((value: string[] | undefined) => void) | undefined;
   /**
    * Optional custom trigger element
    */
-  trigger?: React$1.ReactElement;
+  trigger?: React$1.ReactElement | undefined;
 }
 export declare function useTableFacetedFilter<TData extends RowData, TValue = unknown>({ column, onValueChange, multiple }: {
-  column?: DataTableColumn<TData, TValue>;
-  onValueChange?: (value: string[] | undefined) => void;
-  multiple?: boolean;
+  column?: DataTableColumn<TData, TValue> | undefined;
+  onValueChange?: ((value: string[] | undefined) => void) | undefined;
+  multiple?: boolean | undefined;
 }): {
   selectedValues: Set<any>;
   onItemSelect: (option: Option, isSelected: boolean) => void;
@@ -31,7 +31,7 @@ export declare namespace TableFacetedFilter {
   var displayName: string;
 }
 export declare function TableFacetedFilterContent({ title, options, selectedValues, onItemSelect, onReset }: {
-  title?: string;
+  title?: string | undefined;
   options: Option[];
   selectedValues: Set<string>;
   onItemSelect: (option: Option, isSelected: boolean) => void;

package/dist/components/registry/niko-table/filters/table-search-filter.d.ts

@@ -4,13 +4,13 @@ import { RowData } from "@tanstack/react-table";
 //#region src/components/registry/niko-table/filters/table-search-filter.d.ts
 export interface TableSearchFilterProps<TData extends RowData> {
   table: DataTableInstance<TData>;
-  className?: string;
-  placeholder?: string;
+  className?: string | undefined;
+  placeholder?: string | undefined;
   /** The field's accessible name, such as "Filter holdings". */
-  label?: string;
-  showClearButton?: boolean;
-  onChange?: (value: string) => void;
-  value?: string;
+  label?: string | undefined;
+  showClearButton?: boolean | undefined;
+  onChange?: ((value: string) => void) | undefined;
+  value?: string | undefined;
   /**
    * Debounce ms before pushing the typed value into table state. The
    * input reflects keystrokes immediately; only the call to
@@ -29,7 +29,7 @@ export interface TableSearchFilterProps<TData extends RowData> {
    *
    * @default 0
    */
-  debounceMs?: number;
+  debounceMs?: number | undefined;
 }
 export declare function TableSearchFilter<TData extends RowData>({ table, className, placeholder, label, showClearButton, onChange, value, debounceMs }: TableSearchFilterProps<TData>): React$1.JSX.Element;
 export declare namespace TableSearchFilter {