@caffeinebounce/ui 0.62.3 → 0.63.0

package/dist/data-table-jLzt6plY.d.cts

@@ -0,0 +1,818 @@
+import { Table, VisibilityState, ColumnFiltersState, SortingState, Row, Column, RowData, ColumnSort, TableOptions, TableState, ColumnMeta } from '@tanstack/react-table';
+import * as nuqs_server from 'nuqs/server';
+import { z } from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import { c as ButtonProps } from './button-BHnoRUkF.cjs';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as _tanstack_table_core from '@tanstack/table-core';
+
+/**
+ * Props for DataTableAddButton
+ */
+interface DataTableAddButtonProps extends Omit<ButtonProps, "variant" | "size"> {
+    /** Label text to display (defaults to "Add") */
+    label?: string;
+    /** Custom icon to use instead of Plus */
+    icon?: React$1.ReactNode;
+    /** Hide label on small screens (responsive) */
+    responsiveLabel?: boolean;
+}
+/**
+ * Standardized "Add" button for DataTable headers.
+ *
+ * Provides a consistent styling pattern:
+ * - Ghost variant with muted text that highlights on hover
+ * - Small size with compact height (h-7)
+ * - Plus icon by default
+ * - Optional responsive label (hidden on small screens)
+ *
+ * @example
+ * ```tsx
+ * <DataTableTopper>
+ *   <DataTableViews ... />
+ *   <DataTableSearch ... />
+ *   <DataTableAddButton onClick={() => setShowDialog(true)} />
+ * </DataTableTopper>
+ * ```
+ *
+ * @example With custom label
+ * ```tsx
+ * <DataTableAddButton label="New User" onClick={handleAdd} />
+ * ```
+ *
+ * @example Non-responsive (always show label)
+ * ```tsx
+ * <DataTableAddButton label="Add" responsiveLabel={false} onClick={handleAdd} />
+ * ```
+ */
+declare function DataTableAddButton({ label, icon, responsiveLabel, className, children, ...props }: DataTableAddButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Options for CSV export
+ */
+interface ExportToCsvOptions<TData> {
+    /** TanStack Table instance */
+    table: Table<TData>;
+    /** Custom filename (without extension) */
+    filename?: string;
+    /** Whether to include only visible columns (default: true) */
+    visibleColumnsOnly?: boolean;
+    /** Whether to include only selected rows (default: false, exports all rows) */
+    selectedRowsOnly?: boolean;
+    /** Custom column headers mapping (columnId -> headerText) */
+    customHeaders?: Record<string, string>;
+    /** Column IDs to exclude from export */
+    excludeColumns?: string[];
+    /** Custom value formatter for specific columns */
+    formatters?: Record<string, (value: unknown) => string>;
+}
+/**
+ * Exports table data to CSV and triggers download
+ */
+declare function exportToCsv<TData>({ table, filename, visibleColumnsOnly, selectedRowsOnly, customHeaders, excludeColumns, formatters, }: ExportToCsvOptions<TData>): void;
+/**
+ * Options for Excel export
+ */
+interface ExportToExcelOptions<TData> {
+    /** TanStack Table instance */
+    table: Table<TData>;
+    /** Custom filename (without extension) */
+    filename?: string;
+    /** Whether to include only visible columns (default: true) */
+    visibleColumnsOnly?: boolean;
+    /** Whether to include only selected rows (default: false, exports all rows) */
+    selectedRowsOnly?: boolean;
+    /** Custom column headers mapping (columnId -> headerText) */
+    customHeaders?: Record<string, string>;
+    /** Column IDs to exclude from export */
+    excludeColumns?: string[];
+    /** Custom value formatter for specific columns */
+    formatters?: Record<string, (value: unknown) => string>;
+}
+/**
+ * Exports table data to Excel (XML Spreadsheet format) and triggers download
+ */
+declare function exportToExcel<TData>({ table, filename, visibleColumnsOnly, selectedRowsOnly, customHeaders, excludeColumns, formatters, }: ExportToExcelOptions<TData>): void;
+type ExportFormat = "csv" | "excel";
+interface DataTableExportButtonProps<TData = unknown> {
+    /**
+     * TanStack Table instance for built-in export.
+     * If provided, the component will handle CSV/Excel export automatically.
+     */
+    table?: Table<TData>;
+    /**
+     * Custom export callback for CSV. If provided (and table is not), this will be called instead.
+     * Should return a Promise that resolves when export is complete.
+     */
+    onExportCsv?: () => Promise<void>;
+    /**
+     * Custom export callback for Excel. If provided (and table is not), this will be called instead.
+     * Should return a Promise that resolves when export is complete.
+     */
+    onExportExcel?: () => Promise<void>;
+    /**
+     * @deprecated Use onExportCsv instead. Kept for backwards compatibility.
+     */
+    onExport?: () => Promise<void>;
+    /** Custom filename for export (without extension) */
+    filename?: string;
+    /** Label for the tooltip */
+    label?: string;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Whether to export only selected rows (default: false) */
+    selectedRowsOnly?: boolean;
+    /** Column IDs to exclude from export */
+    excludeColumns?: string[];
+    /** Custom column headers mapping (columnId -> headerText) */
+    customHeaders?: Record<string, string>;
+    /** Custom value formatters for specific columns */
+    formatters?: Record<string, (value: unknown) => string>;
+}
+/**
+ * Export dropdown button for DataTable with CSV and Excel options.
+ * Styled consistently with other DataTable topper buttons.
+ *
+ * @example Built-in export (CSV and Excel)
+ * ```tsx
+ * <DataTableExportButton
+ *   table={table}
+ *   filename="my-data"
+ *   excludeColumns={["actions"]}
+ * />
+ * ```
+ *
+ * @example Custom export handlers
+ * ```tsx
+ * <DataTableExportButton
+ *   onExportCsv={async () => { ... }}
+ *   onExportExcel={async () => { ... }}
+ * />
+ * ```
+ */
+declare function DataTableExportButton<TData = unknown>({ table, onExportCsv, onExportExcel, onExport, // deprecated, maps to CSV
+filename, label, disabled, selectedRowsOnly, excludeColumns, customHeaders, formatters, }: DataTableExportButtonProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableRowAction$1 {
+    /** Label for the action */
+    label: string;
+    /** Icon component to display */
+    icon?: React$1.ReactNode;
+    /** Callback when action is clicked */
+    onClick: () => void;
+    /** Whether the action is destructive (shows in red on hover) */
+    destructive?: boolean;
+    /** Whether the action is a success action (shows in green on hover) */
+    success?: boolean;
+    /** Whether the action is active/enabled (shows green, goes muted on hover) */
+    successActive?: boolean;
+    /** Whether to show separator before this action */
+    separatorBefore?: boolean;
+    /** Whether the action is disabled */
+    disabled?: boolean;
+}
+interface DataTableRowActionsProps {
+    /** Array of actions to display */
+    actions: DataTableRowAction$1[];
+    /**
+     * Display mode for actions:
+     * - "dropdown": Always show as dropdown menu (default, original behavior)
+     * - "inline": Always show as inline icon buttons
+     * - "responsive": Show inline buttons on larger screens, dropdown on mobile
+     */
+    mode?: "dropdown" | "inline" | "responsive";
+}
+/**
+ * Row actions component with multiple display modes.
+ *
+ * Modes:
+ * - "dropdown": Always shows as ellipsis dropdown menu (original behavior)
+ * - "inline": Always shows icon buttons inline with tooltips
+ * - "responsive": Shows inline on larger screens, collapses to dropdown on mobile
+ *
+ * @example Dropdown mode (default)
+ * ```tsx
+ * <DataTableRowActions actions={actions} />
+ * ```
+ *
+ * @example Responsive mode
+ * ```tsx
+ * <DataTableRowActions actions={actions} mode="responsive" />
+ * ```
+ *
+ * @example Inline mode
+ * ```tsx
+ * <DataTableRowActions actions={actions} mode="inline" />
+ * ```
+ */
+declare function DataTableRowActions({ actions, mode, }: DataTableRowActionsProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Expandable search input for the data table.
+ * Starts as a search icon and expands into a full input on click.
+ */
+declare function DataTableSearch({ searchValue, searchPlaceholder, onSearchChange, className, }: {
+    searchValue?: string;
+    searchPlaceholder?: string;
+    onSearchChange?: (value: string) => void;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+/** Summary calculation type */
+type SummaryType = "none" | "count" | "count_unique" | "sum" | "average" | "median" | "min" | "max" | "range" | "percent_empty" | "percent_filled";
+/** Column type for determining available summaries */
+type ColumnDataType = "text" | "number" | "boolean" | "date";
+/** Summary configuration for a column */
+interface ColumnSummaryConfig {
+    /** Column ID */
+    columnId: string;
+    /** Active summary type */
+    type: SummaryType;
+}
+interface DataTableSummaryProps<TData> {
+    /** TanStack Table instance */
+    table: Table<TData>;
+    /** All data (not just current page) for accurate calculations */
+    allData: TData[];
+    /** Summary configuration per column */
+    summaryConfig: Record<string, SummaryType>;
+    /** Callback when summary type changes */
+    onSummaryChange: (columnId: string, type: SummaryType) => void;
+    /** Get the data type of a column (for showing appropriate options) */
+    getColumnDataType?: (columnId: string) => ColumnDataType;
+    /** Width of gutter column (for alignment with DataTable gutter) */
+    gutterWidth?: number;
+    /** Optional class name */
+    className?: string;
+}
+/**
+ * DataTable Summary row component.
+ * Displays calculated statistics for each column below the table.
+ *
+ * Features:
+ * - Count (with null/undefined excluded)
+ * - Sum, Average, Median, Min, Max for numeric columns
+ * - Unique count for text columns
+ * - Percent empty/filled
+ * - Click to change summary type
+ */
+declare function DataTableSummary<TData>({ table, allData, summaryConfig, onSummaryChange, getColumnDataType, gutterWidth, className, }: DataTableSummaryProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableTab {
+    /** Unique identifier for the tab */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional count badge */
+    count?: number;
+}
+interface DataTableTopperProps extends React$1.ComponentProps<"div"> {
+    /** Tabs to display on the left side */
+    tabs?: DataTableTab[];
+    /** Currently active tab ID */
+    activeTab?: string;
+    /** Callback when tab changes */
+    onTabChange?: (tabId: string) => void;
+    /** Gutter width for left offset (aligns with DataTable gutter) */
+    gutterWidth?: number;
+}
+/**
+ * The DataTable Topper - a full-width header bar that combines:
+ * - Tabs on the left (for filtering views)
+ * - Actions on the right (search, view options, etc.)
+ *
+ * This component is decoupled from table width - it always spans
+ * the full container width while the table can scroll independently.
+ *
+ * @example
+ * ```tsx
+ * <DataTableTopper
+ *   tabs={[
+ *     { id: "all", label: "All", count: 100 },
+ *     { id: "active", label: "Active", count: 45 },
+ *   ]}
+ *   activeTab="all"
+ *   onTabChange={setActiveTab}
+ * >
+ *   <DataTableSearch ... />
+ *   <DataTableViewOptions ... />
+ * </DataTableTopper>
+ * ```
+ */
+declare function DataTableTopper({ tabs, activeTab, onTabChange, gutterWidth, className, children, ...props }: DataTableTopperProps): react_jsx_runtime.JSX.Element;
+
+/** Represents a saved table view configuration */
+interface DataTableView {
+    /** Unique identifier */
+    id: string;
+    /** Display name for the view */
+    name: string;
+    /** Column visibility state */
+    columnVisibility?: VisibilityState;
+    /** Column order (array of column IDs) */
+    columnOrder?: string[];
+    /** Column wrapping state (map of column ID to wrap boolean) */
+    columnWrapping?: Record<string, boolean>;
+    /** Row order (array of row IDs) - for custom row ordering */
+    rowOrder?: string[];
+    /** Active filters */
+    filters?: ColumnFiltersState;
+    /** Sorting state */
+    sorting?: SortingState;
+    /** Whether this is the default view */
+    isDefault?: boolean;
+    /** When the view was created */
+    createdAt?: string;
+    /** When the view was last updated */
+    updatedAt?: string;
+}
+/** Current table state that can be compared to a view */
+interface DataTableViewState {
+    columnVisibility?: VisibilityState;
+    columnOrder?: string[];
+    columnWrapping?: Record<string, boolean>;
+    rowOrder?: string[];
+    filters?: ColumnFiltersState;
+    sorting?: SortingState;
+}
+interface DataTableViewsProps {
+    /** List of saved views */
+    views: DataTableView[];
+    /** Currently active view ID */
+    activeViewId?: string;
+    /** Current table state */
+    currentState: DataTableViewState;
+    /** Callback when a view is selected */
+    onSelectView: (view: DataTableView) => void;
+    /** Callback to save a new view */
+    onSaveView?: (view: Omit<DataTableView, "id" | "createdAt" | "updatedAt">) => void;
+    /** Callback to update an existing view */
+    onUpdateView?: (id: string, updates: Partial<DataTableView>) => void;
+    /** Callback to delete a view */
+    onDeleteView?: (id: string) => void;
+    /** Callback to set default view */
+    onSetDefaultView?: (id: string) => void;
+    /** Optional class name */
+    className?: string;
+}
+/**
+ * DataTable Views component for saving and loading table configurations.
+ *
+ * Features:
+ * - Save current view with a custom name
+ * - Load saved views
+ * - Set a default view
+ * - Delete views
+ * - Shows "Save" button when view has unsaved changes
+ */
+declare function DataTableViews({ views, activeViewId, currentState, onSelectView, onSaveView, onUpdateView, onDeleteView, onSetDefaultView, className, }: DataTableViewsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Shared styling constants for DataTable topper action buttons.
+ *
+ * These ensure consistent appearance across all DataTable header actions:
+ * - Views dropdown
+ * - Column picker
+ * - Add button
+ * - Search (when implemented as button)
+ *
+ * Uses the ghost-icon variant for:
+ * - No background hover effect
+ * - Icon scale animation on hover
+ * - Consistent text-icon color
+ */
+/**
+ * Standard button props for DataTable topper actions.
+ * Apply these to buttons that appear in the DataTableTopper.
+ */
+declare const dataTableTopperButtonProps: {
+    readonly variant: "ghost-icon";
+    readonly size: "icon-sm";
+};
+/**
+ * CSS classes for responsive topper buttons with labels.
+ * Use when button has both icon and text label that hides on small screens.
+ */
+declare const dataTableTopperResponsiveClasses = "w-8 @min-[450px]:w-auto @min-[450px]:px-2";
+/**
+ * CSS classes for the button when dropdown is open.
+ */
+declare const dataTableTopperOpenStateClasses = "data-[state=open]:text-foreground";
+/**
+ * CSS classes for icon-only elements in the topper (matching ghost-icon variant).
+ * Use for custom buttons or icon elements that aren't using the Button component.
+ */
+declare const dataTableTopperIconClasses = "text-icon hover:text-icon-hover [&_svg]:transition-transform [&_svg]:duration-200 hover:[&_svg]:scale-110";
+
+type DataTableConfig = typeof dataTableConfig;
+declare const dataTableConfig: {
+    textOperators: ({
+        label: string;
+        value: "iLike";
+    } | {
+        label: string;
+        value: "notILike";
+    } | {
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    numericOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "lt";
+    } | {
+        label: string;
+        value: "lte";
+    } | {
+        label: string;
+        value: "gt";
+    } | {
+        label: string;
+        value: "gte";
+    } | {
+        label: string;
+        value: "isBetween";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    dateOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "lt";
+    } | {
+        label: string;
+        value: "gt";
+    } | {
+        label: string;
+        value: "lte";
+    } | {
+        label: string;
+        value: "gte";
+    } | {
+        label: string;
+        value: "isBetween";
+    } | {
+        label: string;
+        value: "isRelativeToToday";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    selectOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    multiSelectOperators: ({
+        label: string;
+        value: "inArray";
+    } | {
+        label: string;
+        value: "notInArray";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    booleanOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    })[];
+    sortOrders: ({
+        label: string;
+        value: "asc";
+    } | {
+        label: string;
+        value: "desc";
+    })[];
+    filterVariants: readonly ["text", "number", "range", "date", "dateRange", "boolean", "select", "multiSelect"];
+    operators: readonly ["iLike", "notILike", "eq", "ne", "inArray", "notInArray", "isEmpty", "isNotEmpty", "lt", "lte", "gt", "gte", "isBetween", "isRelativeToToday"];
+    joinOperators: readonly ["and", "or"];
+};
+
+interface DataTableProps<TData> extends React$1.ComponentProps<"div"> {
+    table: Table<TData>;
+    actionBar?: React$1.ReactNode;
+    /**
+     * Rows rendered inside a `<TableFooter>` after the body (summary/totals).
+     * Local extension over tablecn; pass `<DataTableSummary …/>` here.
+     */
+    footer?: React$1.ReactNode;
+    /**
+     * Called when a body row is clicked. Local extension over tablecn; the row
+     * gets `cursor-pointer` when set.
+     */
+    onRowClick?: (row: Row<TData>) => void;
+    /**
+     * Extra classes for a body row (e.g. tint group rows). Local extension over
+     * tablecn.
+     */
+    getRowClassName?: (row: Row<TData>) => string | undefined;
+}
+declare function DataTable<TData>({ table, actionBar, footer, onRowClick, getRowClassName, children, className, ...props }: DataTableProps<TData>): react_jsx_runtime.JSX.Element;
+
+/**
+ * DropdownMenu - Context menu dropdown component
+ *
+ * @example
+ * <DropdownMenu>
+ *   <DropdownMenuTrigger asChild>
+ *     <Button variant="outline">Open Menu</Button>
+ *   </DropdownMenuTrigger>
+ *   <DropdownMenuContent>
+ *     <DropdownMenuItem>Profile</DropdownMenuItem>
+ *     <DropdownMenuItem>Settings</DropdownMenuItem>
+ *     <DropdownMenuSeparator />
+ *     <DropdownMenuItem variant="destructive">Logout</DropdownMenuItem>
+ *   </DropdownMenuContent>
+ * </DropdownMenu>
+ */
+declare function DropdownMenu({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuPortal - Portal container for dropdown menu
+ */
+declare function DropdownMenuPortal({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuTrigger - Element that triggers the dropdown menu
+ */
+declare function DropdownMenuTrigger({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuContent - Container for dropdown menu items
+ */
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuItem - Individual item in dropdown menu
+ */
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuCheckboxItem - Checkbox item in dropdown menu
+ */
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuRadioItem - Radio button item in dropdown menu
+ */
+declare function DropdownMenuRadioItem({ className, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuLabel - Section label in dropdown menu
+ */
+declare function DropdownMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuSeparator - Visual separator between menu items
+ */
+declare function DropdownMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuGroup - Container for grouping related menu items
+ */
+declare function DropdownMenuGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuRadioGroup - Container for radio button items
+ */
+declare function DropdownMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuSub - Nested submenu container
+ */
+declare function DropdownMenuSub({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
+/**
+ * DropdownMenuSubTrigger - Trigger for opening a submenu
+ */
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+
+interface DataTableColumnHeaderProps<TData, TValue> extends React.ComponentProps<typeof DropdownMenuTrigger> {
+    column: Column<TData, TValue>;
+    label: string;
+}
+declare function DataTableColumnHeader<TData, TValue>({ column, label, className, ...props }: DataTableColumnHeaderProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface DataTableDateFilterProps<TData> {
+    column: Column<TData, unknown>;
+    title?: string;
+    multiple?: boolean;
+}
+declare function DataTableDateFilter<TData>({ column, title, multiple, }: DataTableDateFilterProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare const getSortingStateParser: <TData>(columnIds?: string[] | Set<string>) => nuqs_server.SingleParserBuilder<ExtendedColumnSort<TData>[]>;
+declare const filterItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    variant: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        select: "select";
+        text: "text";
+        date: "date";
+        range: "range";
+        dateRange: "dateRange";
+        multiSelect: "multiSelect";
+    }>;
+    operator: z.ZodEnum<{
+        iLike: "iLike";
+        notILike: "notILike";
+        eq: "eq";
+        ne: "ne";
+        isEmpty: "isEmpty";
+        isNotEmpty: "isNotEmpty";
+        lt: "lt";
+        lte: "lte";
+        gt: "gt";
+        gte: "gte";
+        isBetween: "isBetween";
+        isRelativeToToday: "isRelativeToToday";
+        inArray: "inArray";
+        notInArray: "notInArray";
+    }>;
+    filterId: z.ZodString;
+}, z.core.$strip>;
+type FilterItemSchema = z.infer<typeof filterItemSchema>;
+declare const getFiltersStateParser: <TData>(columnIds?: string[] | Set<string>) => nuqs_server.SingleParserBuilder<ExtendedColumnFilter<TData>[]>;
+
+declare module "@tanstack/react-table" {
+    interface TableMeta<TData extends RowData> {
+        queryKeys?: QueryKeys;
+    }
+    interface ColumnMeta<TData extends RowData, TValue> {
+        label?: string;
+        placeholder?: string;
+        variant?: FilterVariant;
+        options?: Option[];
+        range?: [number, number];
+        unit?: string;
+        icon?: React.ComponentType<React.ComponentProps<"svg">>;
+    }
+}
+interface QueryKeys {
+    page: string;
+    perPage: string;
+    sort: string;
+    filters: string;
+    joinOperator: string;
+}
+interface Option {
+    label: string;
+    value: string;
+    count?: number;
+    icon?: React.ComponentType<React.ComponentProps<"svg">>;
+}
+type FilterOperator = DataTableConfig["operators"][number];
+type FilterVariant = DataTableConfig["filterVariants"][number];
+type JoinOperator = DataTableConfig["joinOperators"][number];
+interface ExtendedColumnSort<TData> extends Omit<ColumnSort, "id"> {
+    id: Extract<keyof TData, string>;
+}
+interface ExtendedColumnFilter<TData> extends FilterItemSchema {
+    id: Extract<keyof TData, string>;
+}
+interface DataTableRowAction<TData> {
+    row: Row<TData>;
+    variant: "update" | "delete";
+}
+
+interface DataTableFacetedFilterProps<TData, TValue> {
+    column?: Column<TData, TValue>;
+    title?: string;
+    options: Option[];
+    multiple?: boolean;
+}
+declare function DataTableFacetedFilter<TData, TValue>({ column, title, options, multiple, }: DataTableFacetedFilterProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface DataTablePaginationProps<TData> extends React.ComponentProps<"div"> {
+    table: Table<TData>;
+    pageSizeOptions?: number[];
+}
+declare function DataTablePagination<TData>({ table, pageSizeOptions, className, ...props }: DataTablePaginationProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableSkeletonProps extends React.ComponentProps<"div"> {
+    columnCount: number;
+    rowCount?: number;
+    filterCount?: number;
+    cellWidths?: string[];
+    withViewOptions?: boolean;
+    withPagination?: boolean;
+    shrinkZero?: boolean;
+}
+declare function DataTableSkeleton({ columnCount, rowCount, filterCount, cellWidths, withViewOptions, withPagination, shrinkZero, className, ...props }: DataTableSkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface DataTableSliderFilterProps<TData> {
+    column: Column<TData, unknown>;
+    title?: string;
+}
+declare function DataTableSliderFilter<TData>({ column, title, }: DataTableSliderFilterProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableToolbarProps<TData> extends React$1.ComponentProps<"div"> {
+    table: Table<TData>;
+}
+declare function DataTableToolbar<TData>({ table, children, className, ...props }: DataTableToolbarProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function Popover({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function PopoverTrigger({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare function PopoverAnchor({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Anchor>): react_jsx_runtime.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function PopoverTitle({ className, ...props }: React$1.ComponentProps<"h2">): react_jsx_runtime.JSX.Element;
+declare function PopoverDescription({ className, ...props }: React$1.ComponentProps<"p">): react_jsx_runtime.JSX.Element;
+
+interface DataTableViewOptionsProps<TData> extends React$1.ComponentProps<typeof PopoverContent> {
+    table: Table<TData>;
+    disabled?: boolean;
+}
+declare function DataTableViewOptions<TData>({ table, disabled, className, ...props }: DataTableViewOptionsProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function getColumnPinningStyle<TData>({ column, withBorder, }: {
+    column: Column<TData>;
+    withBorder?: boolean;
+}): React.CSSProperties;
+declare function getFilterOperators(filterVariant: FilterVariant): {
+    label: string;
+    value: FilterOperator;
+}[];
+declare function getDefaultFilterOperator(filterVariant: FilterVariant): "iLike" | "notILike" | "eq" | "ne" | "isEmpty" | "isNotEmpty" | "lt" | "lte" | "gt" | "gte" | "isBetween" | "isRelativeToToday" | "inArray" | "notInArray";
+declare function getValidFilters<TData>(filters: ExtendedColumnFilter<TData>[]): ExtendedColumnFilter<TData>[];
+
+interface UseDataTableProps<TData> extends Omit<TableOptions<TData>, "state" | "pageCount" | "getCoreRowModel" | "manualFiltering" | "manualPagination" | "manualSorting">, Required<Pick<TableOptions<TData>, "pageCount">> {
+    initialState?: Omit<Partial<TableState>, "sorting"> & {
+        sorting?: ExtendedColumnSort<TData>[];
+    };
+    queryKeys?: Partial<QueryKeys>;
+    history?: "push" | "replace";
+    debounceMs?: number;
+    throttleMs?: number;
+    clearOnDefault?: boolean;
+    enableAdvancedFilter?: boolean;
+    scroll?: boolean;
+    shallow?: boolean;
+    startTransition?: React$1.TransitionStartFunction;
+}
+declare function useDataTable<TData>(props: UseDataTableProps<TData>): {
+    table: _tanstack_table_core.Table<TData>;
+    shallow: boolean;
+    debounceMs: number;
+    throttleMs: number;
+};
+
+/**
+ * Data table — tablecn (sadmann7/shadcn-table) components over TanStack Table,
+ * vendored under `blocks/table`, plus local add-ons under `./addons`.
+ *
+ * The tablecn pieces are kept as close to upstream as possible so they can be
+ * re-vendored; local changes are marked in-file. `useDataTable` keeps table
+ * state in the URL via nuqs and needs a `NuqsAdapter` at the app root; the
+ * components work with any TanStack table instance and need no adapter.
+ */
+
+/**
+ * Column `meta` shape the toolbar and header read (`label`, `variant`,
+ * `options`, `placeholder`, `icon`, …). Alias of the augmented TanStack
+ * `ColumnMeta` so column files can write `satisfies DataTableColumnMeta`.
+ */
+type DataTableColumnMeta<TData = unknown, TValue = unknown> = ColumnMeta<TData, TValue>;
+
+export { type JoinOperator as $, type DataTableViewState as A, DataTableViews as B, type ColumnDataType as C, DataTable as D, type DataTableViewsProps as E, DropdownMenu as F, DropdownMenuCheckboxItem as G, DropdownMenuContent as H, DropdownMenuGroup as I, DropdownMenuItem as J, DropdownMenuLabel as K, DropdownMenuPortal as L, DropdownMenuRadioGroup as M, DropdownMenuRadioItem as N, DropdownMenuSeparator as O, DropdownMenuShortcut as P, DropdownMenuSub as Q, DropdownMenuSubContent as R, DropdownMenuSubTrigger as S, DropdownMenuTrigger as T, type ExportFormat as U, type ExportToCsvOptions as V, type ExportToExcelOptions as W, type ExtendedColumnFilter as X, type ExtendedColumnSort as Y, type FilterOperator as Z, type FilterVariant as _, type ColumnSummaryConfig as a, type Option as a0, Popover as a1, PopoverAnchor as a2, PopoverContent as a3, PopoverDescription as a4, PopoverHeader as a5, PopoverTitle as a6, PopoverTrigger as a7, type QueryKeys as a8, type SummaryType as a9, dataTableConfig as aa, dataTableTopperButtonProps as ab, dataTableTopperIconClasses as ac, dataTableTopperOpenStateClasses as ad, dataTableTopperResponsiveClasses as ae, exportToCsv as af, exportToExcel as ag, getColumnPinningStyle as ah, getDefaultFilterOperator as ai, getFilterOperators as aj, getFiltersStateParser as ak, getSortingStateParser as al, getValidFilters as am, useDataTable as an, DataTableAddButton as b, type DataTableAddButtonProps as c, DataTableColumnHeader as d, type DataTableColumnMeta as e, type DataTableConfig as f, DataTableDateFilter as g, DataTableExportButton as h, type DataTableExportButtonProps as i, DataTableFacetedFilter as j, DataTablePagination as k, type DataTableRowAction$1 as l, type DataTableRowAction as m, DataTableRowActions as n, type DataTableRowActionsProps as o, DataTableSearch as p, DataTableSkeleton as q, DataTableSliderFilter as r, DataTableSummary as s, type DataTableSummaryProps as t, type DataTableTab as u, DataTableToolbar as v, DataTableTopper as w, type DataTableTopperProps as x, type DataTableView as y, DataTableViewOptions as z };