@servicetitan/anvil2 3.0.3 → 3.0.5

package/dist/src/beta/components/SelectField/types.d.ts

@@ -0,0 +1,339 @@
+import { AriaAttributes, CSSProperties, ReactElement, ReactNode } from 'react';
+import { AiMarkWithTooltipOrPopoverProps, LayoutUtilProps, Size } from '../../../types';
+import { AvatarProps, ChipProps, IconProps } from '../../..';
+import { AddNewItemProps } from '../../../internal/types/addNewItemTypes';
+/**
+ * Configuration options for the SelectField cache.
+ * @property enabled - Whether caching is enabled. Defaults to true.
+ * @property maxSize - Maximum number of cached entries before clearing the cache. Defaults to 15.
+ */
+export type SelectFieldCacheOptions = {
+    enabled?: boolean;
+    maxSize?: number;
+};
+/**
+ * Imperative handle for the SelectField component.
+ * @property clearCache - Clears the options cache.
+ * @property invalidate - Clears the cache and triggers a fresh options load from the data source.
+ */
+export type SelectFieldHandle = {
+    clearCache: () => void;
+    invalidate: () => void;
+};
+export type SelectFieldGroupByValue = string | number;
+export type SelectFieldOption = {
+    id: string | number;
+    label: string;
+    searchText?: string;
+    group?: SelectFieldGroupByValue;
+    disabled?: boolean;
+    extra?: Record<string, unknown>;
+    content?: {
+        title?: string;
+        description?: string;
+        chips?: Pick<ChipProps, "label" | "color" | "textWrap">[];
+        avatar?: Pick<AvatarProps, "name" | "status" | "color" | "image">;
+        icon?: Pick<IconProps, "svg" | "color"> & {
+            /** Accessible label for the icon. When omitted, the icon is treated as decorative. */
+            label?: string;
+        };
+    };
+};
+export type SelectFieldGroupedOption = SelectFieldOption & {
+    group: SelectFieldGroupByValue;
+};
+export type SelectFieldUngroupedOption = Omit<SelectFieldOption, "group"> & {
+    group?: never;
+};
+export type SelectFieldOptionsResult = SelectFieldOption[] | Promise<SelectFieldOption[]>;
+export type SelectFieldEagerLoader = (searchValue: string) => SelectFieldOptionsResult;
+export type SelectFieldOffsetLazyResult = {
+    options: SelectFieldUngroupedOption[];
+    hasMore?: boolean;
+};
+export type SelectFieldOffsetLazyLoader = (searchValue: string, offset: number, limit: number) => SelectFieldOffsetLazyResult | Promise<SelectFieldOffsetLazyResult>;
+export type SelectFieldPageLazyResult = {
+    options: SelectFieldUngroupedOption[];
+    hasMore?: boolean;
+};
+export type SelectFieldPageLazyLoader = (searchValue: string, pageNumber: number, pageSize: number) => SelectFieldPageLazyResult | Promise<SelectFieldPageLazyResult>;
+export type SelectFieldGroupLazyResult = {
+    options: SelectFieldGroupedOption[];
+    hasMore?: boolean;
+};
+export type SelectFieldGroupLazyLoader = (searchValue: string, previousGroupKey: SelectFieldGroupByValue | null) => SelectFieldGroupLazyResult | Promise<SelectFieldGroupLazyResult>;
+export type SelectFieldSearchProps = {
+    /**
+     * The current search value.
+     * Not a preferred usage. You likely don't need to control the searchValue yourself.
+     */
+    searchValue?: string;
+    /**
+     * Callback when the search value changes.
+     * Not a preferred usage. Lean on the searchValue in the loadOptions function instead.
+     */
+    onSearchChange?: (searchValue: string) => void;
+    /**
+     * The number of milliseconds to debounce the search input.
+     */
+    debounceMs?: number;
+};
+type SelectFieldAddNewOptionProps = {
+    /**
+     * The configuration for the add new option.
+     */
+    addNewOption?: {
+        /**
+         * The label to display for the add new option.
+         */
+        label: string;
+        /**
+         * The content to display in the add new option dialog.
+         */
+        renderDialogContent: (searchValue: string) => React.ReactNode;
+    };
+};
+export type SelectFieldPinnedOptionsSection = {
+    options: SelectFieldOption[] | ((searchValue: string) => SelectFieldOption[] | Promise<SelectFieldOption[]>);
+    label: string;
+    /**
+     * Whether to re-call the loader when search value changes.
+     * Only applies when `options` is a function. Defaults to true.
+     * When false, the loader is called once and the result is reused for all search values.
+     *
+     * You may wish to use this, for example, if you are loading a set of "favorites" options that should not be re-loaded when the search value changes.
+     */
+    searchReactive?: boolean;
+    /**
+     * Maximum number of search results to cache per section.
+     * Only applies when `options` is a function and `searchReactive` is true.
+     * Oldest entries are evicted when the limit is reached. Defaults to 15.
+     */
+    cacheSize?: number;
+};
+/**
+ * There are two ways to configure pinned options.
+ * 1. A labeled pinned options object (e.g. "Favorites", "Recent", "AI Suggestions", etc.)
+ * 2. An array of labeled pinned options objects (e.g. [{"label": "Favorites", "options": [...]}])
+ */
+export type SelectFieldPinnedOptions = SelectFieldPinnedOptionsSection | SelectFieldPinnedOptionsSection[];
+type SelectFieldCommonSelectFieldProps = {
+    /**
+     * The id of the select field.
+     */
+    id?: string;
+    /**
+     * The label of the select field.
+     */
+    label: string;
+    /**
+     * The placeholder of the select field.
+     */
+    placeholder?: string;
+    /**
+     * The size of the select field.
+     */
+    size?: Extract<Size, "small" | "medium" | "large">;
+    /**
+     * The value of the select field. Must be controlled state.
+     */
+    value: SelectFieldOption | null;
+    /**
+     * The callback to call when an item is clicked.
+     * @param option - The option that was selected.
+     */
+    onSelectedOptionChange: (option: SelectFieldOption | null) => void;
+    /**
+     * Defines the initial loading behavior of the options. Controls when loadOptions is called.
+     * @default "auto"
+     * @description "auto" default behavior, currently equivalent to "immediate".
+     * @description "immediate" will load the initial options when the component is mounted.
+     * @description "open" will load the initial options if/when the user opens the dropdown.
+     */
+    initialLoad?: "auto" | "immediate" | "open";
+    /**
+     * The options to pin to the top of the list.
+     */
+    pinned?: SelectFieldPinnedOptions;
+    /**
+     * Whether to disable the clear button.
+     * @default false
+     */
+    disableClearButton?: boolean;
+    /**
+     * Configuration for caching loadOptions results.
+     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     */
+    cache?: SelectFieldCacheOptions;
+    /**
+     * The way to display the menu.
+     * @default "auto"
+     * @description "auto" will display the menu as a popover on mobile and a dialog on desktop.
+     * @description "popover" will always display the menu as a popover.
+     * @description "dialog" will always display the menu as a dialog.
+     */
+    displayMenuAs?: "auto" | "popover" | "dialog";
+    /**
+     * Error state for the field. Pass `true` to indicate error styling without a message.
+     * Pass a string, string[], or ReactElement (deprecated) for error messages.
+     */
+    error?: boolean | string | ReactElement | string[];
+    /**
+     * Visually hides the label while keeping it accessible to screen readers.
+     * @default false
+     */
+    hideLabel?: boolean;
+    /**
+     * Hint text displayed below the input field.
+     */
+    hint?: ReactElement | string;
+    /**
+     * Additional information to display in a tooltip next to the label.
+     */
+    moreInfo?: ReactNode;
+    /**
+     * AI mark configuration to display next to the label.
+     * Can be a boolean to show a simple AI mark, or an object with tooltip/popover configuration.
+     */
+    labelAiMark?: AiMarkWithTooltipOrPopoverProps["aiMark"];
+    /**
+     * Description text displayed below the input field.
+     */
+    description?: ReactElement | string;
+    /**
+     * @deprecated No longer used. Error messages always use `aria-live="assertive"`.
+     */
+    errorAriaLive?: AriaAttributes["aria-live"];
+    /**
+     * Warning message(s) to display. Supports a single string or an array of strings.
+     */
+    warning?: string | string[];
+    /**
+     * Whether the field is required. Shows a red asterisk (*) next to the label.
+     */
+    required?: boolean;
+    /**
+     * Whether the field is disabled.
+     * When disabled, the input is still focusable but menu items cannot be selected.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the field is read-only.
+     * When read-only, the input is still focusable but menu items cannot be selected.
+     */
+    readOnly?: boolean;
+    /**
+     * Content to display before the input field.
+     */
+    prefix?: string | ReactElement;
+    /**
+     * Content to display after the input field.
+     */
+    suffix?: string | ReactElement;
+    /**
+     * Custom CSS class name for the wrapper element.
+     */
+    className?: string;
+    /**
+     * Custom inline styles for the wrapper element.
+     */
+    style?: CSSProperties;
+    /**
+     * Whether to virtualize the dropdown list using windowed rendering.
+     * Enable this for large option sets to improve performance by only rendering visible items.
+     * @default false
+     */
+    virtualize?: boolean;
+    /**
+     * Whether to disable the search input.
+     * When true, the input is replaced with a non-editable select trigger and the ARIA pattern
+     * changes from combobox to listbox.
+     * @default false
+     */
+    disableSearch?: boolean;
+} & SelectFieldSearchProps & SelectFieldAddNewOptionProps & LayoutUtilProps & AddNewItemProps;
+type SelectFieldGroupingProps = {
+    /**
+     * Function to convert a group value to a display label.
+     * Only used when options have a `group` property.
+     * @param groupValue - The group value from the option's `group` property
+     * @returns The formatted group label
+     */
+    groupToString?: (groupValue: SelectFieldGroupByValue) => string;
+    /**
+     * Function to compare two group values for sorting.
+     * When provided, options are sorted by group using this comparator,
+     * then by match-sort order within each group.
+     * @param a - First group value to compare
+     * @param b - Second group value to compare
+     * @returns Negative if a < b, positive if a > b, zero if equal
+     */
+    groupSorter?: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number;
+};
+type SelectFieldNonGroupingProps = {
+    /**
+     * Incompatible with non-group lazy loading.
+     */
+    groupToString?: never;
+    /**
+     * Incompatible with non-group lazy loading.
+     */
+    groupSorter?: never;
+};
+export type SelectFieldPropsLazyPage = SelectFieldCommonSelectFieldProps & {
+    /**
+     * Lazy loading mode using page-based pagination.
+     * Options will be loaded on demand when the user scrolls to the bottom of the list.
+     * This mode only supports flat options (i.e. cannot be used with grouped options).
+     */
+    lazy: "page";
+    lazyOptions?: {
+        pageSize?: number;
+    };
+    /**
+     * Function to load the options.
+     */
+    loadOptions: SelectFieldPageLazyLoader;
+} & SelectFieldNonGroupingProps;
+export type SelectFieldPropsLazyOffset = SelectFieldCommonSelectFieldProps & {
+    /**
+     * Lazy loading mode using offset-based pagination.
+     * Options will be loaded on demand when the user scrolls to the bottom of the list.
+     * This mode only supports flat options (i.e. cannot be used with grouped options).
+     */
+    lazy: "offset";
+    lazyOptions?: {
+        limit?: number;
+    };
+    /**
+     * Function to load the options.
+     */
+    loadOptions: SelectFieldOffsetLazyLoader;
+} & SelectFieldNonGroupingProps;
+export type SelectFieldPropsLazyGroup = SelectFieldCommonSelectFieldProps & {
+    /**
+     * Lazy loading mode using incremental group loading.
+     * Groups will be loaded on demand when the user scrolls to the bottom of the list.
+     * This mode supports grouped options.
+     */
+    lazy: "group";
+    lazyOptions?: object;
+    /**
+     * Function to load the options.
+     */
+    loadOptions: SelectFieldGroupLazyLoader;
+} & SelectFieldGroupingProps;
+export type SelectFieldPropsEager = SelectFieldCommonSelectFieldProps & {
+    /**
+     * Whether the options are lazy loaded. If true, the options will be loaded on demand when the user scrolls to the bottom of the list.
+     * @default false
+     */
+    lazy?: false;
+    /**
+     * Function to load the options.
+     */
+    loadOptions: SelectFieldEagerLoader;
+} & SelectFieldGroupingProps;
+export type SelectFieldPropsLazy = SelectFieldPropsLazyPage | SelectFieldPropsLazyOffset | SelectFieldPropsLazyGroup;
+export type SelectFieldProps = SelectFieldPropsLazy | SelectFieldPropsEager;
+export {};

