@petrarca/sonnet-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,989 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React$1 from 'react';
+import React__default from 'react';
+import { VariantProps } from 'class-variance-authority';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { DialogProps } from '@radix-ui/react-dialog';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { RowData, PaginationState, OnChangeFn } from '@tanstack/react-table';
+export { PaginationState } from '@tanstack/react-table';
+import { PageResult } from '@petrarca/sonnet-core';
+import { UISchema, JsonSchemaProperty, JsonSchema } from '@petrarca/sonnet-core/schema';
+import { EntitySelectMode } from '@petrarca/sonnet-core/hooks';
+import { EntityOptionFetcher, EntityOption } from '@petrarca/sonnet-core/entityOptions';
+import { FilterExpr } from '@petrarca/sonnet-core/search';
+
+declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "secondary" | "outline" | null | undefined;
+    badgeColor?: "grape" | "blue" | "green" | "red" | "orange" | "yellow" | "teal" | "cyan" | "pink" | "indigo" | "violet" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, badgeColor, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "link" | "secondary" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "compact" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps$1 extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps$1 & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Collapsible: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Command: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: ({ children, ...props }: DialogProps) => react_jsx_runtime.JSX.Element;
+declare const CommandInput: React$1.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React$1.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React$1.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & {
+    label?: string;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild">, "heading" | "value"> & {
+    heading?: React$1.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React$1.ForwardRefExoticComponent<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & {
+    alwaysRender?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild">, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare function InputGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-start" | "inline-end" | "block-start" | "block-end" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): react_jsx_runtime.JSX.Element;
+declare function InputGroupText({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React$1.ComponentProps<"input">): react_jsx_runtime.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React$1.ComponentProps<"textarea">): react_jsx_runtime.JSX.Element;
+
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_types.ClassProp | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;
+
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    side?: "right" | "left";
+    /** CSS length (e.g. "3rem" or "0px") controlling where the panel starts vertically. Internal use — prefer PanelOptions.coverage at the shell API level. */
+    offsetTop?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
+declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const SheetBody: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
+declare const SheetFooter: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
+
+declare const gapMap$1: {
+    readonly 0: "gap-0";
+    readonly xs: "gap-1";
+    readonly sm: "gap-2";
+    readonly md: "gap-4";
+    readonly lg: "gap-6";
+    readonly xl: "gap-8";
+    readonly 2: "gap-0.5";
+    readonly 4: "gap-1";
+    readonly 6: "gap-1.5";
+    readonly 8: "gap-2";
+    readonly 24: "gap-6";
+};
+declare const alignMap$1: {
+    readonly start: "items-start";
+    readonly center: "items-center";
+    readonly end: "items-end";
+    readonly stretch: "items-stretch";
+    readonly "flex-start": "items-start";
+    readonly "flex-end": "items-end";
+};
+declare const justifyMap$1: {
+    readonly start: "justify-start";
+    readonly center: "justify-center";
+    readonly end: "justify-end";
+    readonly between: "justify-between";
+    readonly around: "justify-around";
+    readonly "space-between": "justify-between";
+    readonly "flex-start": "justify-start";
+    readonly "flex-end": "justify-end";
+};
+declare const wrapMap: {
+    readonly wrap: "flex-wrap";
+    readonly nowrap: "flex-nowrap";
+    readonly "wrap-reverse": "flex-wrap-reverse";
+};
+declare const mtMap: Record<string, string>;
+interface SimpleGroupProps {
+    children: React$1.ReactNode;
+    gap?: keyof typeof gapMap$1;
+    align?: keyof typeof alignMap$1;
+    justify?: keyof typeof justifyMap$1;
+    wrap?: keyof typeof wrapMap;
+    grow?: boolean;
+    className?: string;
+    style?: React$1.CSSProperties;
+    mt?: keyof typeof mtMap;
+    onClick?: () => void;
+}
+/**
+ * SimpleGroup - A horizontal flex container component
+ *
+ * Replaces Mantine's Group with a simpler Tailwind-based implementation.
+ * Defaults to flex-row (horizontal layout).
+ *
+ * @example
+ * <SimpleGroup gap="sm" justify="between">
+ *   <div>Left item</div>
+ *   <div>Right item</div>
+ * </SimpleGroup>
+ */
+declare function SimpleGroup({ children, gap, align, justify, wrap, grow, className, style, mt, onClick, }: SimpleGroupProps): React$1.ReactElement;
+
+declare const gapMap: {
+    readonly 0: "gap-0";
+    readonly xs: "gap-1";
+    readonly sm: "gap-2";
+    readonly md: "gap-4";
+    readonly lg: "gap-6";
+    readonly xl: "gap-8";
+    readonly 2: "gap-0.5";
+    readonly 4: "gap-1";
+    readonly 6: "gap-1.5";
+    readonly 8: "gap-2";
+    readonly 24: "gap-6";
+};
+declare const alignMap: {
+    readonly start: "items-start";
+    readonly center: "items-center";
+    readonly end: "items-end";
+    readonly stretch: "items-stretch";
+};
+declare const justifyMap: {
+    readonly start: "justify-start";
+    readonly center: "justify-center";
+    readonly end: "justify-end";
+    readonly between: "justify-between";
+    readonly around: "justify-around";
+};
+interface SimpleStackProps {
+    children: React$1.ReactNode;
+    gap?: keyof typeof gapMap;
+    align?: keyof typeof alignMap;
+    justify?: keyof typeof justifyMap;
+    className?: string;
+    style?: React$1.CSSProperties;
+    h?: number | string;
+}
+/**
+ * SimpleStack - A vertical flex container component
+ *
+ * Replaces Mantine's Stack with a simpler Tailwind-based implementation.
+ * Defaults to flex-col (vertical stacking).
+ *
+ * @example
+ * <SimpleStack gap="md" align="center">
+ *   <div>Item 1</div>
+ *   <div>Item 2</div>
+ * </SimpleStack>
+ */
+declare function SimpleStack({ children, gap, align, justify, className, style, h, }: SimpleStackProps): React$1.ReactElement;
+
+interface SimpleTooltipProps {
+    label: React$1.ReactNode;
+    children: React$1.ReactElement;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    delayDuration?: number;
+    sideOffset?: number;
+}
+/**
+ * Simplified Tooltip wrapper that matches Mantine's simple API.
+ * Usage: <SimpleTooltip label="Click me"><Button>Click</Button></SimpleTooltip>
+ */
+declare function SimpleTooltip({ label, children, side, align, delayDuration, sideOffset, }: SimpleTooltipProps): react_jsx_runtime.JSX.Element;
+
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+interface SpinnerProps {
+    className?: string;
+    size?: "sm" | "md" | "lg";
+}
+/**
+ * Simple loading spinner component
+ *
+ * Replaces Mantine's Loader component
+ *
+ * @example
+ * ```tsx
+ * <Spinner />
+ * <Spinner size="lg" />
+ * <Spinner className="text-blue-500" />
+ * ```
+ */
+declare function Spinner({ className, size }: SpinnerProps): react_jsx_runtime.JSX.Element;
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TabsListProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
+    /** Alignment of tabs: 'start' (left), 'center', or 'end' (right). Default: 'start' */
+    align?: "start" | "center" | "end";
+}
+declare const TabsList: React$1.ForwardRefExoticComponent<TabsListProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Textarea: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+type Direction = "ltr" | "rtl";
+type Orientation = "horizontal" | "vertical";
+type NavigationDirection = "next" | "prev";
+type ActivationMode = "automatic" | "manual";
+type DataState = "inactive" | "active" | "completed";
+interface DivProps extends React$1.ComponentProps<"div"> {
+    asChild?: boolean;
+}
+interface ButtonProps extends React$1.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+interface StepState {
+    value: string;
+    completed: boolean;
+    disabled: boolean;
+}
+interface StoreState {
+    steps: Map<string, StepState>;
+    value: string;
+}
+declare function useStore<T>(selector: (state: StoreState) => T): T;
+interface StepperProps extends DivProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onValueComplete?: (value: string, completed: boolean) => void;
+    onValueAdd?: (value: string) => void;
+    onValueRemove?: (value: string) => void;
+    onValidate?: (value: string, direction: NavigationDirection) => boolean | Promise<boolean>;
+    activationMode?: ActivationMode;
+    dir?: Direction;
+    orientation?: Orientation;
+    disabled?: boolean;
+    loop?: boolean;
+    nonInteractive?: boolean;
+}
+declare function Stepper(props: StepperProps): react_jsx_runtime.JSX.Element;
+declare function StepperList(props: DivProps): react_jsx_runtime.JSX.Element;
+interface StepperItemProps extends DivProps {
+    value: string;
+    completed?: boolean;
+    disabled?: boolean;
+}
+declare function StepperItem(props: StepperItemProps): react_jsx_runtime.JSX.Element;
+declare function StepperTrigger(props: ButtonProps): react_jsx_runtime.JSX.Element;
+interface StepperIndicatorProps extends Omit<DivProps, "children"> {
+    children?: React$1.ReactNode | ((dataState: DataState) => React$1.ReactNode);
+}
+declare function StepperIndicator(props: StepperIndicatorProps): react_jsx_runtime.JSX.Element;
+interface StepperSeparatorProps extends DivProps {
+    forceMount?: boolean;
+}
+declare function StepperSeparator(props: StepperSeparatorProps): react_jsx_runtime.JSX.Element | null;
+interface StepperTitleProps extends React$1.ComponentProps<"span"> {
+    asChild?: boolean;
+}
+declare function StepperTitle(props: StepperTitleProps): react_jsx_runtime.JSX.Element;
+interface StepperDescriptionProps extends React$1.ComponentProps<"span"> {
+    asChild?: boolean;
+}
+declare function StepperDescription(props: StepperDescriptionProps): react_jsx_runtime.JSX.Element;
+interface StepperContentProps extends DivProps {
+    value: string;
+    forceMount?: boolean;
+}
+declare function StepperContent(props: StepperContentProps): react_jsx_runtime.JSX.Element | null;
+declare function StepperPrev(props: ButtonProps): react_jsx_runtime.JSX.Element;
+declare function StepperNext(props: ButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Type definitions for the schema-driven EntityTable system.
+ *
+ * Extractable to @petrarca/sonnet-core -- no React, no app-specific imports.
+ */
+
+/** Resolved column descriptor after merging schema + UI schema. */
+interface ResolvedColumn {
+    /** Property key from schema.properties. */
+    key: string;
+    /** Column header label (from title, x-ui-column.label, or UI schema label). */
+    label: string;
+    /** The merged property schema. */
+    property: JsonSchemaProperty;
+    /** Resolved cell renderer name. */
+    cellRenderer: string;
+    /** Merged cell renderer options. */
+    cellOptions: Record<string, unknown>;
+    /** Fixed column width in pixels, if specified. */
+    width?: number;
+    /** Minimum column width in pixels, if specified. */
+    minWidth?: number;
+}
+/** Per-field UI schema entry for table columns. */
+type TableUiSchema = Record<string, UISchema & {
+    "x-ui-column"?: NonNullable<JsonSchemaProperty["x-ui-column"]> & {
+        label?: string;
+    };
+}> & {
+    "x-ui-globalOptions"?: {
+        sortable?: boolean;
+        stickyHeader?: boolean;
+    };
+};
+
+/**
+ * Built-in cell renderer components for schema-driven EntityTable.
+ *
+ * Each renderer is a React component that receives the raw cell value and
+ * the merged cell options from x-ui-cell-options. All renderers are
+ * display-only -- stateless, no side effects.
+ *
+ * Cross-cutting options supported by all built-in renderers:
+ *   valueKey  -- extract a sub-field from an object value before rendering
+ *   nowrap    -- apply whitespace-nowrap to the output element
+ *
+ * Registry, resolution helpers, and the createRenderer factory live in
+ * cellRegistry.ts so this file exports only components (react-refresh
+ * requirement).
+ */
+
+interface CellRendererProps {
+    value: unknown;
+    /** Full row record -- available for renderers that need sibling fields. */
+    row: Record<string, unknown>;
+    options: Record<string, unknown>;
+}
+type CellRenderer = (props: CellRendererProps) => React__default.ReactElement;
+
+/**
+ * Cell renderer registry, resolution helpers, and the createRenderer factory.
+ *
+ * Separate from cellRenderers.tsx so that non-component exports
+ * (registry object, pure functions, factory) do not violate react-refresh
+ * rules.
+ *
+ * Extractable to @petrarca/sonnet-core (pure logic) /
+ * @petrarca/sonnet-ui (registry with React components).
+ */
+
+/** Registry mapping renderer names to components. */
+declare const CELL_RENDERERS: Record<string, CellRenderer>;
+/**
+ * Factory for creating typed local cell renderers.
+ *
+ * Local renderer names must start with `x-` to distinguish them from
+ * built-in renderers (e.g. `x-audit-actors`, `x-trade-risk`). This
+ * follows the same convention as the `x-ui-*` schema extensions.
+ * Built-in names like `badge`, `datetime`, `muted` stay clean and
+ * unprefixed. A dev-mode warning is logged if the convention is violated.
+ *
+ * The render function receives the full typed row and the x-ui-cell-options
+ * from the schema. This keeps the schema purely declarative (no functions)
+ * while giving domain-specific renderers full type safety.
+ *
+ * For generic table viewers where the row type is not known, omit the
+ * type parameter -- TRow defaults to Record<string, unknown> and you
+ * inspect the row dynamically using options as hints.
+ *
+ * @example
+ * ```ts
+ * import { createRenderer } from "@petrarca/sonnet-ui";
+ * import type { AuditLogEntry } from "../schemas";
+ *
+ * const RENDERERS = {
+ *   "x-audit-actors": createRenderer<AuditLogEntry>((row, options) => {
+ *     // row is fully typed, options from x-ui-cell-options in the schema.
+ *     return <span>{row.actors[0]?.name ?? "--"}</span>;
+ *   }),
+ * };
+ *
+ * // Schema stays pure data:
+ * // actors: { "x-ui-cell": "x-audit-actors" }
+ *
+ * <EntityTable schema={SCHEMA} renderers={RENDERERS} ... />
+ * ```
+ */
+declare function createRenderer<TRow = Record<string, unknown>>(render: (row: TRow, options: Record<string, unknown>) => React__default.ReactNode): CellRenderer;
+
+/**
+ * EntityTable -- generic paginated table driven by JSON Schema + UI Schema.
+ *
+ * Column definitions are derived from schema.properties via resolveColumns().
+ * Domain-specific cell rendering is handled by passing a local renderer
+ * registry via the renderers prop; x-ui-cell names in the schema are
+ * resolved against the local registry first, then the global registry.
+ *
+ * Pagination is opt-in. When pagination + onPaginationChange are provided the
+ * table runs in manualPagination mode and renders prev/next controls.
+ *
+ * Row interaction has two modes controlled by selectionMode:
+ *
+ *   Normal (selectionMode=false, default): click on a row calls onRowClick
+ *   directly (navigation / edit). No keyboard focus management.
+ *
+ *   Selection (selectionMode=true): checkboxes appear, click toggles
+ *   selection, arrow keys navigate rows, Space toggles selection on the
+ *   focused row, Enter is suppressed. The parent receives selected rows
+ *   via onSelectionChange.
+ *
+ * Extractable to @petrarca/sonnet-ui.
+ */
+
+/** Declarative row action rendered as a button in a trailing "Actions" column. */
+interface RowAction<TRow> {
+    label: string;
+    icon?: React__default.ComponentType<{
+        className?: string;
+    }>;
+    variant?: "default" | "destructive" | "ghost";
+    onClick: (row: TRow) => void;
+    hidden?: (row: TRow) => boolean;
+    disabled?: (row: TRow) => boolean;
+}
+interface EntityTableProps<TRow extends RowData> {
+    schema: JsonSchema;
+    uiSchema?: TableUiSchema;
+    renderers?: Record<string, CellRenderer>;
+    data: PageResult<TRow> | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    errorMessage?: string;
+    entityLabel: string;
+    isFiltered?: boolean;
+    emptyMessage?: string;
+    onRowClick?: (row: TRow) => void;
+    selectionMode?: boolean;
+    onSelectionChange?: (selectedRows: TRow[]) => void;
+    pagination?: PaginationState;
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    rowActions?: RowAction<TRow>[];
+}
+declare function EntityTable<TRow extends RowData>(props: EntityTableProps<TRow>): React__default.ReactElement;
+
+/**
+ * EntitySelect -- async searchable single-select for entity references.
+ *
+ * Fetches options via a pluggable EntityOptionFetcher. The combobox search
+ * input drives server-side filtering through the useEntityOptions hook.
+ *
+ * Extractable to @petrarca/sonnet-ui -- no app-specific imports.
+ */
+
+interface EntitySelectProps {
+    /** The fetcher that provides options from the backend. */
+    fetcher: EntityOptionFetcher;
+    /**
+     * Stable cache key for TanStack Query. Must be unique per fetcher/endpoint
+     * combination -- two components using the same key share the same cache entry.
+     */
+    queryKey: string;
+    /**
+     * Search mode. Default: "eager".
+     *   eager     -- fetch on mount, refetch as user types (small collections)
+     *   typeahead -- fetch only after minChars are typed (large collections)
+     *   explicit  -- fetch only when user presses Enter
+     */
+    mode?: EntitySelectMode;
+    /** Minimum characters before typeahead mode fires (default 1). */
+    minChars?: number;
+    /** Currently selected value (controlled). */
+    value?: string | null;
+    /** Called when the selection changes. */
+    onChange?: (value: string | null) => void;
+    /** Called when the selection changes, passing the full option (value + label). */
+    onChangeOption?: (option: EntityOption | null) => void;
+    /** Called when the dropdown closes (for form blur tracking). */
+    onBlur?: () => void;
+    /** Label displayed above the select. Pass false to hide. */
+    label?: string | false;
+    /** Placeholder when nothing is selected. */
+    placeholder?: string;
+    /** Placeholder for the search input inside the dropdown. */
+    searchPlaceholder?: string;
+    /** Message when no options match the search. */
+    emptyMessage?: string;
+    /** Whether the field is required (shows asterisk). */
+    required?: boolean;
+    /** Whether the select is disabled. */
+    disabled?: boolean;
+    /** Description text below the label. */
+    description?: string;
+    /** Error message. */
+    error?: string;
+    /** Additional className for the wrapper. */
+    className?: string;
+    /** HTML id for the trigger button. */
+    id?: string;
+}
+declare function EntitySelect(props: EntitySelectProps): React$1.ReactElement;
+
+/**
+ * TreeView -- generic, accessible tree component.
+ *
+ * Renders a hierarchy of nodes with expand/collapse, keyboard navigation,
+ * and optional row selection. Node content is fully delegated to the
+ * caller via a renderNode render prop -- this component owns structure
+ * and interaction only.
+ *
+ * Accessibility: implements WAI-ARIA Tree View pattern with
+ * role="tree", role="treeitem", aria-expanded, aria-selected.
+ * Keyboard: ArrowDown/Up move focus, ArrowRight expands / moves into
+ * first child, ArrowLeft collapses / moves to parent, Enter/Space
+ * activate the focused node.
+ *
+ * Loading and error states per node are communicated via the node data
+ * itself (isLoading, isError flags). The caller controls data fetching.
+ *
+ * Extractable to @petrarca/sonnet-ui. Contains no app-specific imports.
+ */
+
+/** A single node in the tree. TData carries the domain payload. */
+interface TreeNode<TData = Record<string, unknown>> {
+    /** Stable unique identifier for this node. */
+    id: string;
+    /** Domain payload, passed through to renderNode. */
+    data: TData;
+    /** Whether this node can have children (controls expand affordance). */
+    hasChildren: boolean;
+    /** Children that have already been loaded. undefined = not yet fetched. */
+    children?: TreeNode<TData>[];
+    /** True while children are being fetched. */
+    isLoading?: boolean;
+    /** True when the child fetch failed. */
+    isError?: boolean;
+}
+interface TreeViewProps<TData = Record<string, unknown>> {
+    /** Root-level nodes. */
+    nodes: TreeNode<TData>[];
+    /** Set of node ids that are currently expanded. Controlled. */
+    expandedIds: Set<string>;
+    /** Called when the user requests to expand a node. */
+    onExpand: (nodeId: string) => void;
+    /** Called when the user requests to collapse a node. */
+    onCollapse: (nodeId: string) => void;
+    /** Called when the user clicks a node row. */
+    onNodeClick?: (node: TreeNode<TData>) => void;
+    /** Called when the user activates a node via keyboard (Enter or Space). */
+    onNodeActivate?: (node: TreeNode<TData>) => void;
+    /**
+     * Render the visible content of a single node row.
+     * depth starts at 0 for root nodes.
+     */
+    renderNode: (node: TreeNode<TData>, depth: number) => React__default.ReactNode;
+    /** Row selection -- set of selected node ids. Controlled, opt-in. */
+    selectedIds?: Set<string>;
+    /** Called when the user toggles selection on a node. */
+    onSelectionChange?: (nodeId: string, selected: boolean) => void;
+    /** When true, the first selected node locks checkboxes to its siblings
+     *  (nodes sharing the same parent). Clearing all selections resets the
+     *  constraint so a different sibling group can be selected next. */
+    constrainSelectionToSiblings?: boolean;
+    /** Pixels of indentation per depth level. Default 20. */
+    indentPx?: number;
+    className?: string;
+}
+/** Imperative handle exposed via ref for programmatic focus. */
+interface TreeViewHandle {
+    /** Focus the tree so keyboard navigation is active. */
+    focus(): void;
+}
+declare const TreeView: <TData = Record<string, unknown>>(props: TreeViewProps<TData> & {
+    ref?: React__default.Ref<TreeViewHandle>;
+}) => React__default.ReactElement;
+
+/**
+ * EntityTree -- schema-driven tree component.
+ *
+ * Wraps TreeView and drives column rendering from a JSON Schema +
+ * optional UI Schema, using the same resolveColumns / resolveCellRenderer
+ * pipeline as EntityTable. Each visible tree node row renders as a set
+ * of schema-derived cells.
+ *
+ * Row interaction has two modes controlled by selectionMode:
+ *
+ *   Normal (selectionMode=false, default): click sets active row, pencil
+ *   icon visible on active/hover rows, Enter/Space triggers onNodeEdit.
+ *
+ *   Selection (selectionMode=true): checkboxes appear, click toggles
+ *   selection, pencil icon is hidden, onNodeEdit is suppressed.
+ *
+ * Loading, error, and empty states are communicated via node flags and
+ * the top-level isLoading / isError / isEmpty props.
+ *
+ * Contains no app-specific imports.
+ */
+
+/** Imperative handle for programmatic focus. */
+interface EntityTreeHandle {
+    focus(): void;
+}
+interface EntityTreeProps<TData extends Record<string, unknown>> {
+    schema: JsonSchema;
+    uiSchema?: TableUiSchema;
+    renderers?: Record<string, CellRenderer>;
+    nodes: TreeNode<TData>[];
+    expandedIds: Set<string>;
+    onExpand: TreeViewProps<TData>["onExpand"];
+    onCollapse: TreeViewProps<TData>["onCollapse"];
+    isLoading?: boolean;
+    isError?: boolean;
+    errorMessage?: string;
+    entityLabel?: string;
+    /** Called on row click -- sets the active row without opening edit. */
+    onNodeSelect?: (node: TreeNode<TData>) => void;
+    /** Called when the pencil icon is clicked -- opens the edit panel. */
+    onNodeEdit?: (node: TreeNode<TData>) => void;
+    /** Id of the currently active node. Controls pencil-icon visibility only
+     *  (always shown on the active node, hover-only on others). Row highlight
+     *  is managed by TreeView via focus state. */
+    activeNodeId?: string;
+    selectionMode?: boolean;
+    selectedIds?: Set<string>;
+    onSelectionChange?: TreeViewProps<TData>["onSelectionChange"];
+    /** When true, the first selected node locks subsequent selections to its
+     *  siblings (nodes at the same depth sharing the same parent). Clearing
+     *  all selections resets the constraint. Managed internally by TreeView. */
+    constrainSelectionToSiblings?: boolean;
+    /**
+     * Optional override for specific node rendering. When provided, called
+     * before the default schema-driven renderer. Return a React node to
+     * replace the default, or null to fall through to the default.
+     */
+    renderNodeOverride?: (node: TreeNode<TData>, depth: number) => React__default.ReactNode | null;
+    indentPx?: number;
+    className?: string;
+}
+declare const EntityTree: <TData extends Record<string, unknown>>(props: EntityTreeProps<TData> & {
+    ref?: React__default.Ref<EntityTreeHandle>;
+}) => React__default.ReactElement;
+
+/**
+ * useSearchInput -- internal state machine for SearchInput.
+ *
+ * Two code paths:
+ *   Simple (no schema) -- manages a single input string, commits it as
+ *                         a one-term FilterExpr on Enter or debounce.
+ *   Faceted (schema)   -- manages chip accumulation plus a pending
+ *                         facet/value input. Facets are derived from the
+ *                         schema properties via buildFacetDescriptors().
+ *
+ * Event contract:
+ *   onChange is the single output event. It fires:
+ *     Simple mode, explicit  -- on Enter
+ *     Simple mode, debounce  -- after the user stops typing
+ *     Faceted mode           -- on submit only (Enter on empty input after
+ *                               chips are composed). Chip accumulation is
+ *                               internal state; the caller never sees it.
+ *     Remove chip / Clear    -- immediately (destructive ops need instant feedback)
+ *
+ * Faceted field selection:
+ *   While no facet is pending and the input does NOT end with a space,
+ *   filteredFacets contains the subset of facets whose labels start with
+ *   the current input (case-insensitive). Selecting one sets it as the
+ *   pending facet and clears the input.
+ *
+ *   If the input ends with a space, facet matching is suppressed --
+ *   the value is committed against facets[0] (implicit default).
+ *
+ * Extractable to @petrarca/sonnet-ui: no app-specific imports.
+ */
+
+type SearchMode = "debounce" | "explicit";
+
+/**
+ * Search widget type definitions.
+ *
+ * Search widgets are purpose-built for value entry in faceted search.
+ * They are not form widgets -- no dirty tracking, no deferred save,
+ * no validation lifecycle. A search widget receives a value, lets the
+ * user edit it, and commits or cancels.
+ *
+ * Extractable to @petrarca/sonnet-ui: no app-specific imports.
+ */
+
+/** Props passed to every search widget. */
+interface SearchWidgetProps {
+    /** The JSON Schema property for this facet. Widgets read enum,
+     *  pattern, x-ui-options, and any other metadata they need. */
+    property: JsonSchemaProperty;
+    /** Resolved x-ui-options from the schema property. Convenience
+     *  accessor -- equivalent to property["x-ui-options"] ?? {}. */
+    options: Record<string, unknown>;
+    /** Current input value (controlled). */
+    value: string;
+    /** Called on every keystroke / value change. */
+    onChange: (value: string) => void;
+    /** Called when the user confirms a value (Enter, item selection). */
+    onCommit: (value: string) => void;
+    /** Called when the user abandons entry (Escape). */
+    onCancel: () => void;
+    /** Placeholder text for the input. */
+    placeholder?: string;
+    /** Whether the widget should auto-focus on mount. */
+    autoFocus?: boolean;
+}
+/** A search widget is a React component that implements SearchWidgetProps. */
+type SearchWidget = React.ComponentType<SearchWidgetProps>;
+/** Registry mapping widget names to their implementations. */
+type SearchWidgetRegistry = Record<string, SearchWidget>;
+
+/**
+ * SearchInput -- controlled search and filter input with chip display.
+ *
+ * Supports two modes:
+ *   "explicit"  -- fires only on Enter or the search button (default)
+ *   "debounce"  -- fires automatically after the user stops typing
+ *
+ * Supports two search styles:
+ *   Simple    -- no schema prop; produces a single search term
+ *   Faceted   -- schema prop provided; facets derived from schema properties,
+ *                value entry delegates to search widgets
+ *
+ * Faceted field picker:
+ *   - Opens on ArrowDown or chevron button click
+ *   - Filters to prefix-matching facets as the user types
+ *   - ArrowDown/ArrowUp navigate the list; Enter selects when navigated or typed
+ *   - Click on an item accepts that facet
+ *   - Closes when a facet is selected, input is submitted, or focus leaves
+ *
+ * Always emits a FilterExpr. Use flattenFilterExpr() from @/lib/search to
+ * convert to flat key/value params for server APIs that do not yet accept AST.
+ *
+ * Extractable to @petrarca/sonnet-ui: no imports from api/, services/,
+ * store/, contexts/, or modules/.
+ */
+
+interface SearchInputProps {
+    value: FilterExpr;
+    onChange: (expr: FilterExpr) => void;
+    /** JSON Schema defining available facets. Providing this activates
+     *  faceted mode. Each schema property becomes an available facet.
+     *  Omit for simple single-term search. */
+    schema?: JsonSchema;
+    /** Custom search widgets merged with defaults. Keys are widget names
+     *  referenced by x-ui-widget in schema properties. */
+    widgets?: SearchWidgetRegistry;
+    mode?: SearchMode;
+    debounceMs?: number;
+    /** Minimum characters before onChange fires. Simple mode only --
+     *  has no effect in faceted mode. */
+    minChars?: number;
+    /** Show an explicit Search button. Only rendered in explicit mode --
+     *  has no effect when mode is "debounce". */
+    showSearchButton?: boolean;
+    /**
+     * Simple mode only. When provided, the search text is expanded into a
+     * FilterOr with one LIKE term per field instead of the default single
+     * { key: "search" } term. Enables cross-field search (e.g. match on
+     * code OR display). Ignored in faceted mode.
+     */
+    searchFields?: string[];
+    placeholder?: string;
+    className?: string;
+    /** Disable all interaction (e.g. when a prerequisite is not met). */
+    disabled?: boolean;
+}
+declare function SearchInput(props: SearchInputProps): React__default.ReactElement;
+
+type Props$2 = {
+    hasItems: boolean;
+    onClick: () => void;
+};
+/**
+ * ClipboardButton - Toolbar button that opens the clipboard menu.
+ *
+ * Displayed in CytoscapeControls toolbar with enabled/disabled state.
+ */
+declare function ClipboardButton({ hasItems, onClick }: Props$2): react_jsx_runtime.JSX.Element;
+
+/**
+ * ClipboardItem - Lightweight representation of an item in the clipboard.
+ */
+interface ClipboardItem {
+    id: string;
+    type: string;
+    entityId: string;
+    label: string;
+    displayName: string;
+    color: string;
+}
+
+type Props$1 = {
+    item: ClipboardItem;
+    onAddItem: (item: ClipboardItem, keepInClipboard: boolean) => void;
+    onRemove: (itemId: string) => void;
+};
+/**
+ * ClipboardItem - Individual clipboard item display.
+ *
+ * Shows item info with color indicator and action buttons.
+ * Compact design for dropdown menu.
+ */
+declare function ClipboardItemComponent({ item, onAddItem, onRemove }: Props$1): react_jsx_runtime.JSX.Element;
+
+type Props = {
+    onAddItem: (item: ClipboardItem, keepInClipboard: boolean) => void;
+};
+/**
+ * ClipboardMenu - Dropdown menu content for clipboard management.
+ *
+ * Displays clipboard items with add and clear all functionality.
+ */
+declare function ClipboardMenu({ onAddItem }: Props): react_jsx_runtime.JSX.Element;
+
+export { Alert, AlertDescription, AlertTitle, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Button, CELL_RENDERERS, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, type CellRenderer, type CellRendererProps, Checkbox, ClipboardButton, ClipboardItemComponent as ClipboardItem, ClipboardMenu, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EntitySelect, type EntitySelectProps, EntityTable, type EntityTableProps, EntityTree, type EntityTreeHandle, type EntityTreeProps, Input, InputGroup, InputGroupAddon, InputGroupInput, InputGroupText, InputGroupTextarea, Label, Popover, PopoverContent, PopoverTrigger, type ResolvedColumn, type RowAction, ScrollArea, ScrollBar, SearchInput, type SearchMode, Separator, Sheet, SheetBody, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetTitle, SheetTrigger, SimpleGroup, SimpleStack, SimpleTooltip, Skeleton, Spinner, Stepper, StepperContent, StepperDescription, StepperIndicator, StepperItem, StepperList, StepperNext, StepperPrev, type StepperProps, StepperSeparator, StepperTitle, StepperTrigger, type TableUiSchema, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TreeNode, TreeView, type TreeViewHandle, type TreeViewProps, badgeVariants, buttonVariants, createRenderer, useStore as useStepper };