@proteos/ui 0.31.0

package/dist/index.d.cts

@@ -0,0 +1,2126 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+import { LucideIcon, LucideProps } from 'lucide-react';
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, AnchorHTMLAttributes, Ref, MouseEvent, KeyboardEvent as KeyboardEvent$1, RefObject, Key as Key$1 } from 'react';
+import * as react_aria_components from 'react-aria-components';
+import { Key, BreadcrumbsProps as BreadcrumbsProps$1, ButtonProps as ButtonProps$1, CheckboxProps as CheckboxProps$1, CheckboxGroupProps as CheckboxGroupProps$1, ComboBoxProps, DateValue, DatePickerProps as DatePickerProps$1, TextFieldProps, InputProps as InputProps$1, MenuProps as MenuProps$1, MenuItemProps as MenuItemProps$1, PopoverProps, MenuTrigger as MenuTrigger$1, DialogTriggerProps, ModalOverlayProps, DialogProps, HeadingProps, DisclosureProps, ProgressBarProps as ProgressBarProps$1, RadioProps as RadioProps$1, RadioGroupProps as RadioGroupProps$1, SelectProps as SelectProps$1, SeparatorProps as SeparatorProps$1, SwitchProps as SwitchProps$1, TabsProps, TabListProps, TabProps, TabPanelProps, TextAreaProps, TimeValue, TimeFieldProps as TimeFieldProps$1, TooltipProps as TooltipProps$1, TooltipTriggerComponentProps } from 'react-aria-components';
+import { ColumnDef, SortingState, OnChangeFn, Row } from '@tanstack/react-table';
+import { ClassValue } from 'clsx';
+
+declare const attachmentChipStyles: tailwind_variants.TVReturnType<{
+    status: {
+        uploading: string;
+        ready: string;
+        error: string;
+    };
+    isInteractive: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    status: {
+        uploading: string;
+        ready: string;
+        error: string;
+    };
+    isInteractive: {
+        true: string;
+        false: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    status: {
+        uploading: string;
+        ready: string;
+        error: string;
+    };
+    isInteractive: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type AttachmentChipVariants = VariantProps<typeof attachmentChipStyles>;
+interface AttachmentChipProps {
+    /** File name shown (truncated). */
+    name: string;
+    /** Size in bytes — rendered when known and the chip is in the `ready` state. */
+    sizeInBytes?: number;
+    /** MIME type — picks the leading file-type icon. */
+    contentType?: string;
+    /** Upload lifecycle: spinner while `uploading`, danger styling on `error`. */
+    status?: 'uploading' | 'ready' | 'error';
+    /** Tooltip text and the meta line shown in the `error` state (the failure reason). */
+    errorMessage?: string;
+    /** When set, an (x) button is shown that calls this. */
+    onRemove?: () => void;
+    /** When set, the chip body is pressable (e.g. to download an agent file). */
+    onPress?: () => void;
+    className?: string;
+}
+declare function AttachmentChip({ name, sizeInBytes, contentType, status, errorMessage, onRemove, onPress, className, }: AttachmentChipProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Attribute-type values the design system knows how to render. Exported as a
+ * value (an enum-like const object) so consumers can both reference a single
+ * member by name (`AttributeType.String`) and iterate the full set
+ * (`Object.values(AttributeType)`) without re-declaring the list. The
+ * matching type — derived from this same object — keeps the union and the
+ * runtime list in lockstep: adding a member here surfaces it in every
+ * consumer (icon mapping, type picker, designer config) automatically.
+ */
+declare const AttributeType: {
+    readonly String: "string";
+    readonly Number: "number";
+    readonly Integer: "integer";
+    readonly Datetime: "datetime";
+    readonly Enum: "enum";
+    readonly Boolean: "boolean";
+    readonly Array: "array";
+    readonly Object: "object";
+    readonly Relation: "relation";
+    readonly User: "user";
+    readonly Currency: "currency";
+    readonly KnowledgeText: "knowledge-text";
+    readonly File: "file";
+};
+type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
+/** Iteration order for type pickers, dropdowns, etc. */
+declare const ATTRIBUTE_TYPES: ReadonlyArray<AttributeType>;
+declare const ATTRIBUTE_TYPE_ICONS: Record<AttributeType, LucideIcon>;
+declare function useAttributeTypeIcon(type: AttributeType): LucideIcon;
+type AttributeTypeIconProps = Omit<LucideProps, 'ref'> & {
+    type: AttributeType;
+};
+declare function AttributeTypeIcon({ type, className, strokeWidth, ...props }: AttributeTypeIconProps): react_jsx_runtime.JSX.Element;
+
+declare const avatarStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    tone: {
+        paper: string;
+        indigo: string;
+        moss: string;
+        terra: string;
+        slate: string;
+    };
+}, undefined, string[], {
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    tone: {
+        paper: string;
+        indigo: string;
+        moss: string;
+        terra: string;
+        slate: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    tone: {
+        paper: string;
+        indigo: string;
+        moss: string;
+        terra: string;
+        slate: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type AvatarVariants = VariantProps<typeof avatarStyles>;
+type AvatarProps = HTMLAttributes<HTMLSpanElement> & AvatarVariants & {
+    /** 1–2 character initials. Ignored if `children` is provided. */
+    initials?: string;
+};
+declare function Avatar({ size, tone, initials, className, children, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+declare const avatarGroupStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+}, undefined, "flex items-center", {
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+}, undefined, "flex items-center", unknown, unknown, undefined>>;
+type AvatarGroupVariants = VariantProps<typeof avatarGroupStyles>;
+/** One person in the stack — initials plus an optional tone. */
+interface AvatarGroupItem {
+    initials: string;
+    tone?: AvatarVariants['tone'];
+    /** Stable key (e.g. the participant's external id); falls back to the index. */
+    key?: string;
+}
+type AvatarGroupProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & AvatarGroupVariants & {
+    avatars: AvatarGroupItem[];
+    /** Max avatars shown before the rest collapse into a +N chip. Default 3. */
+    max?: number;
+};
+declare function AvatarGroup({ avatars, max, size, className, ...props }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+
+declare const badgeStyles: tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        neutral: string;
+        active: string[];
+        success: string[];
+        warning: string[];
+        danger: string[];
+    };
+}, undefined, string[], {
+    variant: {
+        default: string;
+        neutral: string;
+        active: string[];
+        success: string[];
+        warning: string[];
+        danger: string[];
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        neutral: string;
+        active: string[];
+        success: string[];
+        warning: string[];
+        danger: string[];
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type BadgeVariants = VariantProps<typeof badgeStyles>;
+type BadgeProps = HTMLAttributes<HTMLSpanElement> & BadgeVariants;
+declare function Badge({ variant, className, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare const fieldControlStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            content: string;
+        };
+        md: {
+            content: string;
+        };
+    };
+    invalid: {
+        true: {
+            box: string;
+        };
+        false: {
+            box: string;
+        };
+    };
+    appearance: {
+        field: {};
+        cell: {
+            box: string;
+            content: string;
+        };
+    };
+}, {
+    box: string[];
+    content: string;
+}, undefined, {
+    size: {
+        sm: {
+            content: string;
+        };
+        md: {
+            content: string;
+        };
+    };
+    invalid: {
+        true: {
+            box: string;
+        };
+        false: {
+            box: string;
+        };
+    };
+    appearance: {
+        field: {};
+        cell: {
+            box: string;
+            content: string;
+        };
+    };
+}, {
+    box: string[];
+    content: string;
+}, tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            content: string;
+        };
+        md: {
+            content: string;
+        };
+    };
+    invalid: {
+        true: {
+            box: string;
+        };
+        false: {
+            box: string;
+        };
+    };
+    appearance: {
+        field: {};
+        cell: {
+            box: string;
+            content: string;
+        };
+    };
+}, {
+    box: string[];
+    content: string;
+}, undefined, unknown, unknown, undefined>>;
+type FieldControlVariants = VariantProps<typeof fieldControlStyles>;
+type FieldSize = NonNullable<FieldControlVariants['size']>;
+type FieldAppearance = NonNullable<FieldControlVariants['appearance']>;
+declare const fieldLabelStyles = "font-mono text-[11px] uppercase tracking-[0.08em] text-ink-4";
+declare const fieldHintStyles = "font-mono text-[11px] text-ink-4";
+declare const fieldErrorStyles = "font-mono text-[11px] text-danger";
+declare function FieldCaret(): react_jsx_runtime.JSX.Element;
+
+type BadgeMultiSelectOption<T extends Key = Key> = {
+    id: T;
+    /** Text shown inside the badge. Used as the accessible name too. */
+    label: string;
+    /** Badge color register. Defaults to `default`. */
+    variant?: BadgeVariants['variant'];
+    isDisabled?: boolean;
+};
+type BadgeMultiSelectProps<T extends Key = Key> = {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    options: ReadonlyArray<BadgeMultiSelectOption<T>>;
+    /** Controlled selection. Pass a `Set<T>` or any `Iterable<T>`. */
+    selectedKeys: Iterable<T>;
+    onSelectionChange: (keys: Set<T>) => void;
+    isDisabled?: boolean;
+    isInvalid?: boolean;
+    /** Hide already-selected options from the dropdown. Removal then only
+     *  happens via the chip × in the trigger. Default `false` (selected
+     *  options stay visible and can be toggled from the listbox). */
+    hideSelectedOptions?: boolean;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+    /** Focus the trigger on mount. Mirrors RAC's `autoFocus` prop on native
+     *  inputs; useful for keyboard chains where the trigger should take focus
+     *  when its surrounding context becomes ready. */
+    autoFocus?: boolean;
+    className?: string;
+};
+declare function BadgeMultiSelect<T extends Key>({ label, description, errorMessage, placeholder, options, selectedKeys, onSelectionChange, isDisabled, isInvalid, hideSelectedOptions, size, appearance, autoFocus, className, }: BadgeMultiSelectProps<T>): react_jsx_runtime.JSX.Element;
+
+type BreadcrumbItem = {
+    /** Stable key for the row. */
+    id: string | number;
+    /** Display label. */
+    label: ReactNode;
+    /** Optional href. Omit (or leave the last item without one) to render the
+     *  current page as plain text. */
+    href?: string;
+};
+type BreadcrumbsProps = Omit<BreadcrumbsProps$1<never>, 'children' | 'items'> & {
+    items: ReadonlyArray<BreadcrumbItem>;
+    /** Glyph between crumbs. Default `/`. */
+    separator?: ReactNode;
+};
+declare function Breadcrumbs({ items, separator, className, ...props }: BreadcrumbsProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonStyles: tailwind_variants.TVReturnType<{
+    variant: {
+        primary: string[];
+        accent: string[];
+        secondary: string[];
+        ghost: string[];
+        subtle: string[];
+        link: string[];
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+        'icon-sm': string;
+        'icon-md': string;
+        'icon-lg': string;
+    };
+    shape: {
+        rounded: string;
+        pill: string;
+    };
+}, undefined, string[], {
+    variant: {
+        primary: string[];
+        accent: string[];
+        secondary: string[];
+        ghost: string[];
+        subtle: string[];
+        link: string[];
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+        'icon-sm': string;
+        'icon-md': string;
+        'icon-lg': string;
+    };
+    shape: {
+        rounded: string;
+        pill: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        primary: string[];
+        accent: string[];
+        secondary: string[];
+        ghost: string[];
+        subtle: string[];
+        link: string[];
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+        'icon-sm': string;
+        'icon-md': string;
+        'icon-lg': string;
+    };
+    shape: {
+        rounded: string;
+        pill: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type ButtonVariants = VariantProps<typeof buttonStyles>;
+type ButtonProps = ButtonProps$1 & ButtonVariants;
+declare function Button({ variant, size, shape, className, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+declare const cardStyles: tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        accent: string[];
+        outline: string;
+        raised: string;
+    };
+}, undefined, string[], {
+    variant: {
+        default: string;
+        accent: string[];
+        outline: string;
+        raised: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        accent: string[];
+        outline: string;
+        raised: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type CardVariants = VariantProps<typeof cardStyles>;
+type CardProps = HTMLAttributes<HTMLDivElement> & CardVariants;
+declare function Card({ variant, className, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+type PressableCardProps = ButtonProps$1 & CardVariants;
+declare function PressableCard({ variant, className, ...props }: PressableCardProps): react_jsx_runtime.JSX.Element;
+/**
+ * Flush, full-bleed strip at the top of a Card.
+ * Sand-tinted surface, uppercase mono, anchors a record identifier / status.
+ * The strip bleeds to the card edges because the Card has no padding.
+ */
+declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+/**
+ * Padded content block. This is where inline slots (CardEyebrow, CardTitle,
+ * CardBody) must live — they do not carry their own padding. Repeatable for
+ * multi-section layouts; separate sections with a `<hr class="border-rule"/>`.
+ */
+declare function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+/**
+ * Footer anchored to the bottom of the card via `mt-auto`. Place a
+ * `<Separator />` above it when you want the dashed divider.
+ * Mono meta-sized text. Typically holds counts + a trailing arrow / action.
+ */
+declare function CardFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardEyebrow({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function CardFeatureTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function CardBody({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+type CheckboxProps = Omit<CheckboxProps$1, 'children'> & {
+    children?: ReactNode;
+};
+declare function Checkbox({ children, className, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+type CheckboxGroupProps = Omit<CheckboxGroupProps$1, 'children'> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    /** `<Checkbox value="…">` elements. Function-as-children is not supported at the group level. */
+    children: ReactNode;
+};
+declare function CheckboxGroup({ label, description, errorMessage, children, className, ...props }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
+
+type ComboboxOption<T extends Key = Key> = {
+    id: T;
+    label: string;
+    description?: ReactNode;
+    isDisabled?: boolean;
+    /**
+     * Per-row action UI rendered at the trailing edge of the option. Hidden
+     * by default; revealed when the row is hovered or keyboard-focused. The
+     * slot intercepts `pointerdown` / `click` propagation so interactions
+     * inside it don't trigger option selection — put a real `<button>` /
+     * `<Link>` here and it Just Works.
+     */
+    trailing?: ReactNode;
+};
+type ComboboxProps<T extends Key = Key> = Omit<ComboBoxProps<never>, 'children' | 'items' | 'defaultItems'> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    options: ReadonlyArray<ComboboxOption<T>>;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+    /** Visual override for the trigger input wrapper only. */
+    inputWrapperClassName?: string;
+    /** Visual override for the inner `<input>` (size, padding, font). */
+    inputClassName?: string;
+    /** Empty-state message shown in the popover when no options match. */
+    emptyMessage?: ReactNode;
+};
+declare function Combobox<T extends Key>({ label, description, errorMessage, placeholder, options, size, appearance, inputWrapperClassName, inputClassName, emptyMessage, className, allowsEmptyCollection, ...props }: ComboboxProps<T>): react_jsx_runtime.JSX.Element;
+
+type CommandProps = {
+    combo: string;
+    /** CSS selector for the click target. Defaults to the wrapper's first
+     *  element child — fine when that child IS the interactive control. */
+    target?: string;
+    /** Layout overrides for the wrapper. `relative` is always applied. */
+    className?: string;
+    children: ReactNode;
+};
+declare function Command({ combo, target, className, children }: CommandProps): react_jsx_runtime.JSX.Element;
+
+type CommandHintTone = 'subtle' | 'prominent';
+type CommandHintProps = {
+    combo: string;
+    tone?: CommandHintTone;
+    className?: string;
+};
+declare function CommandHint({ combo, tone, className }: CommandHintProps): react_jsx_runtime.JSX.Element;
+
+type KeyCombo = {
+    /** Normalized form for registry keying. Always `mod+<key>`. */
+    raw: string;
+    /** Key part, lowercased. Letters use `event.code` (`KeyS`); others match `event.key`. */
+    key: string;
+    /** True when `key` is a single A–Z letter — match against `event.code` so the
+     *  binding stays on the physical key regardless of keyboard layout. */
+    isLetter: boolean;
+};
+declare function parseCombo(input: string): KeyCombo;
+
+declare const PROTECTED_COMBOS: ReadonlySet<string>;
+
+declare function isEditableTarget(target: EventTarget | null): boolean;
+
+type UseCommandOptions = {
+    /** Defaults to `true`. Set to `false` to temporarily disable without unmounting. */
+    enabled?: boolean;
+};
+declare function useCommand(combo: string, handler: (event: KeyboardEvent) => void, options?: UseCommandOptions): void;
+
+type UseEscapeKeyOptions = {
+    /** Defaults to `true`. Set to `false` to temporarily disable without unmounting. */
+    enabled?: boolean;
+};
+declare function useEscapeKey(handler: (event: KeyboardEvent) => void, options?: UseEscapeKeyOptions): void;
+
+declare function useDiscoveryActive(): boolean;
+
+interface CurrencyInputValue {
+    amount: string;
+    currency_code: string;
+}
+interface CurrencyInputOption {
+    code: string;
+    /** The currency's symbol (e.g. "$", "€"); falls back to the code. */
+    symbol?: string;
+}
+interface CurrencyInputProps {
+    value: CurrencyInputValue | null;
+    onChange: (next: CurrencyInputValue | null) => void;
+    currencyOptions: ReadonlyArray<CurrencyInputOption>;
+    /** Locale for the amount's grouping + decimal separators. Defaults to runtime. */
+    locale?: string;
+    isReadOnly?: boolean;
+    isInvalid?: boolean;
+    errorMessage?: ReactNode;
+    size?: FieldSize;
+    appearance?: FieldAppearance;
+    placeholder?: string;
+    autoFocus?: boolean;
+    'aria-label'?: string;
+    onBlur?: () => void;
+    className?: string;
+}
+declare function CurrencyInput({ value, onChange, currencyOptions, locale, isReadOnly, isInvalid, errorMessage, size, appearance, placeholder, autoFocus, 'aria-label': ariaLabel, onBlur, className, }: CurrencyInputProps): react_jsx_runtime.JSX.Element;
+
+type DateCellProps = {
+    value: string | number | Date | null | undefined;
+    locale?: string;
+    options?: Intl.DateTimeFormatOptions;
+    fallback?: ReactNode;
+    className?: string;
+};
+declare function DateCell({ value, locale, options, fallback, className, }: DateCellProps): react_jsx_runtime.JSX.Element;
+type DateTimeCellProps = DateCellProps;
+declare function DateTimeCell({ value, locale, options, fallback, className, }: DateTimeCellProps): react_jsx_runtime.JSX.Element;
+type BooleanCellProps = {
+    value: boolean | null | undefined;
+    className?: string;
+};
+declare function BooleanCell({ value, className }: BooleanCellProps): react_jsx_runtime.JSX.Element;
+type TruncateCellProps = {
+    value: ReactNode;
+    title?: string;
+    className?: string;
+};
+/**
+ * The parent TableCell already clips with `overflow-hidden text-ellipsis`,
+ * so this just adds a `title` attribute for the native tooltip when the
+ * value is a string.
+ */
+declare function TruncateCell({ value, title, className }: TruncateCellProps): react_jsx_runtime.JSX.Element;
+type LinkCellProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
+    children: ReactNode;
+};
+/**
+ * An anchor that stops click propagation so a row-click handler on the
+ * parent <TableRow> doesn't fire alongside the link navigation.
+ */
+declare function LinkCell({ children, onClick, className, ...props }: LinkCellProps): react_jsx_runtime.JSX.Element;
+
+declare const tableStyles: tailwind_variants.TVReturnType<{
+    variant: {
+        panel: string[];
+        bare: string;
+    };
+}, undefined, string[], {
+    variant: {
+        panel: string[];
+        bare: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        panel: string[];
+        bare: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type TableVariants = VariantProps<typeof tableStyles>;
+type TableProps = HTMLAttributes<HTMLDivElement> & TableVariants & {
+    'aria-label'?: string;
+};
+declare function Table({ variant, className, ...props }: TableProps): react_jsx_runtime.JSX.Element;
+type TableHeaderProps = HTMLAttributes<HTMLDivElement> & {
+    sticky?: boolean;
+};
+declare function TableHeader({ sticky, className, ...props }: TableHeaderProps): react_jsx_runtime.JSX.Element;
+declare const tableHeaderCellStyles: tailwind_variants.TVReturnType<{
+    align: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    interactive: {
+        true: string[];
+        false: string;
+    };
+    active: {
+        true: string;
+        false: string;
+    };
+    sticky: {
+        left: string;
+        right: string;
+        false: string;
+    };
+}, undefined, string[], {
+    align: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    interactive: {
+        true: string[];
+        false: string;
+    };
+    active: {
+        true: string;
+        false: string;
+    };
+    sticky: {
+        left: string;
+        right: string;
+        false: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    align: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    interactive: {
+        true: string[];
+        false: string;
+    };
+    active: {
+        true: string;
+        false: string;
+    };
+    sticky: {
+        left: string;
+        right: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type SortDirection = 'asc' | 'desc' | null;
+/** Discriminator stored on every column drag payload. */
+declare const COLUMN_DRAG_KIND: "proteos:table:column";
+type ColumnDragData = {
+    kind: typeof COLUMN_DRAG_KIND;
+    columnId: string;
+};
+declare function isColumnDragData(data: Record<string | symbol, unknown>): data is ColumnDragData & Record<string | symbol, unknown>;
+type TableHeaderCellProps = Omit<HTMLAttributes<HTMLDivElement>, 'onClick'> & {
+    width?: number | string;
+    align?: 'left' | 'right' | 'center';
+    /** Pin the cell to the left or right edge during horizontal scroll. */
+    sticky?: 'left' | 'right' | false;
+    /**
+     * When non-null, renders a sort affordance and treats clicks on the cell
+     * body as a sort toggle. `null` (the default) is "not sortable".
+     */
+    sortDirection?: SortDirection;
+    onSortToggle?: () => void;
+    /**
+     * Make the header draggable for column reorder. Requires `columnId`.
+     * The cell registers pragmatic-dnd `draggable` + `dropTargetForElements`
+     * with left/right edge detection; the actual reorder runs in a global
+     * `monitorForElements` (e.g. inside DataTable) by reading the published
+     * `ColumnDragData`.
+     */
+    draggable?: boolean;
+    columnId?: string;
+    /**
+     * When provided, renders a trailing `×` button. Click events
+     * `stopPropagation` so removal never starts a drag or toggles sort.
+     */
+    onRemove?: () => void;
+    /** Aria label fragment used in the remove button label and any drag a11y. */
+    ariaLabel?: string;
+};
+declare function TableHeaderCell({ width, align, className, style, children, sortDirection, onSortToggle, draggable: isDraggable, columnId, onRemove, ariaLabel, sticky, ...rest }: TableHeaderCellProps): react_jsx_runtime.JSX.Element;
+/**
+ * Trailing flexible spacer so the header row fills the full row width when
+ * the sum of column widths is less than the viewport. Matches the design's
+ * `pt-th--spacer`.
+ */
+declare function TableHeaderSpacer({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+type TableBodyProps = HTMLAttributes<HTMLDivElement> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function TableBody({ className, ref, ...props }: TableBodyProps): react_jsx_runtime.JSX.Element;
+declare function TableScroller({ className, ref, ...props }: TableBodyProps): react_jsx_runtime.JSX.Element;
+type TableRowProps = HTMLAttributes<HTMLDivElement> & {
+    alt?: boolean;
+    interactive?: boolean;
+    /**
+     * Position the row absolutely (used by virtualizers that translate rows
+     * into place via inline `style.transform`).
+     */
+    absolute?: boolean;
+    onRowClick?: (e: MouseEvent<HTMLDivElement>) => void;
+};
+declare function TableRow({ alt, interactive, absolute, className, onRowClick, onClick, ...props }: TableRowProps): react_jsx_runtime.JSX.Element;
+declare const tableCellStyles: tailwind_variants.TVReturnType<{
+    align: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    mono: {
+        true: string;
+        false: string;
+    };
+    ink: {
+        true: string;
+        false: string;
+    };
+    sticky: {
+        left: string;
+        right: string;
+        false: string;
+    };
+}, undefined, string[], {
+    align: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    mono: {
+        true: string;
+        false: string;
+    };
+    ink: {
+        true: string;
+        false: string;
+    };
+    sticky: {
+        left: string;
+        right: string;
+        false: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    align: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    mono: {
+        true: string;
+        false: string;
+    };
+    ink: {
+        true: string;
+        false: string;
+    };
+    sticky: {
+        left: string;
+        right: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type TableCellProps = HTMLAttributes<HTMLDivElement> & {
+    width?: number | string;
+    align?: 'left' | 'right' | 'center';
+    mono?: boolean;
+    ink?: boolean;
+    /** Pin the cell to the left or right edge during horizontal scroll. */
+    sticky?: 'left' | 'right' | false;
+};
+declare function TableCell({ width, align, mono, ink, sticky, className, style, ...props }: TableCellProps): react_jsx_runtime.JSX.Element;
+
+type InfinitePage<TRow> = {
+    data: TRow[];
+    meta?: {
+        items_total?: number;
+    };
+};
+type InfiniteQueryLike<TRow> = {
+    data?: {
+        pages: InfinitePage<TRow>[];
+    } | undefined;
+    isLoading: boolean;
+    isFetchingNextPage: boolean;
+    hasNextPage: boolean | undefined;
+    error: Error | null;
+    fetchNextPage: () => void;
+    refetch?: () => void;
+};
+type DataTableProps<TRow> = {
+    query: InfiniteQueryLike<TRow>;
+    columns: ColumnDef<TRow>[];
+    sorting?: SortingState;
+    onSortingChange?: OnChangeFn<SortingState>;
+    rowHeight?: number;
+    overscan?: number;
+    /**
+     * Called when a row is clicked. Provides both the original data row and
+     * the underlying event so consumers can inspect modifier keys.
+     */
+    onRowClick?: (row: TRow, event: MouseEvent<HTMLDivElement> | KeyboardEvent$1<HTMLDivElement>) => void;
+    zebra?: boolean;
+    emptyState?: ReactNode;
+    errorState?: ReactNode;
+    loadingState?: ReactNode;
+    /**
+     * Optional accessor used as the React key for each row. Defaults to a
+     * row's `id` field (if present), then `slug`, then index.
+     */
+    getRowId?: (row: TRow, index: number) => string;
+    className?: string;
+    ariaLabel?: string;
+    /**
+     * Enable horizontal drag-and-drop reordering of columns. When on, a grip
+     * handle and `monitorForElements` are wired up; on a successful reorder
+     * `onReorderColumn` fires with the moved column's id and its new index.
+     * Each `ColumnDef` must carry a stable `id` for events to be routable.
+     */
+    enableColumnReordering?: boolean;
+    /**
+     * Enable an `×` remove affordance on each column header. The handler is
+     * called with the column's id; the parent decides what removal means
+     * (e.g. filter the displayed `columns` array).
+     */
+    enableColumnRemoval?: boolean;
+    onReorderColumn?: (params: {
+        id: string;
+        toIndex: number;
+    }) => void;
+    onRemoveColumn?: (id: string) => void;
+    /**
+     * Visual chrome around the table. `panel` (default) wraps the table in a
+     * bordered, rounded, soft-shadowed card. `bare` strips that chrome so the
+     * table can sit flush with its container — used when the surrounding
+     * surface already supplies borders (e.g. the Query Builder's results pane).
+     */
+    variant?: TableVariants['variant'];
+    /**
+     * Optional per-row wrapper. When provided, the row's cell content is
+     * passed through this function, which may render context providers (e.g.
+     * a row-scoped TanStack Form for inline editing) around the cells. The
+     * default is identity — cells render directly inside the `<TableRow>`.
+     */
+    rowWrapper?: (row: Row<TRow>, cells: ReactNode) => ReactNode;
+    /**
+     * Extra rows rendered alongside the server data. Used for inline-editable
+     * draft rows that are not yet persisted. `start` rows render above the
+     * server data, `end` rows below. They participate in the same column
+     * model, virtualization, and `rowWrapper` as server rows.
+     */
+    extraRows?: {
+        start?: TRow[];
+        end?: TRow[];
+    };
+    /**
+     * Slot rendered ABOVE the body (above the virtualized region). Used for
+     * controls like an Add row button at slot='start'. Stays put when the
+     * body scrolls (sits inside the header sticky region or just below it).
+     */
+    bodyBefore?: ReactNode;
+    /**
+     * Slot rendered BELOW the body. Used for controls like an Add row button
+     * at slot='end'. Sits inside the scrollable area below the rows.
+     */
+    bodyAfter?: ReactNode;
+    /**
+     * Draw vertical gridlines between body cells. The header always has them;
+     * the body opts in (e.g. inline-edit mode wants the full Excel-style grid).
+     * Default false — read-only tables stay borderless in the body.
+     */
+    columnBorders?: boolean;
+};
+declare function DataTable<TRow>({ query, columns, sorting, onSortingChange, rowHeight, overscan, onRowClick, zebra, emptyState, errorState, loadingState, getRowId, className, ariaLabel, enableColumnReordering, enableColumnRemoval, onReorderColumn, onRemoveColumn, variant, rowWrapper, extraRows, bodyBefore, bodyAfter, columnBorders, }: DataTableProps<TRow>): react_jsx_runtime.JSX.Element;
+
+type ActionsColumnOptions<TData> = {
+    id?: string;
+    header?: string;
+    width?: number;
+    cell: (row: TData) => ReactNode;
+};
+/**
+ * Convenience builder for a non-sortable, right-aligned actions column.
+ * Carries `meta.align: 'right'` so DataTable renders the header/cell
+ * end-aligned even though the column has no value to sort by.
+ */
+declare function makeActionsColumn<TData>({ id, header, width, cell, }: ActionsColumnOptions<TData>): ColumnDef<TData>;
+
+type DataTableEmptyProps = {
+    title?: string;
+    message?: string;
+    icon?: ReactNode;
+    action?: ReactNode;
+    className?: string;
+};
+/**
+ * Empty state shown when the query returns zero rows.
+ * Mirrors the design's `pt-empty` block.
+ */
+declare function DataTableEmpty({ title, message, icon, action, className, }: DataTableEmptyProps): react_jsx_runtime.JSX.Element;
+
+type DataTableErrorProps = {
+    error: Error;
+    onRetry?: () => void;
+    className?: string;
+};
+declare function DataTableError({ error, onRetry, className }: DataTableErrorProps): react_jsx_runtime.JSX.Element;
+
+type DataTableSkeletonProps = {
+    rows?: number;
+    columnWidths?: ReadonlyArray<number | string>;
+    rowHeight?: number;
+};
+/**
+ * Skeleton placeholder shown while the first page is loading.
+ * Renders inside the same TableBody scroller, so the layout doesn't jump
+ * when real rows replace it.
+ */
+declare function DataTableSkeleton({ rows, columnWidths, rowHeight, }: DataTableSkeletonProps): react_jsx_runtime.JSX.Element;
+
+type UseInfiniteScrollSentinelOptions = {
+    onIntersect: () => void;
+    /**
+     * IntersectionObserver `rootMargin`. Default `200px` so the next page
+     * starts fetching before the user scrolls all the way to the bottom.
+     */
+    rootMargin?: string;
+    /**
+     * Optional scroll-container ref (passed as the observer's `root`). When
+     * omitted, the observer uses the viewport.
+     */
+    root?: Element | null;
+    enabled?: boolean;
+};
+/**
+ * Mounts a sentinel element ref. When the element scrolls into view (with
+ * the given rootMargin), `onIntersect` fires once per visible streak.
+ * Used by DataTable to drive `query.fetchNextPage()`.
+ */
+declare function useInfiniteScrollSentinel<T extends Element = HTMLDivElement>({ onIntersect, rootMargin, root, enabled, }: UseInfiniteScrollSentinelOptions): RefObject<T | null>;
+
+type DatePickerProps<T extends DateValue> = DatePickerProps$1<T> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+};
+declare function DatePicker<T extends DateValue>({ label, description, errorMessage, size, appearance, className, ...props }: DatePickerProps<T>): react_jsx_runtime.JSX.Element;
+
+type DateTimePickerProps<T extends DateValue> = DatePickerProps$1<T> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+};
+declare function DateTimePicker<T extends DateValue>({ label, description, errorMessage, size, appearance, className, granularity, hideTimeZone, shouldCloseOnSelect, ...props }: DateTimePickerProps<T>): react_jsx_runtime.JSX.Element;
+
+declare const emptyStateStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            root: string;
+            art: string;
+        };
+        md: {
+            root: string;
+            art: string;
+        };
+    };
+}, {
+    root: string;
+    art: string;
+    title: string;
+    description: string;
+    actions: string;
+}, undefined, {
+    size: {
+        sm: {
+            root: string;
+            art: string;
+        };
+        md: {
+            root: string;
+            art: string;
+        };
+    };
+}, {
+    root: string;
+    art: string;
+    title: string;
+    description: string;
+    actions: string;
+}, tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            root: string;
+            art: string;
+        };
+        md: {
+            root: string;
+            art: string;
+        };
+    };
+}, {
+    root: string;
+    art: string;
+    title: string;
+    description: string;
+    actions: string;
+}, undefined, unknown, unknown, undefined>>;
+type EmptyStateVariants = VariantProps<typeof emptyStateStyles>;
+interface EmptyStateProps extends EmptyStateVariants {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    className?: string;
+}
+declare function EmptyState({ icon, title, description, action, size, className, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+type ErrorAnimationProps = {
+    className?: string;
+};
+declare function ErrorAnimation({ className }: ErrorAnimationProps): react_jsx_runtime.JSX.Element;
+
+interface FileFieldValue {
+    /** Filename shown as the label. */
+    name: string;
+    /** Size in bytes — rendered when known (resolved from storage on read). */
+    sizeInBytes?: number;
+    /** MIME type — picks the file-type icon when known. */
+    contentType?: string;
+}
+interface FileFieldProps {
+    /** The attached file, or null/undefined when empty. */
+    value?: FileFieldValue | null;
+    /** True while an upload is in flight — shows a spinner, blocks re-pick. */
+    isUploading?: boolean;
+    /** Read-only: no picker, no delete — download still works. */
+    isReadOnly?: boolean;
+    /** Restrict the native picker (e.g. `['image/*', '.pdf']`). */
+    acceptedFileTypes?: string[];
+    /** Called with the picked/dropped File. */
+    onSelectFile?: (file: File) => void;
+    /** Called when the filled card is clicked. */
+    onDownload?: () => void;
+    /** Called after the user confirms removal in the (x) popover. */
+    onDelete?: () => void;
+    /** Inline validation message (edit surface). */
+    errorMessage?: string;
+    /** True iff the field is touched and currently invalid. */
+    isInvalid?: boolean;
+    className?: string;
+}
+/** Maps a MIME type to a file-type glyph. Falls back to a generic file. */
+declare function iconForContentType(contentType?: string): LucideIcon;
+/** Human-readable byte size (1 KB = 1024 B). */
+declare function formatFileSize(bytes: number | undefined): string;
+declare function FileField({ value, isUploading, isReadOnly, acceptedFileTypes, onSelectFile, onDownload, onDelete, errorMessage, isInvalid, className, }: FileFieldProps): react_jsx_runtime.JSX.Element;
+
+declare const fileViewerFallbackCardStyles: tailwind_variants.TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, tailwind_variants.TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+type FileViewerFallbackCardVariants = VariantProps<typeof fileViewerFallbackCardStyles>;
+interface FileViewerFallbackCardProps {
+    name: string;
+    contentType?: string;
+    sizeInBytes?: number;
+    /** Why the preview is unavailable (e.g. "Too large to preview"). */
+    note?: string;
+    /** Load failure — rendered in the danger tone, wins over `note`. */
+    errorMessage?: string;
+    onDownload?: () => void;
+    className?: string;
+}
+declare function FileViewerFallbackCard({ name, contentType, sizeInBytes, note, errorMessage, onDownload, className, }: FileViewerFallbackCardProps): react_jsx_runtime.JSX.Element;
+
+declare const fileViewerStyles: tailwind_variants.TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, tailwind_variants.TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+type FileViewerVariants = VariantProps<typeof fileViewerStyles>;
+/** Which renderer a content type maps to (`none` → fallback card). */
+type FileViewerKind = 'image' | 'video' | 'pdf' | 'none';
+/**
+ * Maps a MIME type to the viewer that can render it inline. Consumers use
+ * this to decide whether fetching the bytes is worthwhile at all.
+ */
+declare function viewerKindForContentType(contentType?: string): FileViewerKind;
+interface FileViewerProps {
+    /** Filename — labels, alt text and the fallback card. */
+    name: string;
+    /** MIME type; unknown/unpreviewable types render the fallback card. */
+    contentType?: string;
+    /** Blob object URL of the file bytes. While undefined (and previewable), the skeleton renders. */
+    src?: string;
+    /** Size in bytes — shown on the fallback card when known. */
+    sizeInBytes?: number;
+    /** Viewer height in px for previewable files (the fallback card keeps its natural height). */
+    heightPx?: number;
+    /** Error loading the file — renders the fallback card with the message. */
+    errorMessage?: string;
+    /** File too large for inline preview — renders the fallback card. */
+    isOversized?: boolean;
+    /** When set, download actions render (card button, lightbox, PDF toolbar). */
+    onDownload?: () => void;
+    className?: string;
+}
+declare function FileViewer({ name, contentType, src, sizeInBytes, heightPx, errorMessage, isOversized, onDownload, className, }: FileViewerProps): react_jsx_runtime.JSX.Element;
+
+declare const imageAttachmentStyles: tailwind_variants.TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, tailwind_variants.TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+type ImageAttachmentVariants = VariantProps<typeof imageAttachmentStyles>;
+interface ImageAttachmentProps {
+    /** File name — the alt text and the accessible button name. */
+    name: string;
+    /** Resolved image URL. While undefined, the skeleton placeholder renders. */
+    src?: string;
+    /** Fired when the browser fails to load `src` (e.g. not actually an image). */
+    onLoadError?: () => void;
+    /** Fired on thumbnail press (consumer opens the lightbox). */
+    onPress?: () => void;
+    className?: string;
+}
+declare function ImageAttachment({ name, src, onLoadError, onPress, className, }: ImageAttachmentProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * True when a filename's extension is one the browser renders natively in
+ * `<img>`. A heuristic for contexts where only a name is known (e.g. a
+ * FileRef carries no MIME type) — a wrong guess should degrade gracefully via
+ * the consumer's img-error fallback. SVG is deliberately included: scripts do
+ * not execute in an `<img>` context.
+ */
+declare function isPreviewableImageName(name: string): boolean;
+
+declare const imageLightboxStyles: tailwind_variants.TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, tailwind_variants.TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+type ImageLightboxVariants = VariantProps<typeof imageLightboxStyles>;
+interface ImageLightboxProps {
+    isOpen: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    /** Full-size image URL; nothing renders in the frame while undefined. */
+    src?: string;
+    /** File name — the dialog's accessible name, alt text, and caption. */
+    name: string;
+    /** When set, a download action renders in the caption bar. */
+    onDownload?: () => void;
+}
+declare function ImageLightbox({ isOpen, onOpenChange, src, name, onDownload }: ImageLightboxProps): react_jsx_runtime.JSX.Element;
+
+type InputProps = TextFieldProps & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    /** Field size. Defaults to `md`. Use `sm` for compact rows (filter builder, toolbars). */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box for
+     *  spreadsheet-style inline editing (2px radius, no halo / resting shadow). */
+    appearance?: FieldAppearance;
+    /** Extra props forwarded to the underlying <input>. */
+    inputProps?: Omit<InputProps$1, 'className'>;
+    /** Visual override for the input control only. */
+    inputClassName?: string;
+};
+declare function Input({ label, description, errorMessage, placeholder, size, appearance, inputProps, inputClassName, className, ...props }: InputProps): react_jsx_runtime.JSX.Element;
+
+type KbdProps = HTMLAttributes<HTMLElement>;
+declare function Kbd({ className, children, ...props }: KbdProps): react_jsx_runtime.JSX.Element;
+
+/** Stateful root (RAC). Wraps the trigger element + the MenuPopover. */
+declare const MenuTrigger: typeof MenuTrigger$1;
+/**
+ * Submenu wrapper (RAC). Wraps a parent MenuItem and the nested MenuPopover so
+ * the flyout opens on hover/right-arrow. Use `placement="end top"` on the nested
+ * MenuPopover so it cascades to the side, Windows-style.
+ */
+declare const SubmenuTrigger: (props: react_aria_components.SubmenuTriggerProps & React.RefAttributes<HTMLDivElement>) => react.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+type MenuPopoverProps = PopoverProps;
+/** The floating panel. Defaults to opening below-start; pass `placement="end top"` for a submenu flyout. */
+declare function MenuPopover({ className, offset, placement, ...props }: MenuPopoverProps): react_jsx_runtime.JSX.Element;
+type MenuProps<T extends object> = MenuProps$1<T>;
+/** The menu list. Holds MenuItem / SubmenuTrigger children. */
+declare function Menu<T extends object>({ className, ...props }: MenuProps<T>): react_jsx_runtime.JSX.Element;
+type MenuItemProps = Omit<MenuItemProps$1, 'children'> & {
+    /** Leading icon slot. */
+    icon?: ReactNode;
+    /** Renders a trailing chevron marking this row as a submenu parent. */
+    hasSubmenu?: boolean;
+    children?: ReactNode;
+};
+/** A single menu row. Pass `onAction` to handle selection; `isDisabled` to dim it. */
+declare function MenuItem({ icon, hasSubmenu, children, className, ...props }: MenuItemProps): react_jsx_runtime.JSX.Element;
+
+/** Stateful root. Pass `isOpen` + `onOpenChange` for controlled usage. */
+declare function Modal(props: DialogTriggerProps): react_jsx_runtime.JSX.Element;
+type ModalContentProps = ModalOverlayProps & {
+    /** Disable backdrop click to close. Default: backdrop closes. */
+    isDismissable?: boolean;
+    /** Children of the Dialog element. Supports render-prop form `({ close }) => …`. */
+    children: DialogProps['children'];
+    /** Visual override for the panel wrapper (affects width, padding, etc.). */
+    modalClassName?: string;
+};
+/**
+ * Portaled overlay + floating panel + dialog role. Backdrop darkens the page
+ * with a warm ink tint; panel uses vellum bg + rule border + the float shadow.
+ */
+declare function ModalContent({ children, className, modalClassName, isDismissable, ...props }: ModalContentProps): react_jsx_runtime.JSX.Element;
+/** Padded top block. Contains `<ModalTitle>` and optionally `<ModalDescription>`. */
+declare function ModalHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+/** The modal's accessible name. Uses RAC `<Heading slot="title">` so the
+ *  Dialog's `aria-labelledby` points here automatically. */
+declare function ModalTitle({ className, ...props }: Omit<HeadingProps, 'slot'>): react_jsx_runtime.JSX.Element;
+/** Supporting copy under the title. */
+declare function ModalDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+/** Padded main content block — put forms, text, lists, etc. here. */
+declare function ModalBody({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+/** Action row at the bottom. Right-aligned. Place a `<Separator />` above
+ *  it when you want the dashed divider between body and footer. */
+declare function ModalFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+type MultiSelectOption<T extends Key = Key> = {
+    id: T;
+    /** Plain-text label — used as the option's accessible name and fallback
+     *  when `content` isn't provided. */
+    label: string;
+    /** Optional rich render. Applied to BOTH the listbox row and the selected
+     *  chip (wrapped by the chip's × button). Falls back to `label`. */
+    content?: ReactNode;
+    isDisabled?: boolean;
+};
+type MultiSelectProps<T extends Key = Key> = {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    options: ReadonlyArray<MultiSelectOption<T>>;
+    /** Controlled selection. Pass a `Set<T>` or any `Iterable<T>`. */
+    selectedKeys: Iterable<T>;
+    onSelectionChange: (keys: Set<T>) => void;
+    isDisabled?: boolean;
+    isInvalid?: boolean;
+    /** Hide already-selected options from the dropdown. Removal then only
+     *  happens via the chip × in the trigger. Default `false` (selected
+     *  options stay visible and can be toggled off from the listbox). */
+    hideSelectedOptions?: boolean;
+    /** Render a search input at the top of the popover that filters options
+     *  by label (case-insensitive substring). Default `false`. */
+    isSearchable?: boolean;
+    /** Fires as the search text changes — lets consumers drive a server-side
+     *  directory search alongside the local filter. */
+    onSearchChange?: (needle: string) => void;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+    className?: string;
+};
+declare function MultiSelect<T extends Key>({ label, description, errorMessage, placeholder, options, selectedKeys, onSelectionChange, isDisabled, isInvalid, hideSelectedOptions, isSearchable, onSearchChange, size, appearance, className, }: MultiSelectProps<T>): react_jsx_runtime.JSX.Element;
+
+type NavSectionProps = {
+    /** Uppercase mono label rendered above the items. */
+    label?: ReactNode;
+    /** Counter rendered at the right of the label (e.g. `5`). */
+    count?: ReactNode;
+    /** Trailing slot at the right of the heading row, e.g. an action button. */
+    action?: ReactNode;
+    className?: string;
+    children?: ReactNode;
+    /** Stable test/automation id, forwarded to the section root. */
+    'data-testid'?: string;
+};
+/** Visually-grouped block of nav entries. Use one per logical section
+ *  ("Workspace", "Operations", "Finance"). */
+declare function NavSection({ label, count, action, className, children, 'data-testid': dataTestid, }: NavSectionProps): react_jsx_runtime.JSX.Element;
+declare const navItemStyles: tailwind_variants.TVReturnType<{
+    isActive: {
+        true: string[];
+        false: string;
+    };
+    isNested: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    isActive: {
+        true: string[];
+        false: string;
+    };
+    isNested: {
+        true: string;
+        false: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    isActive: {
+        true: string[];
+        false: string;
+    };
+    isNested: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type NavItemVariants = VariantProps<typeof navItemStyles>;
+type NavItemProps = Omit<ButtonProps$1, 'children'> & {
+    /** Leading icon. Pass an SVG element; it's wrapped in a 16px box. */
+    icon?: ReactNode;
+    /** Trailing slot — typically a count or status dot. */
+    badge?: ReactNode;
+    /** Mark the item as the current page. */
+    isActive?: boolean;
+    children?: ReactNode;
+};
+/** Leaf nav entry. RAC Button under the hood — full keyboard, focus-visible
+ *  ring, and disabled state included. For routing, apply `navItemStyles({...})`
+ *  to a RAC `<Link>` instead. */
+declare function NavItem({ icon, badge, isActive, className, children, ...props }: NavItemProps): react_jsx_runtime.JSX.Element;
+type NavGroupProps = Omit<DisclosureProps, 'children'> & {
+    /** Leading icon for the group head. */
+    icon?: ReactNode;
+    /** Group label rendered next to the icon. */
+    label: ReactNode;
+    /** Children get auto-styled as nested NavItems via context. */
+    children: ReactNode;
+    className?: string;
+};
+/** Collapsible parent. RAC Disclosure handles aria-expanded / aria-controls
+ *  and keyboard activation. Children render inside an indented panel with a
+ *  vertical guide rule and pick up nested styling automatically. */
+declare function NavGroup({ icon, label, children, className, ...props }: NavGroupProps): react_jsx_runtime.JSX.Element;
+
+declare function Popover(props: DialogTriggerProps): react_jsx_runtime.JSX.Element;
+type PopoverContentProps = Omit<PopoverProps, 'children'> & {
+    /** Dialog children. Supports the render-prop form `({ close }) => …`. */
+    children: DialogProps['children'];
+    /** Visual override for the floating panel. */
+    panelClassName?: string;
+    /** When in controlled mode, the element the popover should anchor to. */
+    triggerRef?: RefObject<Element | null>;
+};
+declare function PopoverContent({ children, className, panelClassName, offset, placement, ...props }: PopoverContentProps): react_jsx_runtime.JSX.Element;
+declare function PopoverPanelHeader({ className, children, }: {
+    className?: string;
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function PopoverPanelBody({ className, children, }: {
+    className?: string;
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function PopoverPanelFooter({ className, children, }: {
+    className?: string;
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const progressBarStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            track: string;
+        };
+        md: {
+            track: string;
+        };
+    };
+}, {
+    track: string;
+    fill: string;
+}, undefined, {
+    size: {
+        sm: {
+            track: string;
+        };
+        md: {
+            track: string;
+        };
+    };
+}, {
+    track: string;
+    fill: string;
+}, tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            track: string;
+        };
+        md: {
+            track: string;
+        };
+    };
+}, {
+    track: string;
+    fill: string;
+}, undefined, unknown, unknown, undefined>>;
+type ProgressBarVariants = VariantProps<typeof progressBarStyles>;
+type ProgressBarProps = Omit<ProgressBarProps$1, 'children' | 'className'> & ProgressBarVariants & {
+    className?: string;
+};
+declare function ProgressBar({ size, className, ...props }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+
+type RadioGroupProps = Omit<RadioGroupProps$1, 'children'> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    /** `<Radio>` elements. Function-as-children is not supported at the group level. */
+    children: ReactNode;
+};
+declare function RadioGroup({ label, description, errorMessage, orientation, children, className, ...props }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+type RadioProps = Omit<RadioProps$1, 'children'> & {
+    children?: ReactNode;
+};
+declare function Radio({ children, className, ...props }: RadioProps): react_jsx_runtime.JSX.Element;
+
+type FilterFieldType = Exclude<AttributeType, 'object'>;
+type FilterFieldOption = {
+    value: string;
+    label: string;
+    /** Badge color register, used when this option is rendered as a pill. */
+    variant?: BadgeVariants['variant'];
+};
+type FilterField = {
+    /** Dot-path to the attribute, e.g. `'owner.email'`. Stable identifier. */
+    path: string;
+    /** Full nested label, e.g. `'Owner / Email'`. Used in pickers. */
+    label: string;
+    /** Leaf label only, e.g. `'Email'`. Used in chips. */
+    shortLabel: string;
+    /** Parent label for breadcrumb in chips, e.g. `'Owner'`. Omitted for top-level. */
+    parentLabel?: string;
+    type: FilterFieldType;
+    /** Required when `type === 'enum'`; ignored otherwise. */
+    options?: ReadonlyArray<FilterFieldOption>;
+    /** Hint for `<Input type=…>`. Defaults derived from `type`. */
+    inputType?: 'text' | 'number' | 'date' | 'datetime' | 'email';
+    /**
+     * Relationship metadata for fields that traverse a foreign key into a
+     * related entity. Consumers that auto-emit JOINs (e.g. the report
+     * builder) read this to determine how to join the related table; the
+     * core record-filter UI just renders these like any other field.
+     *
+     * Path convention: `<attribute>.<relatedFieldPath>`, e.g.
+     * `'createdBy.firstName'` or `'accountId.address.city'`. The local FK
+     * attribute name is the prefix (not the related entity slug) so multiple
+     * relationships to the same target stay distinguishable.
+     */
+    relation?: FilterFieldRelation;
+    /**
+     * LUM-34: pointer to the page-layout control that drives editor + chip
+     * rendering. When set, the consumer's `renderValueInput` dispatches via
+     * the control registry (`registry[controlSlug].Filter`) instead of the
+     * lib's built-in type-switch. The lib treats this as opaque metadata —
+     * it never touches the registry itself.
+     */
+    controlSlug?: string;
+    /**
+     * LUM-34: the raw SDK `Attribute` for this field, threaded through to
+     * the descriptor's `Filter` / `Display` components which need full
+     * type+meta context (enum values, relation target, etc.). Typed
+     * `unknown` because the lib has no `@proteos/sdk` dependency;
+     * consumers cast back to `Attribute` in their renderer.
+     */
+    attribute?: unknown;
+    /**
+     * LUM-34: per-field operator allowlist. When set, the operator picker
+     * uses this list verbatim instead of the per-type default in
+     * `operatorsForType(type)`. Lets the registry's per-control overrides
+     * (e.g. `password` → `[]`) flow through to the picker without coupling
+     * the lib to the registry.
+     */
+    filterOperators?: ReadonlyArray<ComparisonOperator>;
+};
+type FilterFieldRelation = {
+    /** Local FK attribute on this entity, e.g. `'accountId'`. Used as JOIN alias. */
+    attribute: string;
+    /** Slug of the related entity table, e.g. `'account'`. */
+    relatedEntitySlug: string;
+    /** Attribute on the related entity to join against, typically `'id'`. */
+    relatedAttribute: string;
+    /** Dot-path of the field on the related entity, e.g. `'name'` or `'address.city'`. */
+    relatedFieldPath: string;
+};
+type ComparisonOperator = 'eq' | 'gt' | 'lt' | 'gte' | 'lte' | 'ne' | 'in' | 'not_in' | 'contains' | 'starts_with' | 'ends_with' | 'empty' | 'not_empty';
+type LogicalOperator = 'and' | 'or';
+type FilterValue = string | string[] | boolean | null;
+type FilterElement = {
+    field: string;
+    operator: ComparisonOperator;
+    /**
+     * In-memory value shape. Richer than the SDK's `string`-only `value`
+     * because the UI needs structured arrays for `in`/`not_in` and booleans
+     * for boolean filters. App-level serializers collapse this back to the
+     * SDK's wire format (pipe-joined strings, etc.) at the boundary.
+     */
+    value: FilterValue;
+};
+type FilterGroup = {
+    logicalOperator: LogicalOperator;
+    elements?: FilterElement[];
+    groups?: FilterGroup[];
+};
+type OperatorArity = 0 | 1 | 'n';
+type OperatorDescriptor = {
+    id: ComparisonOperator;
+    /** Human label shown in the operator picker. */
+    label: string;
+    /** Number of values the operator takes. */
+    arity: OperatorArity;
+    /** Field types this operator applies to. */
+    types: ReadonlyArray<FilterFieldType>;
+};
+
+type AttributePickerProps = {
+    fields: ReadonlyArray<FilterField>;
+    /** Currently picked field path. Empty string means "no field picked yet". */
+    value: string;
+    onChange: (picked: FilterField) => void;
+    autoFocus?: boolean;
+    isDisabled?: boolean;
+    /** Field size. Defaults to `sm` since this picker only ships inside the
+     *  filter row; `md` is exposed for future stand-alone uses. */
+    size?: FieldSize;
+    /** Visual override for the field wrapper. */
+    className?: string;
+};
+declare function AttributePicker({ fields, value, onChange, autoFocus, isDisabled, size, className, }: AttributePickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Per-value-item renderer. Called once per value (twice for arity 'n'
+ * with two items, etc.) AFTER arity orchestration. Return `undefined`
+ * to fall through to the lib default for that item.
+ */
+type ChipValueItemRenderer = (props: {
+    field: FilterField;
+    operator: ComparisonOperator;
+    value: string;
+}) => ReactNode | undefined;
+declare function RenderChipItemProvider({ renderer, children, }: {
+    renderer: ChipValueItemRenderer | undefined;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useRenderChipItem(): ChipValueItemRenderer | undefined;
+type ChipValueProps = {
+    field: FilterField;
+    operator: ComparisonOperator;
+    value: FilterValue;
+    /** Override per-value-item rendering (LUM-34: registry dispatch). */
+    renderItem?: ChipValueItemRenderer;
+};
+declare function ChipValue({ field, operator, value, renderItem }: ChipValueProps): react_jsx_runtime.JSX.Element | null;
+declare function formatValue(field: FilterField, operator: ComparisonOperator, value: FilterValue): string;
+
+type FilterRowProps = {
+    index: number;
+    joiner: LogicalOperator;
+    /** Resolved field metadata. `undefined` means the row's field is unset. */
+    field?: FilterField;
+    element: FilterElement;
+    fields: ReadonlyArray<FilterField>;
+    /** Auto-focus the AttributePicker on mount (e.g. for newly added rows). */
+    autoFocus?: boolean;
+    /** Auto-focus the OperatorPicker on mount. Used right after a pending
+     *  row's field is picked: the row remounts (its `key` changes), and we
+     *  want focus to advance from the AttributePicker to the operator. */
+    autoFocusOperator?: boolean;
+    /** Fires once after a mount that consumed `autoFocusOperator`, so the
+     *  parent can clear its tracking index. */
+    onAutoFocusOperatorConsumed?: () => void;
+    /** Auto-focus the value cell on mount. Forwarded into FilterValueInput,
+     *  whose key-based remount on operator change makes this re-fire reliably
+     *  across leaf types. */
+    autoFocusValue?: boolean;
+    /** Fires once after a mount that consumed `autoFocusValue`. */
+    onAutoFocusValueConsumed?: () => void;
+    /** Fires when the user submits the row from a plain text/number value
+     *  Input (Enter). Used by the builder panel to chain "commit + add new
+     *  pending row". The chip mini-editor passes its own form-submit handler
+     *  here if it wants the same behaviour. */
+    onSubmit?: () => void;
+    onChangeField: (next: FilterField) => void;
+    onChangeOperator: (next: ComparisonOperator) => void;
+    onChangeValue: (next: FilterValue) => void;
+    onRemove: () => void;
+    /** Optional "wrap in group" affordance — when present, a hover-only icon
+     *  appears next to the remove button. Used by the recursive popover panel
+     *  when `isComplexEnabled` is on. */
+    onWrap?: () => void;
+};
+declare function FilterRow({ index, joiner, field, element, fields, autoFocus, autoFocusOperator, onAutoFocusOperatorConsumed, autoFocusValue, onAutoFocusValueConsumed, onSubmit, onChangeField, onChangeOperator, onChangeValue, onRemove, onWrap, }: FilterRowProps): react_jsx_runtime.JSX.Element;
+declare function rebaseRowOnFieldChange(element: FilterElement, next: FilterField): FilterElement;
+declare function rebaseRowOnOperatorChange(element: FilterElement, field: FilterField, nextOperator: ComparisonOperator): FilterElement;
+
+declare function addLeaf(group: FilterGroup, field: FilterField): FilterGroup;
+declare function addPendingLeaf(group: FilterGroup): FilterGroup;
+declare function addSubgroup(group: FilterGroup, joiner?: LogicalOperator): FilterGroup;
+declare function removeLeaf(group: FilterGroup, index: number): FilterGroup;
+declare function removeSubgroup(group: FilterGroup, index: number): FilterGroup;
+declare function updateLeaf(group: FilterGroup, index: number, patch: Partial<FilterElement> | FilterElement): FilterGroup;
+declare function replaceLeaf(group: FilterGroup, index: number, next: FilterElement): FilterGroup;
+declare function updateSubgroup(group: FilterGroup, index: number, next: FilterGroup): FilterGroup;
+declare function wrapLeafInGroup(group: FilterGroup, index: number): FilterGroup;
+declare function setJoiner(group: FilterGroup, joiner: LogicalOperator): FilterGroup;
+declare function countLeaves(group: FilterGroup): number;
+
+/**
+ * Render-prop signature for overriding the default value editor. Called
+ * with everything `FilterValueInput` knows about the leaf. Return a
+ * `ReactNode` to take over rendering, or `undefined` to fall through to
+ * the built-in branches (the common pattern: override one specific
+ * `field.type`, return `undefined` for the rest).
+ *
+ * Used to plug in product-specific editors the lib can't know about —
+ * e.g. a related-record picker that hits the SDK for typeahead.
+ */
+type FilterValueInputRenderer = (props: {
+    field: FilterField;
+    operator: ComparisonOperator;
+    value: FilterValue;
+    onChange: (next: FilterValue) => void;
+    autoFocus?: boolean;
+    isDisabled?: boolean;
+}) => ReactNode | undefined;
+declare function RenderValueInputProvider({ renderer, children, }: {
+    renderer: FilterValueInputRenderer | undefined;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useRenderValueInput(): FilterValueInputRenderer | undefined;
+type FilterValueInputProps = {
+    field: FilterField;
+    operator: ComparisonOperator;
+    value: FilterValue;
+    onChange: (next: FilterValue) => void;
+    isDisabled?: boolean;
+    /** When true, focus the routed leaf on mount. The wrapping `<div>` is
+     *  keyed on `${field.path}-${operator}`, so an operator change remounts
+     *  the leaf and re-fires its `autoFocus` reliably across all six leaf
+     *  branches. Committed values come from props so they survive remount;
+     *  mid-typed drafts (TagInput buffer, DatePicker partial segment,
+     *  Combobox search) are reset — acceptable since the user took the
+     *  deliberate operator-change action. */
+    autoFocus?: boolean;
+    className?: string;
+};
+declare function FilterValueInput({ field, operator, value, onChange, isDisabled, autoFocus, className, }: FilterValueInputProps): react_jsx_runtime.JSX.Element | null;
+
+type OperatorPickerProps = {
+    fieldType: FilterFieldType;
+    value: ComparisonOperator;
+    onChange: (next: ComparisonOperator) => void;
+    isDisabled?: boolean;
+    /** Auto-focus the trigger on mount. Used by the chip mini-editor so focus
+     *  lands on the operator (the field is already chosen, the operator is the
+     *  natural next thing to tweak). */
+    autoFocus?: boolean;
+    /** Field size. Defaults to `sm` to match the filter row. */
+    size?: FieldSize;
+    /** Visual override for the trigger wrapper (sizing). */
+    className?: string;
+    /** Per-field allowlist override (LUM-34). When provided, picks operators
+     *  from this list instead of `operatorsForType(fieldType)`. */
+    operators?: ReadonlyArray<ComparisonOperator>;
+};
+declare function OperatorPicker({ fieldType, value, onChange, isDisabled, autoFocus, size, className, operators, }: OperatorPickerProps): react_jsx_runtime.JSX.Element;
+
+declare const OPERATORS: ReadonlyArray<OperatorDescriptor>;
+declare function operatorsForType(type: FilterFieldType): ReadonlyArray<OperatorDescriptor>;
+declare function operatorById(id: ComparisonOperator): OperatorDescriptor | undefined;
+declare function arityOf(operator: ComparisonOperator): OperatorArity;
+declare function defaultValueFor(type: FilterFieldType, arity: OperatorArity): FilterValue;
+
+type RecordFilterBuilderPanelProps = {
+    /** Display label shown in the header when fewer than 2 rows exist. */
+    entityLabel?: string;
+    fields: ReadonlyArray<FilterField>;
+    filter: FilterGroup;
+    onChange: (next: FilterGroup) => void;
+    onClose: () => void;
+    /** Optional "Save as view" affordance. Hidden when not provided. */
+    onSaveView?: () => void;
+    /** Optional "Expand inline" affordance — surface chips outside the popover. */
+    onExpand?: () => void;
+    showFieldIcons?: boolean;
+    showJoinerToggle?: boolean;
+    /** Opt-in to nested-group affordances: "+ Add group" button, "Wrap in
+     *  group" hover icon on leaves, and rendering of any sub-groups in the
+     *  filter tree. Defaults to `false` for back-compat. */
+    isComplexEnabled?: boolean;
+    /** Optional override for the value editor. Forwarded to RecordFilterEditor. */
+    renderValueInput?: FilterValueInputRenderer;
+};
+declare function RecordFilterBuilderPanel({ entityLabel, fields, filter, onChange, onClose, onSaveView, onExpand, showFieldIcons, showJoinerToggle, isComplexEnabled, renderValueInput, }: RecordFilterBuilderPanelProps): react_jsx_runtime.JSX.Element;
+
+type RecordFilterEditorProps = {
+    fields: ReadonlyArray<FilterField>;
+    filter: FilterGroup;
+    onChange: (next: FilterGroup) => void;
+    /** Show "+ Add group", "Wrap in group", and render nested sub-groups. */
+    isComplexEnabled?: boolean;
+    showFieldIcons?: boolean;
+    showJoinerToggle?: boolean;
+    /** Drop in a pending row on mount when the filter is empty so the user
+     *  lands on an auto-focused AttributePicker. Defaults to `true`. */
+    seedPendingRow?: boolean;
+    /**
+     * Optional override for the value editor. Lets product code plug in
+     * editors the lib can't know about (e.g. a record picker that hits the
+     * SDK). Return `undefined` from the renderer to fall through to the
+     * built-in branches per `(field.type, operator)` combination.
+     */
+    renderValueInput?: FilterValueInputRenderer;
+};
+declare function RecordFilterEditor({ fields, filter, onChange, isComplexEnabled, showFieldIcons, showJoinerToggle, seedPendingRow, renderValueInput, }: RecordFilterEditorProps): react_jsx_runtime.JSX.Element;
+
+type RecordFilterButtonProps = {
+    /** Display label shown in the builder header. */
+    entityLabel?: string;
+    fields: ReadonlyArray<FilterField>;
+    filter: FilterGroup;
+    onChange: (next: FilterGroup) => void;
+    showFieldIcons?: boolean;
+    showJoinerToggle?: boolean;
+    /** Optional save-as-view affordance forwarded to the builder. */
+    onSaveView?: () => void;
+    /** localStorage key shared with `RecordFilterChips`. */
+    storageKey?: string;
+    /** Opt-in to nested-group affordances inside the builder popover. Defaults
+     *  to `false` for back-compat. Forwarded to `RecordFilterBuilderPanel`. */
+    isComplexEnabled?: boolean;
+    /** Optional override for the value editor. Forwarded to the builder panel. */
+    renderValueInput?: FilterValueInputRenderer;
+};
+declare function RecordFilterButton({ entityLabel, fields, filter, onChange, showFieldIcons, showJoinerToggle, onSaveView, storageKey, isComplexEnabled, renderValueInput, }: RecordFilterButtonProps): react_jsx_runtime.JSX.Element | null;
+
+type RecordFilterChipsProps = {
+    fields: ReadonlyArray<FilterField>;
+    filter: FilterGroup;
+    onChange: (next: FilterGroup) => void;
+    showFieldIcons?: boolean;
+    showJoinerToggle?: boolean;
+    /** localStorage key used to share the collapsed/expanded state with the
+     *  RecordFilterButton. Pass the same value to both components. */
+    storageKey?: string;
+    /** Optional override for the value editor inside the chip's mini-editor. */
+    renderValueInput?: FilterValueInputRenderer;
+    /** Optional override for per-value-item rendering inside chip pills.
+     *  Called once per value (or once per item for arity 'n'); returning
+     *  `undefined` falls through to the lib default. LUM-34 wires this to
+     *  the page-layout control registry's Display. */
+    renderChipItem?: ChipValueItemRenderer;
+};
+declare function RecordFilterChips({ fields, filter, onChange, showFieldIcons, showJoinerToggle, storageKey, renderValueInput, renderChipItem, }: RecordFilterChipsProps): react_jsx_runtime.JSX.Element | null;
+
+declare function useShowDetails(storageKey?: string): readonly [boolean, () => void, (next: boolean) => void];
+
+declare const segmentedControlStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            segment: string;
+        };
+        md: {
+            segment: string;
+        };
+    };
+    tone: {
+        default: {
+            segment: string;
+        };
+    };
+}, {
+    group: string;
+    segment: string[];
+}, undefined, {
+    size: {
+        sm: {
+            segment: string;
+        };
+        md: {
+            segment: string;
+        };
+    };
+    tone: {
+        default: {
+            segment: string;
+        };
+    };
+}, {
+    group: string;
+    segment: string[];
+}, tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            segment: string;
+        };
+        md: {
+            segment: string;
+        };
+    };
+    tone: {
+        default: {
+            segment: string;
+        };
+    };
+}, {
+    group: string;
+    segment: string[];
+}, undefined, unknown, unknown, undefined>>;
+type SegmentedControlVariants = VariantProps<typeof segmentedControlStyles>;
+type SegmentedControlOption<T extends Key$1 = Key$1> = {
+    id: T;
+    label: ReactNode;
+    isDisabled?: boolean;
+};
+type SegmentedControlProps<T extends Key$1 = Key$1> = Omit<RadioGroupProps$1, 'children' | 'value' | 'onChange'> & {
+    options: ReadonlyArray<SegmentedControlOption<T>>;
+    value: T;
+    onChange: (value: T) => void;
+    size?: SegmentedControlVariants['size'];
+    /** Focus the selected segment on mount. RAC's RadioGroup doesn't surface
+     *  `autoFocus` itself — it's a per-Radio prop — so we apply it to the
+     *  Radio whose value matches `value`. */
+    autoFocus?: boolean;
+    /** Visual override for the group wrapper. */
+    className?: string;
+};
+declare function SegmentedControl<T extends Key$1>({ options, value, onChange, size, autoFocus, className, orientation, ...props }: SegmentedControlProps<T>): react_jsx_runtime.JSX.Element;
+
+type SelectOption<T extends Key = Key> = {
+    id: T;
+    label: ReactNode;
+    /** Plain-text stand-in for typeahead/accessibility when `label` is a
+     *  ReactNode. Optional for string labels (RAC derives the text itself). */
+    textValue?: string;
+    description?: ReactNode;
+    isDisabled?: boolean;
+};
+type SelectProps<T extends Key = Key> = Omit<SelectProps$1<never>, 'children'> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    options: ReadonlyArray<SelectOption<T>>;
+    /** Optional custom renderer for a ListBoxItem. */
+    renderItem?: (option: SelectOption<T>) => ReactNode;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the trigger box. */
+    appearance?: FieldAppearance;
+    /** Visual override for the trigger only. */
+    triggerClassName?: string;
+    /** Visual override for the popover — e.g. `min-w-[var(--trigger-width)]
+     *  w-max` to size to content when the trigger is intrinsic-width. Defaults
+     *  to matching the trigger width exactly. */
+    popoverClassName?: string;
+};
+declare function Select<T extends Key>({ label, description, errorMessage, placeholder, options, renderItem, size, appearance, triggerClassName, popoverClassName, className, ...props }: SelectProps<T>): react_jsx_runtime.JSX.Element;
+
+declare const separatorStyles: tailwind_variants.TVReturnType<{
+    orientation: {
+        horizontal: string;
+        vertical: string;
+    };
+    variant: {
+        dashed: string;
+        solid: string;
+    };
+}, undefined, "m-0 border-0 border-rule", {
+    orientation: {
+        horizontal: string;
+        vertical: string;
+    };
+    variant: {
+        dashed: string;
+        solid: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    orientation: {
+        horizontal: string;
+        vertical: string;
+    };
+    variant: {
+        dashed: string;
+        solid: string;
+    };
+}, undefined, "m-0 border-0 border-rule", unknown, unknown, undefined>>;
+type SeparatorVariants = VariantProps<typeof separatorStyles>;
+type SeparatorProps = SeparatorProps$1 & {
+    variant?: SeparatorVariants['variant'];
+};
+declare function Separator({ className, orientation, variant, ...props }: SeparatorProps): react_jsx_runtime.JSX.Element;
+
+declare const skeletonStyles: tailwind_variants.TVReturnType<{
+    shape: {
+        rect: string;
+        circle: string;
+        text: string;
+    };
+}, undefined, string[], {
+    shape: {
+        rect: string;
+        circle: string;
+        text: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    shape: {
+        rect: string;
+        circle: string;
+        text: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type SkeletonVariants = VariantProps<typeof skeletonStyles>;
+type SkeletonProps = HTMLAttributes<HTMLDivElement> & SkeletonVariants;
+declare function Skeleton({ shape, className, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+type SuccessAnimationProps = {
+    className?: string;
+};
+declare function SuccessAnimation({ className }: SuccessAnimationProps): react_jsx_runtime.JSX.Element;
+
+type SwitchProps = Omit<SwitchProps$1, 'children'> & {
+    children?: ReactNode;
+    /** Render the label before the track instead of after it. */
+    labelPlacement?: 'start' | 'end';
+};
+declare function Switch({ children, labelPlacement, className, ...props }: SwitchProps): react_jsx_runtime.JSX.Element;
+
+declare const tabsStyles: tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            list: string;
+            trigger: string;
+        };
+        md: {
+            list: string;
+            trigger: string;
+        };
+    };
+}, {
+    root: string;
+    list: string;
+    trigger: string[];
+    panel: string;
+}, undefined, {
+    size: {
+        sm: {
+            list: string;
+            trigger: string;
+        };
+        md: {
+            list: string;
+            trigger: string;
+        };
+    };
+}, {
+    root: string;
+    list: string;
+    trigger: string[];
+    panel: string;
+}, tailwind_variants.TVReturnType<{
+    size: {
+        sm: {
+            list: string;
+            trigger: string;
+        };
+        md: {
+            list: string;
+            trigger: string;
+        };
+    };
+}, {
+    root: string;
+    list: string;
+    trigger: string[];
+    panel: string;
+}, undefined, unknown, unknown, undefined>>;
+type TabsVariants = VariantProps<typeof tabsStyles>;
+type TabsRootProps = Omit<TabsProps, 'children'> & TabsVariants & {
+    children?: ReactNode;
+};
+declare function Root({ size, className, children, ...props }: TabsRootProps): react_jsx_runtime.JSX.Element;
+type TabsListProps = Omit<TabListProps<object>, 'children'> & TabsVariants & {
+    children?: ReactNode;
+};
+declare function List({ size, className, children, ...props }: TabsListProps): react_jsx_runtime.JSX.Element;
+type TabsTriggerProps = Omit<TabProps, 'children'> & TabsVariants & {
+    children?: ReactNode;
+};
+declare function Trigger({ size, className, children, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+type TabsPanelProps = Omit<TabPanelProps, 'children'> & {
+    children?: ReactNode;
+};
+declare function Panel({ className, children, ...props }: TabsPanelProps): react_jsx_runtime.JSX.Element;
+declare const Tabs: typeof Root & {
+    Root: typeof Root;
+    List: typeof List;
+    Trigger: typeof Trigger;
+    Panel: typeof Panel;
+};
+
+type TagInputProps = {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    /** Placeholder shown in the trailing input when there are no tags. */
+    placeholder?: string;
+    /** Underlying `<input>` type. Use `'number'` to constrain numeric tags. */
+    inputType?: 'text' | 'number';
+    value: string[];
+    onChange: (next: string[]) => void;
+    isDisabled?: boolean;
+    isInvalid?: boolean;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+    /** Focus the trailing input on mount. Used by the filter-row chain so
+     *  picking an operator with arity 'n' (and a non-enum field) lands focus
+     *  directly on the tag-entry input. */
+    autoFocus?: boolean;
+    /** Visual override for the field wrapper. */
+    className?: string;
+};
+declare function TagInput({ label, description, errorMessage, placeholder, inputType, value, onChange, isDisabled, isInvalid, size, appearance, autoFocus, className, }: TagInputProps): react_jsx_runtime.JSX.Element;
+
+type TextareaProps = TextFieldProps & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    /** Visible rows. Height can still grow via vertical resize (consumer). */
+    rows?: number;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+    /** Extra props forwarded to the underlying <textarea>. */
+    textareaProps?: Omit<TextAreaProps, 'className'>;
+    /** Visual override for the textarea control only. */
+    textareaClassName?: string;
+};
+declare function Textarea({ label, description, errorMessage, placeholder, rows, size, appearance, textareaProps, textareaClassName, className, ...props }: TextareaProps): react_jsx_runtime.JSX.Element;
+
+type TimeFieldProps<T extends TimeValue> = TimeFieldProps$1<T> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    /** Field size. Defaults to `md`. */
+    size?: FieldSize;
+    /** Chrome variant. Defaults to `field`. `cell` flattens the box. */
+    appearance?: FieldAppearance;
+};
+declare function TimeField<T extends TimeValue = TimeValue>({ label, description, errorMessage, size, appearance, className, ...props }: TimeFieldProps<T>): react_jsx_runtime.JSX.Element;
+
+/** Stateful root. RAC handles hover delay + focus visibility.
+ *
+ *  - `delay` — ms of hover before the tooltip opens. Keyboard focus opens
+ *    instantly regardless. Default **500** (RAC's own default is 1500 which
+ *    feels sluggish for a dense app). Set `0` for instant tooltips.
+ *  - `closeDelay` — ms after the pointer leaves before the tooltip hides.
+ *    Default **0** (close immediately). Raise it if adjacent targets share
+ *    tooltips and you want them to chain without re-waiting.
+ */
+declare function TooltipTrigger({ delay, closeDelay, ...props }: TooltipTriggerComponentProps): react_jsx_runtime.JSX.Element;
+type TooltipProps = TooltipProps$1;
+declare function Tooltip({ className, offset, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { ATTRIBUTE_TYPES, ATTRIBUTE_TYPE_ICONS, type ActionsColumnOptions, AttachmentChip, type AttachmentChipProps, type AttachmentChipVariants, AttributePicker, type AttributePickerProps, AttributeType, AttributeTypeIcon, type AttributeTypeIconProps, Avatar, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, type AvatarGroupVariants, type AvatarProps, type AvatarVariants, Badge, BadgeMultiSelect, type BadgeMultiSelectOption, type BadgeMultiSelectProps, type BadgeProps, type BadgeVariants, BooleanCell, type BooleanCellProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, type ButtonVariants, COLUMN_DRAG_KIND, Card, CardBody, CardContent, CardEyebrow, CardFeatureTitle, CardFooter, CardHeader, type CardProps, CardTitle, type CardVariants, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, ChipValue, type ChipValueItemRenderer, type ChipValueProps, type ColumnDragData, Combobox, type ComboboxOption, type ComboboxProps, Command, CommandHint, type CommandHintProps, type CommandHintTone, type CommandProps, type ComparisonOperator, CurrencyInput, type CurrencyInputOption, type CurrencyInputProps, type CurrencyInputValue, DataTable, DataTableEmpty, type DataTableEmptyProps, DataTableError, type DataTableErrorProps, type DataTableProps, DataTableSkeleton, type DataTableSkeletonProps, DateCell, type DateCellProps, DatePicker, type DatePickerProps, DateTimeCell, type DateTimeCellProps, DateTimePicker, type DateTimePickerProps, EmptyState, type EmptyStateProps, type EmptyStateVariants, ErrorAnimation, type ErrorAnimationProps, type FieldAppearance, FieldCaret, type FieldControlVariants, type FieldSize, FileField, type FileFieldProps, type FileFieldValue, FileViewer, FileViewerFallbackCard, type FileViewerFallbackCardProps, type FileViewerFallbackCardVariants, type FileViewerKind, type FileViewerProps, type FileViewerVariants, type FilterElement, type FilterField, type FilterFieldOption, type FilterFieldRelation, type FilterFieldType, type FilterGroup, FilterRow, type FilterRowProps, type FilterValue, FilterValueInput, type FilterValueInputProps, type FilterValueInputRenderer, ImageAttachment, type ImageAttachmentProps, type ImageAttachmentVariants, ImageLightbox, type ImageLightboxProps, type ImageLightboxVariants, type InfiniteQueryLike, Input, type InputProps, Kbd, type KbdProps, type KeyCombo, LinkCell, type LinkCellProps, type LogicalOperator, Menu, MenuItem, type MenuItemProps, MenuPopover, type MenuPopoverProps, type MenuProps, MenuTrigger, Modal, ModalBody, ModalContent, type ModalContentProps, ModalDescription, ModalFooter, ModalHeader, ModalTitle, MultiSelect, type MultiSelectOption, type MultiSelectProps, NavGroup, type NavGroupProps, NavItem, type NavItemProps, type NavItemVariants, NavSection, type NavSectionProps, OPERATORS, type OperatorArity, type OperatorDescriptor, OperatorPicker, type OperatorPickerProps, PROTECTED_COMBOS, Popover, PopoverContent, type PopoverContentProps, PopoverPanelBody, PopoverPanelFooter, PopoverPanelHeader, PressableCard, type PressableCardProps, ProgressBar, type ProgressBarProps, type ProgressBarVariants, Radio, RadioGroup, type RadioGroupProps, type RadioProps, RecordFilterBuilderPanel, type RecordFilterBuilderPanelProps, RecordFilterButton, type RecordFilterButtonProps, RecordFilterChips, type RecordFilterChipsProps, RecordFilterEditor, type RecordFilterEditorProps, RenderChipItemProvider, RenderValueInputProvider, SegmentedControl, type SegmentedControlOption, type SegmentedControlProps, type SegmentedControlVariants, Select, type SelectOption, type SelectProps, Separator, type SeparatorProps, Skeleton, type SkeletonProps, type SkeletonVariants, type SortDirection, SubmenuTrigger, SuccessAnimation, type SuccessAnimationProps, Switch, type SwitchProps, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableHeader, TableHeaderCell, type TableHeaderCellProps, type TableHeaderProps, TableHeaderSpacer, type TableProps, TableRow, type TableRowProps, TableScroller, type TableVariants, Tabs, type TabsListProps, type TabsPanelProps, type TabsRootProps, type TabsTriggerProps, type TabsVariants, TagInput, type TagInputProps, Textarea, type TextareaProps, TimeField, type TimeFieldProps, Tooltip, type TooltipProps, TooltipTrigger, TruncateCell, type TruncateCellProps, type UseCommandOptions, type UseEscapeKeyOptions, type UseInfiniteScrollSentinelOptions, addLeaf as addFilterLeaf, addPendingLeaf, addSubgroup, arityOf, attachmentChipStyles, avatarGroupStyles, avatarStyles, badgeStyles, buttonStyles, cardStyles, cn, countLeaves, defaultValueFor, emptyStateStyles, fieldControlStyles, fieldErrorStyles, fieldHintStyles, fieldLabelStyles, fileViewerFallbackCardStyles, fileViewerStyles, formatFileSize, formatValue, iconForContentType, imageAttachmentStyles, imageLightboxStyles, isColumnDragData, isEditableTarget, isPreviewableImageName, makeActionsColumn, navItemStyles, operatorById, operatorsForType, parseCombo, progressBarStyles, rebaseRowOnFieldChange, rebaseRowOnOperatorChange, removeLeaf, removeSubgroup, replaceLeaf, segmentedControlStyles, setJoiner, skeletonStyles, tableCellStyles, tableHeaderCellStyles, tabsStyles, updateLeaf, updateSubgroup, useAttributeTypeIcon, useCommand, useDiscoveryActive, useEscapeKey, useInfiniteScrollSentinel, useRenderChipItem, useRenderValueInput, useShowDetails, viewerKindForContentType, wrapLeafInGroup };