package/dist/src/beta/components/SelectMenu/SelectMenu.d.ts

@@ -0,0 +1,28 @@
+import { SelectMenuHandle, SelectMenuProps } from './types';
+/**
+ * SelectMenu component for selecting a single option from a dropdown triggered by any element.
+ *
+ * Features:
+ * - Attaches to any trigger element via a render prop
+ * - Optional search input rendered inside the popover/dialog
+ * - Lazy loading with pagination (page, offset, or group modes)
+ * - Pinned options support
+ * - Grouped options support
+ * - Supports both popover and dialog display modes
+ * - Adaptive display based on device (mobile uses dialog)
+ * - Cache support for loadOptions results
+ * - Full accessibility support with ARIA attributes
+ * - Controlled selection state
+ * - Configurable popover width
+ * - Optional "Add new item" affordance below the option list with consumer-owned dialog
+ *
+ * @example
+ * <SelectMenu
+ *   trigger={(props) => <Button {...props}>Select a book</Button>}
+ *   label="Books"
+ *   value={selectedOption}
+ *   onSelectedOptionChange={setSelectedOption}
+ *   loadOptions={loadOptions}
+ * />
+ */
+export declare const SelectMenu: import('react').ForwardRefExoticComponent<SelectMenuProps & import('react').RefAttributes<SelectMenuHandle>>;

