@ember-home/unbound-styleguide 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1177 @@
+import { ClassValue } from 'clsx';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { VariantProps } from 'class-variance-authority';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as React$1 from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { Command as Command$1 } from 'cmdk';
+import { DayPicker } from 'react-day-picker';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { ColumnDef } from '@tanstack/react-table';
+export { ColumnDef, ColumnFiltersState, Row, RowSelectionState, SortingState } from '@tanstack/react-table';
+
+/**
+ * Merges class names using clsx and tailwind-merge.
+ * Handles conditional classes and deduplicates Tailwind utility conflicts.
+ */
+declare function mergeClasses(...inputs: ClassValue[]): string;
+
+declare function useIsMobile(): boolean;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+type ButtonVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+type ButtonSize = "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg";
+type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof buttonVariants> & {
+    /**
+     * When true, the button will render as a Slot, allowing you to pass your own element
+     */
+    asChild?: boolean;
+};
+
+declare function Button({ className, variant, size, asChild, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuProps = React.ComponentProps<typeof DropdownMenuPrimitive.Root>;
+type DropdownMenuTriggerProps = React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>;
+type DropdownMenuContentProps = React.ComponentProps<typeof DropdownMenuPrimitive.Content>;
+type DropdownMenuItemProps = React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+};
+type DropdownMenuLabelProps = React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+};
+type DropdownMenuSubTriggerProps = React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+};
+declare function DropdownMenu({ ...props }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: DropdownMenuTriggerProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: DropdownMenuContentProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: DropdownMenuItemProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: DropdownMenuLabelProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: DropdownMenuSubTriggerProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertVariant = "default" | "destructive";
+type AlertProps = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>;
+type AlertTitleProps = React.HTMLAttributes<HTMLDivElement>;
+type AlertDescriptionProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Alert({ className, variant, ...props }: AlertProps): react_jsx_runtime.JSX.Element;
+declare function AlertTitle({ className, ...props }: AlertTitleProps): react_jsx_runtime.JSX.Element;
+declare function AlertDescription({ className, ...props }: AlertDescriptionProps): react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariant = "default" | "secondary" | "destructive" | "outline";
+type BadgeProps = React.HTMLAttributes<HTMLSpanElement> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+};
+declare function Badge({ className, variant, asChild, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+type SkeletonProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Skeleton({ className, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+type TooltipProviderProps = React.ComponentProps<typeof TooltipPrimitive.Provider>;
+type TooltipProps = React.ComponentProps<typeof TooltipPrimitive.Root>;
+type TooltipTriggerProps = React.ComponentProps<typeof TooltipPrimitive.Trigger>;
+type TooltipContentProps = React.ComponentProps<typeof TooltipPrimitive.Content>;
+declare function TooltipProvider({ delayDuration, ...props }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
+declare function Tooltip({ ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+declare function TooltipTrigger({ ...props }: TooltipTriggerProps): react_jsx_runtime.JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: TooltipContentProps): react_jsx_runtime.JSX.Element;
+
+interface ToasterProps {
+    /** Position of the toast container */
+    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center";
+}
+/**
+ * Toast notification provider.
+ * Mount once at the app root (e.g., in the main layout).
+ */
+declare function Toaster({ position }: ToasterProps): react_jsx_runtime.JSX.Element;
+
+interface ToastOptions {
+    /** Secondary text below the main message */
+    description?: string;
+    /** Override default duration in milliseconds */
+    duration?: number;
+    /** Action button configuration */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+/**
+ * Display a success toast.
+ * Use for: completed actions, saved changes, successful operations.
+ */
+declare function success(message: string, options?: ToastOptions): void;
+/**
+ * Display an error toast.
+ * Use for: failed operations, validation errors, API failures.
+ * Note: For errors requiring user action, consider a modal instead.
+ */
+declare function error(message: string, options?: ToastOptions): void;
+/**
+ * Display a warning toast.
+ * Use for: partial success, skipped items, non-critical issues.
+ */
+declare function warning(message: string, options?: ToastOptions): void;
+/**
+ * Display an info toast.
+ * Use for: neutral updates, tips, background status changes.
+ */
+declare function info(message: string, options?: ToastOptions): void;
+/**
+ * Display a loading toast that can be updated.
+ * Returns a toast ID for later dismissal or update.
+ */
+declare function loading(message: string): string | number;
+/**
+ * Dismiss a specific toast by ID or dismiss all toasts.
+ */
+declare function dismiss(toastId?: string | number): void;
+/**
+ * Promise-based toast for async operations.
+ * Shows loading state, then success or error based on promise result.
+ */
+declare function promise<T>(promiseToWrap: Promise<T>, messages: {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((error: unknown) => string);
+}): Promise<T>;
+declare const notify: {
+    success: typeof success;
+    error: typeof error;
+    warning: typeof warning;
+    info: typeof info;
+    loading: typeof loading;
+    dismiss: typeof dismiss;
+    promise: typeof promise;
+};
+
+type CardProps = React.HTMLAttributes<HTMLDivElement>;
+type CardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type CardTitleProps = React.HTMLAttributes<HTMLDivElement>;
+type CardDescriptionProps = React.HTMLAttributes<HTMLDivElement>;
+type CardActionProps = React.HTMLAttributes<HTMLDivElement>;
+type CardContentProps = React.HTMLAttributes<HTMLDivElement>;
+type CardFooterProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Card({ className, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ className, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ className, ...props }: CardTitleProps): react_jsx_runtime.JSX.Element;
+declare function CardDescription({ className, ...props }: CardDescriptionProps): react_jsx_runtime.JSX.Element;
+declare function CardAction({ className, ...props }: CardActionProps): react_jsx_runtime.JSX.Element;
+declare function CardContent({ className, ...props }: CardContentProps): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ className, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
+
+type SeparatorProps = React.ComponentProps<typeof SeparatorPrimitive.Root>;
+declare function Separator({ className, orientation, decorative, ...props }: SeparatorProps): react_jsx_runtime.JSX.Element;
+
+type CollapsibleProps = React.ComponentProps<typeof CollapsiblePrimitive.Root>;
+type CollapsibleTriggerProps = React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>;
+type CollapsibleContentProps = React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>;
+declare function Collapsible({ ...props }: CollapsibleProps): react_jsx_runtime.JSX.Element;
+declare function CollapsibleTrigger({ ...props }: CollapsibleTriggerProps): react_jsx_runtime.JSX.Element;
+declare function CollapsibleContent({ ...props }: CollapsibleContentProps): react_jsx_runtime.JSX.Element;
+
+interface UtilityBarAction {
+    /** Button label */
+    label: string;
+    /** Click handler */
+    onClick: () => void;
+    /** Button variant */
+    variant?: "default" | "secondary" | "outline" | "ghost" | "destructive";
+    /** Whether button is disabled */
+    disabled?: boolean;
+    /** Optional icon to show before label */
+    icon?: React$1.ReactNode;
+}
+interface UtilityBarProps {
+    /** Additional class names */
+    className?: string;
+    /**
+     * Whether to show the filter button.
+     * @default true if filterContent is provided, false otherwise
+     */
+    showFilter?: boolean;
+    /**
+     * Controlled mode: current expanded state.
+     * Use with `onFilterExpandedChange` for controlled behavior.
+     */
+    filterExpanded?: boolean;
+    /**
+     * Controlled mode: callback when expanded state changes.
+     * If provided, the component is controlled and `filterExpanded` is the source of truth.
+     * If omitted, the component manages expansion state internally.
+     */
+    onFilterExpandedChange?: (expanded: boolean) => void;
+    /**
+     * Uncontrolled mode: initial expanded state.
+     * Only used when `onFilterExpandedChange` is not provided.
+     * @default false
+     */
+    defaultFilterExpanded?: boolean;
+    /** Content to render in the filter panel when expanded */
+    filterContent?: React$1.ReactNode;
+    /**
+     * Custom label for the filter button.
+     * @default "Filter"
+     */
+    filterLabel?: string;
+    /** Number of active filters (shows badge on button) */
+    activeFilterCount?: number;
+    /**
+     * Whether to show the date range picker slot.
+     * @default false
+     */
+    showDateRange?: boolean;
+    /** Date range picker component */
+    dateRangeContent?: React$1.ReactNode;
+    /**
+     * Whether to show the search field.
+     * When true, `onSearchChange` must be provided.
+     * @default false
+     */
+    showSearch?: boolean;
+    /**
+     * Current search value.
+     * @default ""
+     */
+    searchValue?: string;
+    /**
+     * Callback when search value changes.
+     * Required when `showSearch` is true.
+     */
+    onSearchChange?: (value: string) => void;
+    /**
+     * Search placeholder text.
+     * @default "Search..."
+     */
+    searchPlaceholder?: string;
+    /** Primary action button config */
+    primaryAction?: UtilityBarAction;
+    /** Secondary action button config */
+    secondaryAction?: UtilityBarAction;
+    /** Additional custom actions (rendered between search and secondary action) */
+    additionalActions?: React$1.ReactNode;
+    /** Content rendered below the utility bar */
+    children?: React$1.ReactNode;
+}
+interface DateRangePlaceholderProps {
+    className?: string;
+}
+declare function DateRangePlaceholder({ className }: DateRangePlaceholderProps): react_jsx_runtime.JSX.Element;
+declare function UtilityBar({ className, showFilter, filterExpanded, onFilterExpandedChange, defaultFilterExpanded, filterContent, filterLabel, activeFilterCount, showDateRange, dateRangeContent, showSearch, searchValue, onSearchChange, searchPlaceholder, primaryAction, secondaryAction, additionalActions, children, }: UtilityBarProps): react_jsx_runtime.JSX.Element;
+
+type DialogProps = React.ComponentProps<typeof DialogPrimitive.Root>;
+type DialogTriggerProps = React.ComponentProps<typeof DialogPrimitive.Trigger>;
+type DialogPortalProps = React.ComponentProps<typeof DialogPrimitive.Portal>;
+type DialogCloseProps = React.ComponentProps<typeof DialogPrimitive.Close>;
+type DialogOverlayProps = React.ComponentProps<typeof DialogPrimitive.Overlay>;
+type DialogContentProps = React.ComponentProps<typeof DialogPrimitive.Content> & {
+    showCloseButton?: boolean;
+};
+type DialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogTitleProps = React.ComponentProps<typeof DialogPrimitive.Title>;
+type DialogDescriptionProps = React.ComponentProps<typeof DialogPrimitive.Description>;
+declare function Dialog({ ...props }: DialogProps): react_jsx_runtime.JSX.Element;
+declare function DialogTrigger({ ...props }: DialogTriggerProps): react_jsx_runtime.JSX.Element;
+declare function DialogPortal({ ...props }: DialogPortalProps): react_jsx_runtime.JSX.Element;
+declare function DialogClose({ ...props }: DialogCloseProps): react_jsx_runtime.JSX.Element;
+declare function DialogOverlay({ className, ...props }: DialogOverlayProps): react_jsx_runtime.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: DialogContentProps): react_jsx_runtime.JSX.Element;
+declare function DialogHeader({ className, ...props }: DialogHeaderProps): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ className, ...props }: DialogFooterProps): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, ...props }: DialogTitleProps): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, ...props }: DialogDescriptionProps): react_jsx_runtime.JSX.Element;
+
+type PopoverProps = React.ComponentProps<typeof PopoverPrimitive.Root>;
+type PopoverTriggerProps = React.ComponentProps<typeof PopoverPrimitive.Trigger>;
+type PopoverContentProps = React.ComponentProps<typeof PopoverPrimitive.Content>;
+type PopoverAnchorProps = React.ComponentProps<typeof PopoverPrimitive.Anchor>;
+declare function Popover({ ...props }: PopoverProps): react_jsx_runtime.JSX.Element;
+declare function PopoverTrigger({ ...props }: PopoverTriggerProps): react_jsx_runtime.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: PopoverContentProps): react_jsx_runtime.JSX.Element;
+declare function PopoverAnchor({ ...props }: PopoverAnchorProps): react_jsx_runtime.JSX.Element;
+
+type SheetProps = React.ComponentProps<typeof DialogPrimitive.Root>;
+type SheetTriggerProps = React.ComponentProps<typeof DialogPrimitive.Trigger>;
+type SheetCloseProps = React.ComponentProps<typeof DialogPrimitive.Close>;
+type SheetPortalProps = React.ComponentProps<typeof DialogPrimitive.Portal>;
+type SheetOverlayProps = React.ComponentProps<typeof DialogPrimitive.Overlay>;
+type SheetContentProps = React.ComponentProps<typeof DialogPrimitive.Content> & {
+    side?: "top" | "right" | "bottom" | "left";
+};
+type SheetHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type SheetFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type SheetTitleProps = React.ComponentProps<typeof DialogPrimitive.Title>;
+type SheetDescriptionProps = React.ComponentProps<typeof DialogPrimitive.Description>;
+declare function Sheet({ ...props }: SheetProps): react_jsx_runtime.JSX.Element;
+declare function SheetTrigger({ ...props }: SheetTriggerProps): react_jsx_runtime.JSX.Element;
+declare function SheetClose({ ...props }: SheetCloseProps): react_jsx_runtime.JSX.Element;
+declare function SheetPortal({ ...props }: SheetPortalProps): react_jsx_runtime.JSX.Element;
+declare function SheetOverlay({ className, ...props }: SheetOverlayProps): react_jsx_runtime.JSX.Element;
+declare function SheetContent({ className, children, side, ...props }: SheetContentProps): react_jsx_runtime.JSX.Element;
+declare function SheetHeader({ className, ...props }: SheetHeaderProps): react_jsx_runtime.JSX.Element;
+declare function SheetFooter({ className, ...props }: SheetFooterProps): react_jsx_runtime.JSX.Element;
+declare function SheetTitle({ className, ...props }: SheetTitleProps): react_jsx_runtime.JSX.Element;
+declare function SheetDescription({ className, ...props }: SheetDescriptionProps): react_jsx_runtime.JSX.Element;
+
+interface BottomSheetProps {
+    /** Whether the modal is open */
+    open: boolean;
+    /** Callback when open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Modal title - can be string or ReactNode */
+    title?: React$1.ReactNode;
+    /** Optional accessible description for screen readers */
+    description?: React$1.ReactNode;
+    /** Modal content */
+    children: React$1.ReactNode;
+    /** Optional sticky bottom actions */
+    actions?: React$1.ReactNode;
+    /** Whether clicking outside closes the modal (default: true) */
+    closeOnOutsideClick?: boolean;
+    /** Additional className for the overlay */
+    overlayClassName?: string;
+    /** Additional className for the content container */
+    contentClassName?: string;
+    /** Additional className for the header */
+    headerClassName?: string;
+    /** Additional className for the scrollable body */
+    bodyClassName?: string;
+    /** Additional className for the actions footer */
+    actionsClassName?: string;
+}
+declare function BottomSheet({ open, onOpenChange, title, description, children, actions, closeOnOutsideClick, overlayClassName, contentClassName, headerClassName, bodyClassName, actionsClassName, }: BottomSheetProps): react_jsx_runtime.JSX.Element;
+interface BottomSheetSectionProps {
+    /** Section title */
+    title: string;
+    /** Optional section description */
+    description?: string;
+    /** Section content */
+    children: React$1.ReactNode;
+    /** Additional className */
+    className?: string;
+}
+declare function BottomSheetSection({ title, description, children, className, }: BottomSheetSectionProps): react_jsx_runtime.JSX.Element;
+interface BottomSheetDividerProps {
+    className?: string;
+}
+declare function BottomSheetDivider({ className }: BottomSheetDividerProps): react_jsx_runtime.JSX.Element;
+interface BottomSheetLayoutProps {
+    /** Layout content - should contain BottomSheetSidebar and BottomSheetMain */
+    children: React$1.ReactNode;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Container for split layout within BottomSheet.
+ * Use with BottomSheetSidebar and BottomSheetMain for sidebar + main content layouts.
+ *
+ * @example
+ * <BottomSheet open={open} onOpenChange={setOpen} title="Settings">
+ *   <BottomSheetLayout>
+ *     <BottomSheetSidebar>
+ *       <nav>...</nav>
+ *     </BottomSheetSidebar>
+ *     <BottomSheetMain>
+ *       <SettingsContent />
+ *     </BottomSheetMain>
+ *   </BottomSheetLayout>
+ * </BottomSheet>
+ */
+declare function BottomSheetLayout({ children, className }: BottomSheetLayoutProps): react_jsx_runtime.JSX.Element;
+interface BottomSheetSidebarProps {
+    /** Sidebar content */
+    children: React$1.ReactNode;
+    /** Width of sidebar (default: "w-64") */
+    width?: string;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Sidebar panel for split layout. Place inside BottomSheetLayout.
+ */
+declare function BottomSheetSidebar({ children, width, className, }: BottomSheetSidebarProps): react_jsx_runtime.JSX.Element;
+interface BottomSheetMainProps {
+    /** Main content */
+    children: React$1.ReactNode;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Main content area for split layout. Place inside BottomSheetLayout.
+ */
+declare function BottomSheetMain({ children, className }: BottomSheetMainProps): react_jsx_runtime.JSX.Element;
+/** @deprecated Use BottomSheet instead */
+declare const GlobalSettingsModal: typeof BottomSheet;
+/** @deprecated Use BottomSheetProps instead */
+type GlobalSettingsModalProps = BottomSheetProps;
+/** @deprecated Use BottomSheetSection instead */
+declare const GlobalSettingsModalSection: typeof BottomSheetSection;
+/** @deprecated Use BottomSheetSectionProps instead */
+type GlobalSettingsModalSectionProps = BottomSheetSectionProps;
+/** @deprecated Use BottomSheetDivider instead */
+declare const GlobalSettingsModalDivider: typeof BottomSheetDivider;
+/** @deprecated Use BottomSheetDividerProps instead */
+type GlobalSettingsModalDividerProps = BottomSheetDividerProps;
+
+type CheckboxProps = React.ComponentProps<typeof CheckboxPrimitive.Root>;
+declare function Checkbox({ className, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+type InputProps = React$1.InputHTMLAttributes<HTMLInputElement>;
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+type LabelProps = React.ComponentProps<typeof LabelPrimitive.Root>;
+declare function Label({ className, ...props }: LabelProps): react_jsx_runtime.JSX.Element;
+
+type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+declare function Textarea({ className, ...props }: TextareaProps): react_jsx_runtime.JSX.Element;
+
+type SelectProps = React.ComponentProps<typeof SelectPrimitive.Root>;
+type SelectGroupProps = React.ComponentProps<typeof SelectPrimitive.Group>;
+type SelectValueProps = React.ComponentProps<typeof SelectPrimitive.Value>;
+type SelectTriggerProps = React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+};
+type SelectContentProps = React.ComponentProps<typeof SelectPrimitive.Content>;
+type SelectLabelProps = React.ComponentProps<typeof SelectPrimitive.Label>;
+type SelectItemProps = React.ComponentProps<typeof SelectPrimitive.Item>;
+type SelectSeparatorProps = React.ComponentProps<typeof SelectPrimitive.Separator>;
+declare function Select({ ...props }: SelectProps): react_jsx_runtime.JSX.Element;
+declare function SelectGroup({ ...props }: SelectGroupProps): react_jsx_runtime.JSX.Element;
+declare function SelectValue({ ...props }: SelectValueProps): react_jsx_runtime.JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: SelectTriggerProps): react_jsx_runtime.JSX.Element;
+declare function SelectContent({ className, children, position, align, ...props }: SelectContentProps): react_jsx_runtime.JSX.Element;
+declare function SelectLabel({ className, ...props }: SelectLabelProps): react_jsx_runtime.JSX.Element;
+declare function SelectItem({ className, children, ...props }: SelectItemProps): react_jsx_runtime.JSX.Element;
+declare function SelectSeparator({ className, ...props }: SelectSeparatorProps): react_jsx_runtime.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): react_jsx_runtime.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): react_jsx_runtime.JSX.Element;
+
+type CommandProps = React.ComponentProps<typeof Command$1>;
+type CommandDialogProps = React.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+};
+type CommandInputProps = React.ComponentProps<typeof Command$1.Input>;
+type CommandListProps = React.ComponentProps<typeof Command$1.List>;
+type CommandEmptyProps = React.ComponentProps<typeof Command$1.Empty>;
+type CommandGroupProps = React.ComponentProps<typeof Command$1.Group>;
+type CommandSeparatorProps = React.ComponentProps<typeof Command$1.Separator>;
+type CommandItemProps = React.ComponentProps<typeof Command$1.Item>;
+type CommandShortcutProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Command({ className, ...props }: CommandProps): react_jsx_runtime.JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: CommandDialogProps): react_jsx_runtime.JSX.Element;
+declare function CommandInput({ className, ...props }: CommandInputProps): react_jsx_runtime.JSX.Element;
+declare function CommandList({ className, ...props }: CommandListProps): react_jsx_runtime.JSX.Element;
+declare function CommandEmpty({ ...props }: CommandEmptyProps): react_jsx_runtime.JSX.Element;
+declare function CommandGroup({ className, ...props }: CommandGroupProps): react_jsx_runtime.JSX.Element;
+declare function CommandSeparator({ className, ...props }: CommandSeparatorProps): react_jsx_runtime.JSX.Element;
+declare function CommandItem({ className, ...props }: CommandItemProps): react_jsx_runtime.JSX.Element;
+declare function CommandShortcut({ className, ...props }: CommandShortcutProps): react_jsx_runtime.JSX.Element;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface ComboboxProps {
+    /** The currently selected value */
+    value?: string;
+    /** Callback when value changes */
+    onValueChange?: (value: string) => void;
+    /** Placeholder text when no value is selected */
+    placeholder?: string;
+    /** Search input placeholder */
+    searchPlaceholder?: string;
+    /** Text shown when no results match search */
+    emptyText?: string;
+    /** Available options */
+    options: ComboboxOption[];
+    /** Whether the combobox is disabled */
+    disabled?: boolean;
+    /** Size variant - matches Select sizing */
+    size?: "sm" | "default";
+    /** Additional class names for the trigger */
+    className?: string;
+    /** Alignment of the popover content */
+    align?: "start" | "center" | "end";
+}
+declare function Combobox({ value, onValueChange, placeholder, searchPlaceholder, emptyText, options, disabled, size, className, align, }: ComboboxProps): react_jsx_runtime.JSX.Element;
+interface ComboboxTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    size?: "sm" | "default";
+}
+declare function ComboboxTrigger({ className, size, children, ...props }: ComboboxTriggerProps): react_jsx_runtime.JSX.Element;
+interface ComboboxContentProps extends React$1.ComponentProps<typeof PopoverContent> {
+}
+declare function ComboboxContent({ className, children, align, ...props }: ComboboxContentProps): react_jsx_runtime.JSX.Element;
+interface ComboboxInputProps extends React$1.ComponentProps<typeof CommandInput> {
+}
+declare function ComboboxInput({ ...props }: ComboboxInputProps): react_jsx_runtime.JSX.Element;
+interface ComboboxEmptyProps extends React$1.ComponentProps<typeof CommandEmpty> {
+}
+declare function ComboboxEmpty({ ...props }: ComboboxEmptyProps): react_jsx_runtime.JSX.Element;
+interface ComboboxGroupProps extends React$1.ComponentProps<typeof CommandGroup> {
+}
+declare function ComboboxGroup({ ...props }: ComboboxGroupProps): react_jsx_runtime.JSX.Element;
+interface ComboboxListProps extends React$1.ComponentProps<typeof CommandList> {
+}
+declare function ComboboxList({ ...props }: ComboboxListProps): react_jsx_runtime.JSX.Element;
+interface ComboboxItemProps extends React$1.ComponentProps<typeof CommandItem> {
+    /** Whether this item is currently selected */
+    selected?: boolean;
+}
+declare function ComboboxItem({ className, children, selected, ...props }: ComboboxItemProps): react_jsx_runtime.JSX.Element;
+
+type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, navLayout, startMonth, endMonth, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+
+interface DatePickerProps {
+    value: Date | null;
+    onChange: (date: Date | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    error?: string;
+}
+declare function DatePicker({ value, onChange, placeholder, disabled, readOnly, className, error: externalError, }: DatePickerProps): react_jsx_runtime.JSX.Element;
+
+type DayOfWeek = "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday" | "sunday";
+type WeekOfMonth = 1 | 2 | 3 | 4 | -1;
+type Recurrence = {
+    type: "daily";
+} | {
+    type: "weekly";
+    interval: number;
+    days: DayOfWeek[];
+} | {
+    type: "monthlyDate";
+    interval: number;
+    dayOfMonth: number;
+} | {
+    type: "monthlyWeekday";
+    interval: number;
+    week: WeekOfMonth;
+    day: DayOfWeek;
+} | {
+    type: "yearly";
+    interval: number;
+};
+type EndCondition = {
+    type: "date";
+    value: Date;
+} | {
+    type: "occurrences";
+    value: number;
+} | null;
+interface RecurrenceConfig {
+    startDate: Date | null;
+    recurrence: Recurrence | null;
+    endCondition: EndCondition;
+}
+interface RecurrenceSchedulerProps {
+    value: RecurrenceConfig;
+    onChange: (config: RecurrenceConfig) => void;
+    startDate: Date | null;
+    onStartDateChange?: (date: Date | null) => void;
+    disabled?: boolean;
+    showEndOptions?: boolean;
+    className?: string;
+}
+declare const DEFAULT_RECURRENCE_CONFIG: RecurrenceConfig;
+declare function createDefaultRecurrence(type: Recurrence["type"], startDate: Date | null): Recurrence;
+type FrequencyOption = Recurrence["type"] | "none";
+declare const DAYS_OF_WEEK: {
+    value: DayOfWeek;
+    label: string;
+    short: string;
+}[];
+declare const WEEKS_OF_MONTH: {
+    value: WeekOfMonth;
+    label: string;
+}[];
+declare const FREQUENCY_OPTIONS: {
+    value: FrequencyOption;
+    label: string;
+    description: string;
+}[];
+
+declare function RecurrenceScheduler({ value, onChange, startDate, onStartDateChange, disabled, className, }: RecurrenceSchedulerProps): react_jsx_runtime.JSX.Element;
+
+interface UseRecurrenceSchedulerProps {
+    value: RecurrenceConfig;
+    onChange: (config: RecurrenceConfig) => void;
+    startDate: Date | null;
+}
+declare function useRecurrenceScheduler({ value, onChange, startDate, }: UseRecurrenceSchedulerProps): {
+    isEnabled: boolean;
+    isValid: boolean;
+    summary: string;
+    frequency: FrequencyOption;
+    recurrence: Recurrence | null;
+    endCondition: EndCondition;
+    setFrequency: (newFrequency: FrequencyOption) => void;
+    setWeeklyDays: (days: DayOfWeek[]) => void;
+    setWeeklyInterval: (interval: number) => void;
+    toggleWeeklyDay: (day: DayOfWeek) => void;
+    setMonthlyInterval: (interval: number) => void;
+    setMonthlyDate: (dayOfMonth: number) => void;
+    setMonthlyWeekday: (week: WeekOfMonth, day: DayOfWeek) => void;
+    setYearlyInterval: (interval: number) => void;
+    setEndDate: (date: Date | null) => void;
+    setOccurrences: (count: number | null) => void;
+};
+
+interface FrequencySelectProps {
+    value: FrequencyOption;
+    onChange: (frequency: FrequencyOption) => void;
+    disabled?: boolean;
+}
+declare function FrequencySelect({ value, onChange, disabled, }: FrequencySelectProps): react_jsx_runtime.JSX.Element;
+
+interface WeeklyDaysSelectProps {
+    interval: number;
+    onIntervalChange: (interval: number) => void;
+    selectedDays: DayOfWeek[];
+    onToggleDay: (day: DayOfWeek) => void;
+    disabled?: boolean;
+}
+declare function WeeklyDaysSelect({ interval, onIntervalChange, selectedDays, onToggleDay, disabled, }: WeeklyDaysSelectProps): react_jsx_runtime.JSX.Element;
+
+interface MonthlyDatePickerProps {
+    interval: number;
+    onIntervalChange: (interval: number) => void;
+    date: number;
+    onChange: (date: number) => void;
+    disabled?: boolean;
+}
+declare function MonthlyDatePicker({ interval, onIntervalChange, date, onChange, disabled, }: MonthlyDatePickerProps): react_jsx_runtime.JSX.Element;
+interface MonthlyWeekdayPickerProps {
+    interval: number;
+    onIntervalChange: (interval: number) => void;
+    week: WeekOfMonth;
+    day: DayOfWeek;
+    onChange: (week: WeekOfMonth, day: DayOfWeek) => void;
+    disabled?: boolean;
+}
+declare function MonthlyWeekdayPicker({ interval, onIntervalChange, week, day, onChange, disabled, }: MonthlyWeekdayPickerProps): react_jsx_runtime.JSX.Element;
+
+interface SummaryDisplayProps {
+    summary: string;
+    isValid: boolean;
+    isEnabled: boolean;
+    className?: string;
+}
+declare function SummaryDisplay({ summary, isValid, isEnabled, className, }: SummaryDisplayProps): react_jsx_runtime.JSX.Element;
+
+type ValueSchemaType = "none" | "scalar" | "array" | "range" | "relative_time";
+type TimeUnit = "days" | "weeks" | "months" | "years";
+interface ValueSchema {
+    readonly type: ValueSchemaType;
+    /** For scalar/array: the primitive type of items */
+    readonly itemType?: "string" | "number" | "date";
+    /** For relative_time: which units are allowed */
+    readonly allowedUnits?: readonly TimeUnit[];
+}
+type RelativeTimeValue = {
+    readonly amount: number;
+    readonly unit: TimeUnit;
+};
+type RangeValue = {
+    readonly from: number | Date;
+    readonly to: number | Date;
+};
+type FilterValue = null | string | number | boolean | Date | readonly string[] | readonly number[] | RangeValue | RelativeTimeValue;
+type OperatorId = "is" | "is_not" | "is_any_of" | "is_none_of" | "contains" | "not_contains" | "starts_with" | "ends_with" | "greater_than" | "greater_than_or_equal" | "less_than" | "less_than_or_equal" | "between" | "in_the_next" | "in_the_last" | "on_or_before" | "on_or_after" | "is_set" | "is_not_set";
+type UIHint = "none" | "select" | "combobox" | "checkbox-list" | "multi-combobox" | "text" | "number" | "date-picker" | "date-range" | "number-range" | "relative-time";
+type SemanticFieldType = "string" | "number" | "boolean" | "enum" | "date" | "date.recurring" | "entity";
+interface FilterOperator {
+    readonly id: OperatorId;
+    /** Display label (e.g., "is any of", "in the next") */
+    readonly label: string;
+    /** What value shape this operator expects */
+    readonly valueSchema: ValueSchema;
+    /** Default UI rendering hint */
+    readonly uiHint: UIHint;
+    /** Which field types this operator is compatible with */
+    readonly compatibleFieldTypes: readonly SemanticFieldType[];
+    /** Factory for safe value initialization */
+    defaultValue(): FilterValue;
+}
+interface FilterFieldOption {
+    readonly value: string;
+    readonly label: string;
+}
+interface FilterField {
+    /** Unique field identifier */
+    readonly id: string;
+    /** Display label */
+    readonly label: string;
+    /** Semantic type - determines allowed operators and evaluation logic */
+    readonly type: SemanticFieldType;
+    /** Allowed operator IDs for this field */
+    readonly operators: readonly OperatorId[];
+    /** For enum fields: available options */
+    readonly options?: readonly FilterFieldOption[];
+    /** For entity fields: the entity type for lookups */
+    readonly entityType?: string;
+    /** Override operator's default UI hint (UI only, never value schema) */
+    readonly uiHintOverrides?: Partial<Record<OperatorId, UIHint>>;
+}
+interface FilterExpression {
+    /** Unique identifier for this expression instance */
+    readonly id: string;
+    /** Field being filtered */
+    readonly fieldId: string;
+    /** Operator being applied */
+    readonly operatorId: OperatorId;
+    /** Value - shape determined by operator's valueSchema */
+    readonly value: FilterValue;
+}
+type FilterLogic = "and" | "or";
+interface FilterState {
+    readonly expressions: readonly FilterExpression[];
+    readonly logic: FilterLogic;
+}
+interface QuickFilterConfig {
+    /** Field ID this quick filter controls */
+    readonly fieldId: string;
+    /** Default operator when using this quick filter */
+    readonly defaultOperatorId: OperatorId;
+    /** Optional: override the field's label */
+    readonly label?: string;
+    /** Optional: override the placeholder text */
+    readonly placeholder?: string;
+    /** Optional: fixed width in pixels */
+    readonly width?: number;
+}
+
+interface SemanticFilterControllerProps {
+    /** Available field definitions */
+    fields: readonly FilterField[];
+    /** Current filter state */
+    value: FilterState;
+    /** Callback when filter state changes */
+    onChange: (state: FilterState) => void;
+    /** Quick filter configurations */
+    quickFilters?: readonly QuickFilterConfig[];
+    /** Whether to show advanced filters option */
+    showAdvanced?: boolean;
+    /** Default state to reset to */
+    defaultValue?: FilterState;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function SemanticFilterController({ fields, value, onChange, quickFilters, showAdvanced, defaultValue, className, }: SemanticFilterControllerProps): react_jsx_runtime.JSX.Element;
+
+interface SemanticQuickFiltersProps {
+    /** Available field definitions */
+    fields: readonly FilterField[];
+    /** Quick filter configurations */
+    configs: readonly QuickFilterConfig[];
+    /** Current filter state */
+    value: FilterState;
+    /** Callback when filter state changes */
+    onChange: (state: FilterState) => void;
+    /** Currently visible quick filter field IDs */
+    activeFieldIds: Set<string>;
+    /** Callback to add a quick filter */
+    onAddFilter: (fieldId: string) => void;
+    /** Callback to remove a quick filter */
+    onRemoveFilter: (fieldId: string) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function SemanticQuickFilters({ fields, configs, value, onChange, activeFieldIds, onAddFilter, onRemoveFilter, className, }: SemanticQuickFiltersProps): react_jsx_runtime.JSX.Element | null;
+
+interface SemanticAdvancedFilterBuilderProps {
+    /** Available field definitions */
+    fields: readonly FilterField[];
+    /** Current filter expressions */
+    expressions: readonly FilterExpression[];
+    /** Callback when expressions change */
+    onChange: (expressions: FilterExpression[]) => void;
+    /** Current logic operator (and/or) */
+    logic: FilterLogic;
+    /** Callback when logic changes */
+    onLogicChange: (logic: FilterLogic) => void;
+    /** Callback to switch to quick filters view */
+    onSwitchToQuickFilters?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function SemanticAdvancedFilterBuilder({ fields, expressions, onChange, logic, onLogicChange, onSwitchToQuickFilters, className, }: SemanticAdvancedFilterBuilderProps): react_jsx_runtime.JSX.Element;
+
+interface ValueInputProps {
+    /** Resolved UI hint (after field overrides) */
+    uiHint: UIHint;
+    /** The field (provides options for enum fields) */
+    field: FilterField;
+    /** The operator (provides value schema info) */
+    operator: FilterOperator;
+    /** Current value */
+    value: FilterValue;
+    /** Callback when value changes */
+    onChange: (value: FilterValue) => void;
+    /** Optional size variant */
+    size?: "sm" | "default";
+    /** Optional className */
+    className?: string;
+}
+declare function ValueInput({ uiHint, field, operator, value, onChange, size, className, }: ValueInputProps): react_jsx_runtime.JSX.Element | null;
+
+interface UseSemanticFilterStateOptions {
+    /** Initial filter state */
+    initialState?: FilterState;
+    /** Default state to reset to */
+    defaultState?: FilterState;
+    /** Callback when state changes */
+    onStateChange?: (state: FilterState) => void;
+}
+interface UseSemanticFilterStateReturn {
+    /** Current filter state */
+    state: FilterState;
+    /** All expressions */
+    expressions: readonly FilterExpression[];
+    /** Current logic operator */
+    logic: FilterLogic;
+    /** Whether there are any active filters */
+    hasFilters: boolean;
+    /** Whether state differs from default */
+    canReset: boolean;
+    /** Set the entire state */
+    setState: (state: FilterState) => void;
+    /** Add a new expression */
+    addExpression: (expression: FilterExpression) => void;
+    /** Update an existing expression */
+    updateExpression: (expressionId: string, updates: Partial<Omit<FilterExpression, "id">>) => void;
+    /** Remove an expression by ID */
+    removeExpression: (expressionId: string) => void;
+    /** Set or update expression for a field */
+    setField: (fieldId: string, operatorId: OperatorId, value: FilterValue) => void;
+    /** Remove expression for a field */
+    clearField: (fieldId: string) => void;
+    /** Set the logic operator */
+    setLogic: (logic: FilterLogic) => void;
+    /** Reset to default state */
+    reset: () => void;
+    /** Clear all expressions */
+    clearAll: () => void;
+}
+declare function useSemanticFilterState(options?: UseSemanticFilterStateOptions): UseSemanticFilterStateReturn;
+
+/**
+ * Get an operator by ID.
+ * Throws if operator doesn't exist.
+ */
+declare function getOperator(id: OperatorId): FilterOperator;
+/**
+ * Get all operators for a field based on its declared operator list.
+ */
+declare function getOperatorsForField(operatorIds: readonly OperatorId[]): FilterOperator[];
+/**
+ * Check if an operator is compatible with a field type.
+ */
+declare function isOperatorCompatible(operatorId: OperatorId, fieldType: SemanticFieldType): boolean;
+/**
+ * Get all operators compatible with a field type.
+ */
+declare function getCompatibleOperators(fieldType: SemanticFieldType): FilterOperator[];
+/**
+ * Get the full operator registry (for iteration/debugging).
+ */
+declare function getAllOperators(): readonly FilterOperator[];
+/**
+ * Get default value for an operator.
+ * Convenience function that doesn't require fetching the full operator.
+ */
+declare function getDefaultValueForOperator(operatorId: OperatorId): FilterValue;
+
+/**
+ * Generate a unique ID for a filter expression.
+ */
+declare function generateExpressionId(): string;
+/**
+ * Resolve the UI hint for a field + operator combination.
+ * Precedence:
+ *   1. Field uiHintOverrides (highest)
+ *   2. Inferred default based on (field.type, operator, hasOptions)
+ *   3. Operator default uiHint (fallback)
+ */
+declare function resolveUIHint(field: FilterField, operator: FilterOperator): UIHint;
+/**
+ * Resolve UI hint by IDs (convenience function).
+ */
+declare function resolveUIHintByIds(field: FilterField, operatorId: OperatorId): UIHint;
+/**
+ * Initialize value when field changes.
+ * Resets to first operator's default value.
+ */
+declare function initializeForField(field: FilterField): Pick<FilterExpression, "fieldId" | "operatorId" | "value">;
+/**
+ * Initialize value when operator changes.
+ * Resets to the new operator's default value.
+ */
+declare function initializeForOperator(operatorId: OperatorId): Pick<FilterExpression, "operatorId" | "value">;
+/**
+ * Create a new filter expression for a field.
+ * Uses first operator and its default value.
+ */
+declare function createExpression(field: FilterField): FilterExpression;
+/**
+ * Create a filter expression with specific values.
+ */
+declare function createExpressionWith(fieldId: string, operatorId: OperatorId, value: FilterValue): FilterExpression;
+/**
+ * Add an expression to the state.
+ */
+declare function addExpression(state: FilterState, expression: FilterExpression): FilterState;
+/**
+ * Update an expression in the state.
+ */
+declare function updateExpression(state: FilterState, expressionId: string, updates: Partial<Omit<FilterExpression, "id">>): FilterState;
+/**
+ * Remove an expression from the state.
+ */
+declare function removeExpression(state: FilterState, expressionId: string): FilterState;
+/**
+ * Set or update an expression by field ID.
+ * If an expression for this field exists, update it.
+ * Otherwise, add a new one.
+ */
+declare function setExpressionForField(state: FilterState, fieldId: string, operatorId: OperatorId, value: FilterValue): FilterState;
+/**
+ * Update the logic operator.
+ */
+declare function setLogic(state: FilterState, logic: FilterLogic): FilterState;
+/**
+ * Clear all expressions.
+ */
+declare function clearAll(): FilterState;
+/**
+ * Check if state has any expressions.
+ */
+declare function hasExpressions(state: FilterState): boolean;
+/**
+ * Get expression by field ID.
+ */
+declare function getExpressionByField(state: FilterState, fieldId: string): FilterExpression | undefined;
+/**
+ * Get expression by ID.
+ */
+declare function getExpressionById(state: FilterState, expressionId: string): FilterExpression | undefined;
+/**
+ * Check if state differs from another state.
+ */
+declare function hasChanges(state: FilterState, other: FilterState): boolean;
+/**
+ * Check if a value is considered "empty".
+ */
+declare function isValueEmpty(value: FilterValue): boolean;
+/**
+ * Check if an operator is a presence operator (is_set, is_not_set).
+ */
+declare function isPresenceOperator(operatorId: OperatorId): boolean;
+/**
+ * Deep equality check for filter values.
+ */
+declare function areValuesEqual(a: FilterValue, b: FilterValue): boolean;
+/**
+ * Extract values for quick filters from state.
+ * Returns a map of fieldId -> value.
+ */
+declare function extractQuickFilterValues(state: FilterState, fieldIds: readonly string[]): Record<string, FilterValue>;
+/**
+ * Get field IDs that have active expressions.
+ */
+declare function getActiveFieldIds(state: FilterState): string[];
+declare const EMPTY_STATE: FilterState;
+
+type TabsProps = React.ComponentProps<typeof TabsPrimitive.Root>;
+type TabsListProps = React.ComponentProps<typeof TabsPrimitive.List>;
+type TabsTriggerProps = React.ComponentProps<typeof TabsPrimitive.Trigger>;
+type TabsContentProps = React.ComponentProps<typeof TabsPrimitive.Content>;
+declare function Tabs({ className, ...props }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsList({ className, ...props }: TabsListProps): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ className, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ className, ...props }: TabsContentProps): react_jsx_runtime.JSX.Element;
+
+type SidebarContextProps = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React$1.ComponentProps<"div"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React$1.ComponentProps<"div"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;
+declare function SidebarRail({ className, ...props }: React$1.ComponentProps<"button">): react_jsx_runtime.JSX.Element;
+declare function SidebarInset({ className, ...props }: React$1.ComponentProps<"main">): react_jsx_runtime.JSX.Element;
+declare function SidebarInput({ className, ...props }: React$1.ComponentProps<typeof Input>): react_jsx_runtime.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
+declare function SidebarContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupLabel({ className, asChild, ...props }: React$1.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React$1.ComponentProps<"button"> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React$1.ComponentProps<"ul">): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React$1.ComponentProps<"button"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React$1.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React$1.ComponentProps<"button"> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuBadge({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React$1.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React$1.ComponentProps<"ul">): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React$1.ComponentProps<"a"> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+type TableProps = React.TableHTMLAttributes<HTMLTableElement>;
+type TableHeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
+type TableBodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
+type TableFooterProps = React.HTMLAttributes<HTMLTableSectionElement>;
+type TableRowProps = React.HTMLAttributes<HTMLTableRowElement>;
+type TableHeadProps = React.ThHTMLAttributes<HTMLTableCellElement>;
+type TableCellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
+type TableCaptionProps = React.HTMLAttributes<HTMLTableCaptionElement>;
+declare function Table({ className, ...props }: TableProps): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ className, ...props }: TableHeaderProps): react_jsx_runtime.JSX.Element;
+declare function TableBody({ className, ...props }: TableBodyProps): react_jsx_runtime.JSX.Element;
+declare function TableFooter({ className, ...props }: TableFooterProps): react_jsx_runtime.JSX.Element;
+declare function TableRow({ className, ...props }: TableRowProps): react_jsx_runtime.JSX.Element;
+declare function TableHead({ className, ...props }: TableHeadProps): react_jsx_runtime.JSX.Element;
+declare function TableCell({ className, ...props }: TableCellProps): react_jsx_runtime.JSX.Element;
+declare function TableCaption({ className, ...props }: TableCaptionProps): react_jsx_runtime.JSX.Element;
+
+interface RowAction<TData> {
+    label: string;
+    onClick: (row: TData) => void;
+    icon?: React.ReactNode;
+    variant?: "default" | "destructive";
+    separator?: boolean;
+}
+/**
+ * Visual chrome variants for DataTable.
+ * - "default": Standard appearance with no special styling
+ * - "pageShell": Optimized for use inside PageShell - gray header background,
+ *   edge-to-edge layout that accounts for PageShell's card padding
+ */
+type DataTableChrome = "default" | "pageShell";
+interface DataTableProps<TData, TValue> {
+    /** Column definitions for the table */
+    columns: ColumnDef<TData, TValue>[];
+    /** Data to display in the table */
+    data: TData[];
+    /** Enable sorting on columns (default: true) */
+    enableSorting?: boolean;
+    /** Enable pagination (default: false) */
+    enablePagination?: boolean;
+    /** Number of rows per page when pagination is enabled (default: 10) */
+    pageSize?: number;
+    /** Callback when a row is clicked */
+    onRowClick?: (row: TData) => void;
+    /** Custom class name for the table container */
+    className?: string;
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Empty state description */
+    emptyDescription?: string;
+    /** Enable row selection with checkboxes */
+    enableRowSelection?: boolean;
+    /** Callback when row selection changes */
+    onRowSelectionChange?: (selectedRows: TData[]) => void;
+    /** Enable column visibility toggle */
+    enableColumnVisibility?: boolean;
+    /** Enable global search filter */
+    enableGlobalFilter?: boolean;
+    /** Placeholder for global search input */
+    globalFilterPlaceholder?: string;
+    /** Row actions dropdown - provide actions for each row */
+    rowActions?: (row: TData) => RowAction<TData>[];
+    /**
+     * Visual chrome variant.
+     * - "default": Standard appearance
+     * - "pageShell": Optimized for PageShell (gray header, edge-to-edge layout)
+     * @default "default"
+     */
+    chrome?: DataTableChrome;
+}
+interface DataTableColumnHeaderProps<TData, TValue> {
+    column: {
+        getCanSort: () => boolean;
+        getIsSorted: () => false | "asc" | "desc";
+        toggleSorting: (desc?: boolean) => void;
+    };
+    title: string;
+    className?: string;
+}
+declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+declare function DataTable<TData, TValue>({ columns: userColumns, data, enableSorting, enablePagination, pageSize, onRowClick, className, emptyMessage, emptyDescription, enableRowSelection, onRowSelectionChange, enableColumnVisibility, enableGlobalFilter, globalFilterPlaceholder, rowActions, chrome, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+export { Alert, AlertDescription, type AlertDescriptionProps, type AlertProps, AlertTitle, type AlertTitleProps, type AlertVariant, Badge, type BadgeProps, type BadgeVariant, BottomSheet, BottomSheetDivider, type BottomSheetDividerProps, BottomSheetLayout, type BottomSheetLayoutProps, BottomSheetMain, type BottomSheetMainProps, type BottomSheetProps, BottomSheetSection, type BottomSheetSectionProps, BottomSheetSidebar, type BottomSheetSidebarProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Calendar, type CalendarProps, Card, CardAction, type CardActionProps, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxProps, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsibleProps, CollapsibleTrigger, type CollapsibleTriggerProps, Combobox, ComboboxContent, type ComboboxContentProps, ComboboxEmpty, type ComboboxEmptyProps, ComboboxGroup, type ComboboxGroupProps, ComboboxInput, type ComboboxInputProps, ComboboxItem, type ComboboxItemProps, ComboboxList, type ComboboxListProps, type ComboboxOption, type ComboboxProps, ComboboxTrigger, type ComboboxTriggerProps, Command, CommandDialog, type CommandDialogProps, CommandEmpty, type CommandEmptyProps, CommandGroup, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, type CommandProps, CommandSeparator, type CommandSeparatorProps, CommandShortcut, type CommandShortcutProps, DAYS_OF_WEEK, DEFAULT_RECURRENCE_CONFIG, DataTable, DataTableColumnHeader, type DataTableColumnHeaderProps, type DataTableProps, DatePicker, type DatePickerProps, type DayOfWeek, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, type DialogOverlayProps, DialogPortal, type DialogPortalProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, type DropdownMenuProps, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, EMPTY_STATE, type EndCondition, FREQUENCY_OPTIONS, type FilterExpression, type FilterField, type FilterFieldOption, type FilterLogic, type FilterOperator, type FilterState, type FilterValue, type FrequencyOption, FrequencySelect, GlobalSettingsModal, GlobalSettingsModalDivider, type GlobalSettingsModalDividerProps, type GlobalSettingsModalProps, GlobalSettingsModalSection, type GlobalSettingsModalSectionProps, Input, type InputProps, Label, type LabelProps, MonthlyDatePicker, MonthlyWeekdayPicker, type OperatorId, Popover, PopoverAnchor, type PopoverAnchorProps, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, type QuickFilterConfig, type RangeValue, type Recurrence, type RecurrenceConfig, RecurrenceScheduler, type RecurrenceSchedulerProps, type RelativeTimeValue, type RowAction, Select, SelectContent, type SelectContentProps, SelectGroup, type SelectGroupProps, SelectItem, type SelectItemProps, SelectLabel, type SelectLabelProps, type SelectProps, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, type SelectSeparatorProps, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, SemanticAdvancedFilterBuilder, type SemanticAdvancedFilterBuilderProps, type SemanticFieldType, SemanticFilterController, type SemanticFilterControllerProps, SemanticQuickFilters, type SemanticQuickFiltersProps, Separator, type SeparatorProps, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, SheetOverlay, type SheetOverlayProps, SheetPortal, type SheetPortalProps, type SheetProps, SheetTitle, type SheetTitleProps, SheetTrigger, type SheetTriggerProps, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, type SkeletonProps, SummaryDisplay, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, type TimeUnit, type ToastOptions, Toaster, type ToasterProps, Tooltip, TooltipContent, type TooltipContentProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, TooltipTrigger, type TooltipTriggerProps, type UIHint, type UseSemanticFilterStateOptions, type UseSemanticFilterStateReturn, UtilityBar, type UtilityBarAction, DateRangePlaceholder as UtilityBarDateRangePlaceholder, type UtilityBarProps, ValueInput, type ValueSchema, type ValueSchemaType, WEEKS_OF_MONTH, type WeekOfMonth, WeeklyDaysSelect, addExpression, alertVariants, areValuesEqual, badgeVariants, buttonVariants, clearAll, createDefaultRecurrence, createExpression, createExpressionWith, extractQuickFilterValues, generateExpressionId, getActiveFieldIds, getAllOperators, getCompatibleOperators, getDefaultValueForOperator, getExpressionByField, getExpressionById, getOperator, getOperatorsForField, hasChanges, hasExpressions, initializeForField, initializeForOperator, isOperatorCompatible, isPresenceOperator, isValueEmpty, mergeClasses, notify, removeExpression, resolveUIHint, resolveUIHintByIds, setExpressionForField, setLogic, updateExpression, useIsMobile, useRecurrenceScheduler, useSemanticFilterState, useSidebar };