package/dist/src/beta/components/SelectMenu/types.d.ts

@@ -0,0 +1,169 @@
+import { KeyboardEvent, ReactElement, RefObject } from 'react';
+import { SelectFieldCacheOptions, SelectFieldEagerLoader, SelectFieldGroupByValue, SelectFieldGroupLazyLoader, SelectFieldGroupedOption, SelectFieldOffsetLazyLoader, SelectFieldOption, SelectFieldPageLazyLoader, SelectFieldPinnedOptions, SelectFieldSearchProps } from '../SelectField/types';
+import { AddNewItemProps } from '../../../internal/types/addNewItemTypes';
+export type SelectMenuOption = SelectFieldOption;
+export type SelectMenuGroupByValue = SelectFieldGroupByValue;
+export type SelectMenuGroupedOption = SelectFieldGroupedOption;
+/**
+ * Configuration options for the SelectMenu cache.
+ * @property enabled - Whether caching is enabled. Defaults to true.
+ * @property maxSize - Maximum number of cached entries before clearing the cache. Defaults to 15.
+ */
+export type SelectMenuCacheOptions = SelectFieldCacheOptions;
+/**
+ * Imperative handle for the SelectMenu component.
+ * @property clearCache - Clears the options cache.
+ * @property invalidate - Clears the cache and triggers a fresh options load from the data source.
+ */
+export type SelectMenuHandle = {
+    clearCache: () => void;
+    invalidate: () => void;
+};
+export type SelectMenuEagerLoader = SelectFieldEagerLoader;
+export type SelectMenuPageLazyLoader = SelectFieldPageLazyLoader;
+export type SelectMenuOffsetLazyLoader = SelectFieldOffsetLazyLoader;
+export type SelectMenuGroupLazyLoader = SelectFieldGroupLazyLoader;
+export type SelectMenuPinnedOptions = SelectFieldPinnedOptions;
+export type SelectMenuSearchProps = SelectFieldSearchProps;
+/**
+ * Props provided to the trigger render function.
+ * @property ref - Ref to attach to the trigger element for positioning
+ * @property onClick - Click handler to toggle the menu
+ * @property onKeyDown - Key handler for keyboard navigation
+ * @property aria-haspopup - ARIA attribute indicating the trigger opens a listbox
+ * @property aria-controls - ARIA attribute linking to the menu element
+ * @property aria-expanded - ARIA attribute indicating whether the menu is open
+ * @property data-state - Data attribute indicating the open/close state
+ */
+export type SelectMenuTriggerProps = {
+    ref: RefObject<HTMLButtonElement>;
+    onClick: () => void;
+    onKeyDown: (e: KeyboardEvent<HTMLButtonElement>) => void;
+    "aria-haspopup": "listbox";
+    "aria-controls": string;
+    "aria-expanded": boolean;
+    "data-state": "open" | "close";
+};
+type SelectMenuCommonProps = {
+    /**
+     * The id of the select menu.
+     */
+    id?: string;
+    /**
+     * Render function that receives trigger props and returns the element that opens the menu.
+     */
+    trigger: (props: SelectMenuTriggerProps) => ReactElement;
+    /**
+     * Called when a key is pressed inside the menu (search field or listbox), before the
+     * menu's own key handling. Use `e.preventDefault()` to suppress the default behavior.
+     */
+    onMenuKeyDown?: (e: KeyboardEvent) => void;
+    /**
+     * Called when the menu closes implicitly — due to Tab navigation, clicking outside,
+     * or other ambient focus loss. Focus is not restored to the trigger in these cases.
+     */
+    onImplicitClose?: () => void;
+    /**
+     * Called when the menu closes explicitly — the user intentionally dismissed it
+     * via Escape, selecting an option, or toggling the trigger. Focus is restored to the trigger.
+     */
+    onExplicitClose?: () => void;
+    /**
+     * Accessible label for the menu. Used by screen readers but not rendered visually.
+     */
+    label: string;
+    /**
+     * Placeholder text shown in the search input inside the menu.
+     */
+    searchPlaceholder?: string;
+    /**
+     * The selected option. Must be controlled state.
+     */
+    value: SelectMenuOption | null;
+    /**
+     * Callback fired when the selected option changes.
+     * @param option - The newly selected option, or null if cleared.
+     */
+    onSelectedOptionChange: (option: SelectMenuOption | null) => void;
+    /**
+     * Defines the initial loading behavior of the options.
+     * @default "auto"
+     */
+    initialLoad?: "auto" | "immediate" | "open";
+    /**
+     * Options to pin to the top of the list.
+     */
+    pinned?: SelectMenuPinnedOptions;
+    /**
+     * Configuration for caching loadOptions results.
+     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     */
+    cache?: SelectMenuCacheOptions;
+    /**
+     * Controls how the menu is displayed.
+     * @default "auto"
+     * @description "auto" uses a popover on desktop and a dialog on mobile.
+     * @description "popover" always uses a popover.
+     * @description "dialog" always uses a dialog.
+     */
+    displayMenuAs?: "auto" | "popover" | "dialog";
+    /**
+     * Whether to virtualize the list using windowed rendering.
+     * Enable for large option sets to improve performance.
+     * @default false
+     */
+    virtualize?: boolean;
+    /**
+     * Whether to disable the search input inside the menu.
+     * When true, the menu shows only the list without a search field.
+     * @default false
+     */
+    disableSearch?: boolean;
+    /**
+     * Width of the popover. Only applies when `displayMenuAs="popover"` (or when the adaptive mode resolves to popover). Has no effect in dialog mode.
+     * Accepts a CSS width value or "reference" to match the trigger element's width.
+     * @default 320
+     */
+    popoverWidth?: "reference" | number | string;
+} & SelectMenuSearchProps & AddNewItemProps;
+type SelectMenuGroupingProps = {
+    /**
+     * Function to convert a group value to a display label.
+     * Only used when options have a `group` property.
+     */
+    groupToString?: (groupValue: SelectMenuGroupByValue) => string;
+    /**
+     * Custom comparator function to sort groups.
+     */
+    groupSorter?: (a: SelectMenuGroupByValue, b: SelectMenuGroupByValue) => number;
+};
+type SelectMenuNonGroupingProps = {
+    groupToString?: never;
+    groupSorter?: never;
+};
+export type SelectMenuPropsLazyPage = SelectMenuCommonProps & {
+    lazy: "page";
+    lazyOptions?: {
+        pageSize?: number;
+    };
+    loadOptions: SelectMenuPageLazyLoader;
+} & SelectMenuNonGroupingProps;
+export type SelectMenuPropsLazyOffset = SelectMenuCommonProps & {
+    lazy: "offset";
+    lazyOptions?: {
+        limit?: number;
+    };
+    loadOptions: SelectMenuOffsetLazyLoader;
+} & SelectMenuNonGroupingProps;
+export type SelectMenuPropsLazyGroup = SelectMenuCommonProps & {
+    lazy: "group";
+    lazyOptions?: object;
+    loadOptions: SelectMenuGroupLazyLoader;
+} & SelectMenuGroupingProps;
+export type SelectMenuPropsEager = SelectMenuCommonProps & {
+    lazy?: false;
+    loadOptions: SelectMenuEagerLoader;
+} & SelectMenuGroupingProps;
+export type SelectMenuPropsLazy = SelectMenuPropsLazyPage | SelectMenuPropsLazyOffset | SelectMenuPropsLazyGroup;
+export type SelectMenuProps = SelectMenuPropsLazy | SelectMenuPropsEager;
+export {};

package/dist/src/beta/components/Table/DataTable/internal/DataTableCellAffordance.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export type DataTableCellAffordanceProps = {
+    children: ReactNode;
+    interactive?: boolean;
+};
+export declare function DataTableCellAffordance({ children, interactive, }: DataTableCellAffordanceProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableOverflowCell.d.ts

@@ -0,0 +1,2 @@
+import { DataTableBodyImmutableCellProps } from './DataTableBodyImmutableCell';
+export declare function DataTableOverflowCell<T>(props: DataTableBodyImmutableCellProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/dataTableCellAffordanceHostClassName.d.ts

@@ -0,0 +1 @@
+export declare const dataTableCellAffordanceHostClassName: any;

package/dist/src/beta/components/Table/DataTable/internal/util/getCellInteractives.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Marker attribute applied the first time we manage an element's tabindex,
+ * so we can find it again to flip the value back when entering interaction
+ * mode regardless of what tabindex it currently has.
+ */
+export declare const CELL_MANAGED_ATTR = "data-anv-cell-managed-tabindex";
+/**
+ * Finds descendants of a cell that are currently tabbable but have not yet
+ * been marked managed. Used by the immutable cell to discover newly rendered
+ * focusables and bring them under tabindex control.
+ *
+ * @param cellEl The cell element to search within
+ * @returns Tabbable descendants that are not yet under cell-tabindex control
+ */
+export declare function getUnmanagedTabbables(cellEl: HTMLElement): HTMLElement[];
+/**
+ * Finds descendants the cell has previously brought under tabindex control.
+ *
+ * @param cellEl The cell element to search within
+ * @returns Descendants previously marked as managed by the cell
+ */
+export declare function getManagedInteractives(cellEl: HTMLElement): HTMLElement[];

package/dist/src/beta/components/Table/DataTable/internal/util/getTanStackColumnDef.d.ts

@@ -0,0 +1,65 @@
+import { ColumnHelper } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+import { ColumnDef, ColumnReadRenderResult, EditMode, TableRow } from '../../../types';
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData, TValue> {
+        editMode?: EditMode;
+        editConfig?: ColumnDef<TData>["editConfig"];
+        overflow?: ColumnDef<TData>["overflow"];
+        /**
+         * The original column definition, stored for type narrowing and runtime access
+         */
+        columnDef?: ColumnDef<TData>;
+        /**
+         * Custom read display metadata shared between rendering, editing, and sorting.
+         */
+        readRenderResult?: ColumnReadRenderResult;
+        getCellText?: (value: TValue, context: {
+            row: TableRow<TData>;
+            depth: number;
+        }) => string;
+        getReadRenderResult?: (value: TValue, context: {
+            row: TableRow<TData>;
+            depth: number;
+        }) => ColumnReadRenderResult;
+        /**
+         * Whether the header action (expand all / select all) is disabled for this column
+         */
+        disableHeaderAction?: boolean;
+        /**
+         * Resolved header alignment for DataTable-owned header layout.
+         */
+        headerAlign?: HeaderAlign;
+        /**
+         * Whether this column renders a grouped header.
+         */
+        isGroupHeader?: boolean;
+    }
+}
+/**
+ * Props for the getTanStackColumnDef function
+ */
+export type TanStackColumnDefProps<T> = {
+    /**
+     * The column definition to convert to a TanStack column definition
+     */
+    columnDef: ColumnDef<T>;
+    /**
+     * Table-level default content for empty cells. Column-level `emptyCellContent`
+     * takes precedence over this value.
+     */
+    emptyCellContent?: ReactNode;
+};
+type TanStackColumnDef<T extends object> = ReturnType<ColumnHelper<T>["group"]> | ReturnType<ColumnHelper<T>["accessor"]>;
+type HeaderAlign = "start" | "center" | "end";
+/**
+ * Build the column definition for TanStack useReactTable.
+ * This converts our ColumnDef<T> to TanStack's column definition format,
+ * preserving the original column definition in meta for type narrowing.
+ *
+ * @param props - The props for the getTanStackColumnDef function
+ * @param props.columnDef - The column definition to convert
+ * @returns The column definition for TanStack useReactTable
+ */
+export declare function getTanStackColumnDef<T extends object>({ columnDef, emptyCellContent, }: TanStackColumnDefProps<T>): TanStackColumnDef<T>;
+export {};