@petrarca/sonnet-ui 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -3,8 +3,8 @@ 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 { RadioGroup as RadioGroup$1 } from 'radix-ui';
 import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { DialogProps } from '@radix-ui/react-dialog';
@@ -15,11 +15,11 @@ 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 { CodeableConcept, UISchema, JsonSchemaProperty, JsonSchema } from '@petrarca/sonnet-core/schema';
 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 { UISchema, JsonSchemaProperty, JsonSchema } from '@petrarca/sonnet-core/schema';
+import { RowData, PaginationState, OnChangeFn, SortingState } from '@tanstack/react-table';
+export { PaginationState, SortingState } from '@tanstack/react-table';
 import { EntitySelectMode } from '@petrarca/sonnet-core/hooks';
 import { EntityOptionFetcher, EntityOption } from '@petrarca/sonnet-core/entityOptions';
 import { FilterExpr } from '@petrarca/sonnet-core/search';
@@ -35,15 +35,15 @@ declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitiv
 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;
+    variant?: "default" | "secondary" | "destructive" | "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 function Badge({ className, variant, badgeColor, ...props }: BadgeProps): React$1.JSX.Element;
 
 declare const buttonVariants: (props?: ({
-    variant?: "default" | "destructive" | "link" | "secondary" | "outline" | "ghost" | null | undefined;
+    variant?: "link" | "default" | "secondary" | "destructive" | "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> {
@@ -94,6 +94,131 @@ interface IconButtonProps extends Omit<ButtonProps$1, "size" | "children" | "ari
 }
 declare const IconButton: React$1.ForwardRefExoticComponent<IconButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
+/**
+ * CopyButton -- copies a value to the clipboard and confirms it for a moment
+ * (a check mark, "Copied"). Icon-only by default, as an IconButton whose label
+ * is the tooltip and the accessible name; `withText` shows the label beside
+ * the icon instead, for a standalone toolbar button.
+ *
+ * Usage:
+ *   <CopyButton value={path} label="Copy path" />
+ *   <CopyButton value={json} withText />
+ */
+interface CopyButtonProps {
+    /** The text to copy. */
+    value: string;
+    /** What the button does. Default "Copy". */
+    label?: string;
+    /** Show the label as text beside the icon. Default false. */
+    withText?: boolean;
+    className?: string;
+}
+declare function CopyButton({ value, label, withText, className, }: CopyButtonProps): React$1.ReactElement;
+
+/**
+ * SplitButton -- a primary action with an attached dropdown of secondary
+ * actions (the "split button" / menu-button pattern). The main face runs the
+ * primary action on click; the caret opens a menu of related alternatives.
+ *
+ * Use it to keep a cluster of related verbs as one control (e.g. a primary
+ * "Collect" with a secondary "Run a single operation") instead of a row of
+ * sibling buttons. For a single action use Button; for a pure menu use
+ * DropdownMenu with its own trigger.
+ *
+ * - `variant`/`size` apply to both faces, so it reads as one control. The two
+ *   faces share a seam (the primary loses its right radius, the caret its
+ *   left) and a hairline divider.
+ * - `disabled` disables the primary action only; the menu caret stays usable
+ *   (so secondary actions remain reachable while the primary is unavailable,
+ *   e.g. mid-run). Pass `menuDisabled` to disable the caret too.
+ * - Each item carries its own `disabled`; a `destructive` item tints red.
+ *
+ * Usage:
+ *   <SplitButton
+ *     label="Collect"
+ *     icon={<Play />}
+ *     onClick={startCollect}
+ *     disabled={collecting}
+ *     items={[
+ *       { label: "Run a single operation...", icon: <Zap />, onSelect: openRun },
+ *     ]}
+ *   />
+ */
+interface SplitButtonItem {
+    /** The item's visible text. */
+    label: string;
+    /** Optional leading icon (bare `<Icon />`, no size class). */
+    icon?: React$1.ReactNode;
+    /** Chosen handler. */
+    onSelect: () => void;
+    /** Disable just this item. */
+    disabled?: boolean;
+    /** Tint the item red (a destructive secondary action). */
+    destructive?: boolean;
+}
+interface SplitButtonProps extends Omit<ButtonProps$1, "children" | "onClick"> {
+    /** The primary action's label. */
+    label: string;
+    /** Optional leading icon for the primary face. */
+    icon?: React$1.ReactNode;
+    /** The primary action, run when the main face is clicked. */
+    onClick?: () => void;
+    /** The secondary actions, shown in the dropdown. */
+    items: SplitButtonItem[];
+    /** Disable the menu caret too (default: only the primary is disabled). */
+    menuDisabled?: boolean;
+    /** Accessible label for the caret trigger. Default "More actions". */
+    menuLabel?: string;
+    /** Which side the menu opens. Default "bottom". */
+    menuAlign?: "start" | "center" | "end";
+}
+declare const SplitButton: React$1.ForwardRefExoticComponent<SplitButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * ViewSwitch -- a quiet row of icon + text buttons that switches between the
+ * views (or modes) of one surface: Graph | Model | Description, Semantic |
+ * Text. The current one is filled (secondary), the others are ghost buttons,
+ * so the switch sits calmly in a header or next to a query bar.
+ *
+ * Exactly one option is current; choosing another calls `onChange`. Use it for
+ * a handful of short options that change what the surface shows. For content
+ * panels that belong to the switch use Tabs; for actions use Button.
+ *
+ * - Pass bare icons (`<Network />`): the Button sizes child SVGs.
+ * - Each option is a toggle button (`aria-pressed`) in a labelled group.
+ *
+ * Usage:
+ *   <ViewSwitch
+ *     label="Views"
+ *     value={view}
+ *     onChange={setView}
+ *     options={[
+ *       { value: "graph", label: "Graph", icon: <Network /> },
+ *       { value: "model", label: "Model", icon: <Shapes /> },
+ *     ]}
+ *   />
+ */
+interface ViewSwitchOption<T extends string> {
+    /** The option's value. */
+    value: T;
+    /** Its visible text. */
+    label: string;
+    /** Optional leading icon (bare `<Icon />`, no size class). */
+    icon?: React$1.ReactNode;
+}
+interface ViewSwitchProps<T extends string> {
+    /** The options, in order. */
+    options: ViewSwitchOption<T>[];
+    /** The current option's value. */
+    value: T;
+    /** Called with the chosen option's value. */
+    onChange: (value: T) => void;
+    /** Accessible name of the group (e.g. "Views", "Search mode"). */
+    label: string;
+    className?: string;
+}
+declare function ViewSwitch<T extends string>({ options, value, onChange, label, className, }: ViewSwitchProps<T>): React$1.ReactElement;
+
 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>>;
@@ -103,17 +228,22 @@ declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttribut
 
 declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 
+/** A set of options of which one is chosen -- arrow keys move between them. */
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroup$1.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+/** One option of a RadioGroup, styled as the Checkbox is. */
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroup$1.RadioGroupItemProps & 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"> & {
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     ref?: React$1.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & {
+}, "key" | "asChild" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
     shouldFilter?: boolean;
     filter?: (value: string, search: string, keywords?: string[]) => number;
@@ -124,7 +254,7 @@ declare const Command: React$1.ForwardRefExoticComponent<Omit<{
     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 CommandDialog: ({ children, ...props }: DialogProps) => React$1.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>;
 } & {
@@ -135,45 +265,45 @@ declare const CommandInput: React$1.ForwardRefExoticComponent<Omit<Omit<Pick<Pic
 } & 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"> & {
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     ref?: React$1.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & {
+}, "key" | "asChild" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     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"> & {
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     ref?: React$1.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+}, "key" | "asChild" | keyof React$1.HTMLAttributes<HTMLDivElement>> & 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"> & {
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     ref?: React$1.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild">, "heading" | "value"> & {
+}, "key" | "asChild" | keyof React$1.HTMLAttributes<HTMLDivElement>>, "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"> & {
+declare const CommandSeparator: React$1.ForwardRefExoticComponent<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     ref?: React$1.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild"> & {
+}, "key" | "asChild" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     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"> & {
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     ref?: React$1.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, keyof React$1.HTMLAttributes<HTMLDivElement> | "key" | "asChild">, "onSelect" | "disabled" | "value"> & {
+}, "key" | "asChild" | keyof React$1.HTMLAttributes<HTMLDivElement>>, "onSelect" | "disabled" | "value"> & {
     disabled?: boolean;
     onSelect?: (value: string) => void;
     value?: string;
@@ -181,7 +311,7 @@ declare const CommandItem: React$1.ForwardRefExoticComponent<Omit<{
     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;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
     displayName: string;
 };
 
@@ -192,11 +322,11 @@ declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.Dia
 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;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
     displayName: string;
 };
 declare const DialogFooter: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
     displayName: string;
 };
 declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
@@ -223,7 +353,7 @@ declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<Dropdown
 } & 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;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
     displayName: string;
 };
 
@@ -260,8 +390,12 @@ interface DateInputProps {
     error?: string;
     className?: string;
     onBlur?: () => void;
+    /** The earliest date that can be picked (`YYYY-MM-DD`); the calendar disables those before. */
+    min?: string;
+    /** The latest date that can be picked (`YYYY-MM-DD`); the calendar disables those after. */
+    max?: string;
 }
-declare function DateInput({ value, onChange, precision, locale, id, name, placeholder, required, disabled, error, className, onBlur, }: DateInputProps): React$1.ReactElement;
+declare function DateInput({ value, onChange, precision, locale, id, name, placeholder, required, disabled, error, className, onBlur, min, max, }: DateInputProps): React$1.ReactElement;
 
 /**
  * Calendar -- month/year/decade grid for selecting a single day.
@@ -285,8 +419,12 @@ interface CalendarProps {
     precision?: DatePrecision;
     /** BCP-47 locale for month/weekday labels and week-start. */
     locale?: string;
+    /** The earliest day that can be picked; days, months and years before it are disabled. */
+    min?: Date;
+    /** The latest day that can be picked; days, months and years after it are disabled. */
+    max?: Date;
 }
-declare function Calendar({ value, onSelect, defaultViewDate, precision, locale, }: CalendarProps): React$1.ReactElement;
+declare function Calendar({ value, onSelect, defaultViewDate, precision, locale, min, max, }: CalendarProps): React$1.ReactElement;
 
 /**
  * TimeInput -- text input for a zone-free time of day.
@@ -353,8 +491,12 @@ interface DateTimeInputProps {
     error?: string;
     className?: string;
     onBlur?: () => void;
+    /** The earliest datetime (`YYYY-MM-DDTHH:mm...`): its date bounds the calendar. */
+    min?: string;
+    /** The latest datetime: its date bounds the calendar. */
+    max?: string;
 }
-declare function DateTimeInput({ value, onChange, granularity, timeZone, locale, idPrefix, required, disabled, error, className, onBlur, }: DateTimeInputProps): React$1.ReactElement;
+declare function DateTimeInput({ value, onChange, granularity, timeZone, locale, idPrefix, required, disabled, error, className, onBlur, min, max, }: DateTimeInputProps): React$1.ReactElement;
 
 declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
 declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
@@ -367,23 +509,24 @@ declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitiv
 declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
-declare function InputGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function InputGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.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 InputGroupAddon({ className, align, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): React$1.JSX.Element;
 declare const inputGroupButtonVariants: (props?: ({
     size?: "sm" | "xs" | "icon-xs" | "icon-sm" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React$1.ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>): 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 function InputGroupButton({ className, type, variant, size, ...props }: Omit<React$1.ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>): React$1.JSX.Element;
+declare function InputGroupText({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React$1.ComponentProps<"input">): React$1.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React$1.ComponentProps<"textarea">): React$1.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 PopoverAnchor: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
 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>>;
@@ -426,6 +569,15 @@ interface ResizeHandleProps extends React$1.HTMLAttributes<HTMLDivElement> {
  */
 declare const ResizeHandle: React$1.ForwardRefExoticComponent<ResizeHandleProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * Sheet — a slide-over panel (drawer) built on Radix Dialog.
+ * Slides in from the right edge. Used for create/edit/detail operations.
+ *
+ * SheetContent accepts an optional `offsetTop` (CSS length, e.g. "3rem")
+ * to push the panel below a fixed header. The overlay is unaffected so the
+ * backdrop still covers the full screen.
+ */
+
 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>>;
@@ -435,11 +587,11 @@ declare const SheetContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimiti
     /** 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 SheetHeader: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => React$1.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 SheetBody: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => React$1.JSX.Element;
+declare const SheetFooter: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => React$1.JSX.Element;
 
 declare const gapMap$1: {
     readonly 0: "gap-0";
@@ -504,6 +656,68 @@ interface SimpleGroupProps {
  */
 declare function SimpleGroup({ children, gap, align, justify, wrap, grow, className, style, mt, onClick, }: SimpleGroupProps): React$1.ReactElement;
 
+interface ListRowProps {
+    /** The item's name. */
+    title: React$1.ReactNode;
+    /** Shown next to the title: badges, a key, a status. */
+    adornment?: React$1.ReactNode;
+    /** One muted line below the title: a description or a summary of values. */
+    detail?: React$1.ReactNode;
+    /** Right-aligned controls, typically icon buttons (edit, delete, test). */
+    actions?: React$1.ReactNode;
+    /** Makes the title area a button (e.g. open the item); the actions stay separate. */
+    onClick?: () => void;
+    className?: string;
+}
+/**
+ * ListRow -- one item of a short, bordered list: a title with an optional
+ * adornment and detail line, and actions on the right. For lists of
+ * configurable things (connections, kinds, settings entries); a large or
+ * sortable collection belongs in an EntityTable.
+ */
+declare function ListRow({ title, adornment, detail, actions, onClick, className, }: ListRowProps): React$1.ReactElement;
+
+/** One action of a Danger zone: what it is, what it destroys, its button. */
+interface DangerZoneAction {
+    /** What it does, as a heading: "Delete this source". */
+    title: React$1.ReactNode;
+    /** One sentence saying what it destroys. */
+    description: React$1.ReactNode;
+    /** The button's text: "Delete source". */
+    label: React$1.ReactNode;
+    icon?: React$1.ComponentType<{
+        className?: string;
+    }>;
+    /** Run it -- the caller confirms first (dialog.confirm), naming what is lost. */
+    onClick: () => void;
+    /**
+     * "destructive" (the default) for what removes the item itself; "outline" for
+     * what destroys part of it and leaves the item (drop its data, reset it).
+     */
+    variant?: "destructive" | "outline";
+    /** Not allowed yet: the button is disabled and this says why, on hover. */
+    disabledReason?: React$1.ReactNode;
+    /** Running: the button is disabled until it ends. */
+    pending?: boolean;
+}
+interface DangerZoneProps {
+    actions: DangerZoneAction[];
+    /** The section's heading; "Danger zone" by default. */
+    title?: React$1.ReactNode;
+    className?: string;
+}
+/**
+ * DangerZone -- the last section of a heavyweight item's Settings tab: what
+ * cannot be undone or reaches beyond the item (delete it, drop its data), set
+ * apart under a destructive heading and border, one row per action.
+ *
+ * Each action says what it destroys; one not allowed yet is shown disabled with
+ * its reason -- unlike a row action, which is omitted. Confirming is the
+ * caller's (sonnet-shell's dialog.confirm), naming what is lost. See
+ * docs/design/interaction-patterns.md, "The Danger zone".
+ */
+declare function DangerZone({ actions, title, className, }: DangerZoneProps): React$1.ReactElement | null;
+
 declare const gapMap: {
     readonly 0: "gap-0";
     readonly xs: "gap-1";
@@ -565,9 +779,30 @@ interface SimpleTooltipProps {
  * 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 SimpleTooltip({ label, children, side, align, delayDuration, sideOffset, }: SimpleTooltipProps): React$1.JSX.Element;
 
-declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+/**
+ * CodedValueDisplay -- a coded value as text: its label, and its code beside
+ * it, muted; the code alone when there is no label. The code system, when
+ * given, shows on hover. Used by the coded-value widget, the `coding` cell
+ * renderer, and wherever a stored code is shown without an input.
+ */
+interface CodedValueDisplayProps {
+    code: string;
+    display?: string | null;
+    /** The code system, shown on hover. */
+    system?: string | null;
+    className?: string;
+}
+declare function CodedValueDisplay({ code, display, system, className, }: CodedValueDisplayProps): React$1.JSX.Element;
+
+interface CodeableConceptDisplayProps {
+    value: CodeableConcept;
+    className?: string;
+}
+declare function CodeableConceptDisplay({ value, className, }: CodeableConceptDisplayProps): React$1.JSX.Element;
+
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
 
 interface SpinnerProps {
     className?: string;
@@ -585,7 +820,7 @@ interface SpinnerProps {
  * <Spinner className="text-blue-500" />
  * ```
  */
-declare function Spinner({ className, size }: SpinnerProps): react_jsx_runtime.JSX.Element;
+declare function Spinner({ className, size }: SpinnerProps): React$1.JSX.Element;
 
 declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
 interface TabsListProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
@@ -645,38 +880,38 @@ interface StepperProps extends DivProps {
     loop?: boolean;
     nonInteractive?: boolean;
 }
-declare function Stepper(props: StepperProps): react_jsx_runtime.JSX.Element;
-declare function StepperList(props: DivProps): react_jsx_runtime.JSX.Element;
+declare function Stepper(props: StepperProps): React$1.JSX.Element;
+declare function StepperList(props: DivProps): React$1.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;
+declare function StepperItem(props: StepperItemProps): React$1.JSX.Element;
+declare function StepperTrigger(props: ButtonProps): React$1.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;
+declare function StepperIndicator(props: StepperIndicatorProps): React$1.JSX.Element;
 interface StepperSeparatorProps extends DivProps {
     forceMount?: boolean;
 }
-declare function StepperSeparator(props: StepperSeparatorProps): react_jsx_runtime.JSX.Element | null;
+declare function StepperSeparator(props: StepperSeparatorProps): React$1.JSX.Element | null;
 interface StepperTitleProps extends React$1.ComponentProps<"span"> {
     asChild?: boolean;
 }
-declare function StepperTitle(props: StepperTitleProps): react_jsx_runtime.JSX.Element;
+declare function StepperTitle(props: StepperTitleProps): React$1.JSX.Element;
 interface StepperDescriptionProps extends React$1.ComponentProps<"span"> {
     asChild?: boolean;
 }
-declare function StepperDescription(props: StepperDescriptionProps): react_jsx_runtime.JSX.Element;
+declare function StepperDescription(props: StepperDescriptionProps): React$1.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;
+declare function StepperContent(props: StepperContentProps): React$1.JSX.Element | null;
+declare function StepperPrev(props: ButtonProps): React$1.JSX.Element;
+declare function StepperNext(props: ButtonProps): React$1.JSX.Element;
 
 /**
  * Type definitions for the schema-driven EntityTable system.
@@ -700,6 +935,8 @@ interface ResolvedColumn {
     width?: number;
     /** Minimum column width in pixels, if specified. */
     minWidth?: number;
+    /** Whether the data source can order by this column (x-ui-column.sortable). */
+    sortable: boolean;
 }
 /** Per-field UI schema entry for table columns. */
 type TableUiSchema = Record<string, UISchema & {
@@ -708,17 +945,16 @@ type TableUiSchema = Record<string, UISchema & {
     };
 }> & {
     /**
-     * Table-level options. Reserved for sorting and a sticky header; **neither is
-     * implemented yet**, so setting these has no effect today. Kept declared
-     * because both are intended features -- see the design doc.
+     * Table-level options. Reserved for a sticky header, which is **not
+     * implemented yet**, so setting it has no effect today. Kept declared because
+     * it is an intended feature -- see the design doc. (Sorting is per column:
+     * `x-ui-column.sortable`.)
      *
      * Note this key is unrelated to the `x-ui-globalOptions` of a form UISchema,
      * which carries `UISchemaOptions` and does work. The two share a name and
      * nothing else.
      */
     "x-ui-globalOptions"?: {
-        /** Planned. Sorting is not wired up in EntityTable yet; this has no effect. */
-        sortable?: boolean;
         /** Planned. No sticky positioning is applied yet; this has no effect. */
         stickyHeader?: boolean;
     };
@@ -786,7 +1022,7 @@ declare const CELL_RENDERERS: Record<string, CellRenderer>;
  * 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>;
+ *     return <span>{row.actors[0]?.name ?? EMPTY_VALUE}</span>;
  *   }),
  * };
  *
@@ -808,6 +1044,9 @@ declare function createRenderer<TRow = Record<string, unknown>>(render: (row: TR
  *
  * Pagination is opt-in. When pagination + onPaginationChange are provided the
  * table runs in manualPagination mode and renders prev/next controls.
+ * Sorting is opt-in the same way: with sorting + onSortingChange, the headers of
+ * columns marked x-ui-column.sortable become sort controls (manualSorting --
+ * the consumer's query does the ordering).
  *
  * Row interaction has two modes controlled by selectionMode:
  *
@@ -824,6 +1063,32 @@ declare function createRenderer<TRow = Record<string, unknown>>(render: (row: TR
 
 /** How a row's detail (onRowClick) is opened. */
 type RowActivation = "click" | "double-click";
+/**
+ * How tightly rows are spaced: "default", or "compact" for dense lists (a file
+ * list, a picker in a side panel) -- tighter cells, the same columns and
+ * behaviour.
+ */
+type TableDensity = "default" | "compact";
+/**
+ * Progressive loading -- the alternative to page controls for a list one scans:
+ * the rows grow as more are loaded. The consumer accumulates the pages (e.g.
+ * React Query's useInfiniteQuery) and passes every row loaded so far as
+ * `data.data`, the server's total as `data.meta.total`.
+ */
+interface TableLoadMore {
+    /** More rows on the server. */
+    hasMore: boolean;
+    /** A further page is on its way. */
+    isLoading: boolean;
+    /** Fetch the next page (the consumer appends it to `data`). */
+    onLoadMore: () => void;
+    /**
+     * Load when the end of the rows scrolls into view (default false) -- in the
+     * table's own scroll box with `fill`, else in the page -- instead of on the
+     * footer's "Load more" button, which then is not shown.
+     */
+    auto?: boolean;
+}
 /**
  * Props of EntityTable that can be defaulted app-wide via SonnetConfigProvider.
  * Behavioral, non-data props only.
@@ -886,6 +1151,25 @@ interface EntityTableProps<TRow extends RowData> {
      * "double-click" mode the chevron is an interactive button that opens detail.
      */
     showChevron?: boolean;
+    /** Row spacing (default "default"); "compact" for dense lists. */
+    density?: TableDensity;
+    /**
+     * Fill the parent's height (default false): the rows scroll inside the
+     * table, the header row stays on top and the footer below. The parent gives
+     * the height -- e.g. a flex child with `min-h-0`.
+     */
+    fill?: boolean;
+    /**
+     * Progressive loading instead of pages (opt-in): a "Load more" footer, or
+     * with `auto` loading when the end is scrolled to. Not with `pagination`.
+     */
+    loadMore?: TableLoadMore;
+    /**
+     * Render only the rows in view (default false): for long lists -- many
+     * pages loaded with `loadMore`, or a large data set at once. Needs `fill`
+     * (the table's own scroll box); rows are measured, so wrapping cells work.
+     */
+    virtualize?: boolean;
     selectionMode?: boolean;
     onSelectionChange?: (selectedRows: TRow[]) => void;
     /**
@@ -900,10 +1184,39 @@ interface EntityTableProps<TRow extends RowData> {
     getRowId?: (row: TRow) => string;
     pagination?: PaginationState;
     onPaginationChange?: OnChangeFn<PaginationState>;
+    /**
+     * Server-side sorting (opt-in). With both, the header of each sortable column
+     * (`x-ui-column.sortable`) is a sort control cycling ascending, descending,
+     * unsorted. The table reports the order and never reorders rows itself:
+     * forward it to the query (and start again at the first page).
+     */
+    sorting?: SortingState;
+    onSortingChange?: OnChangeFn<SortingState>;
     rowActions?: RowAction<TRow>[];
 }
 declare function EntityTable<TRow extends RowData>(props: EntityTableProps<TRow>): React__default.ReactElement;
 
+/**
+ * JsonTree -- collapsible JSON tree themed by the semantic design tokens
+ * (dark-mode aware via CSS vars). Thin wrapper over react-json-tree so every
+ * package renders JSON trees the same way.
+ */
+
+interface JsonTreeProps {
+    data: unknown;
+    /** Expand every node initially. Default true. Ignored when `expandLevel` is set. */
+    expanded?: boolean;
+    /**
+     * Expand only the nodes above this depth initially (the root is level 0):
+     * 1 opens the root, 2 also its children. For large documents, where
+     * expanding everything is slow and unreadable.
+     */
+    expandLevel?: number;
+    /** Hide the root node label. Default false. */
+    hideRoot?: boolean;
+}
+declare function JsonTree({ data, expanded, expandLevel, hideRoot, }: JsonTreeProps): React__default.ReactElement;
+
 /**
  * PropertyList — read-only display of a record's properties.
  *
@@ -911,22 +1224,41 @@ declare function EntityTable<TRow extends RowData>(props: EntityTableProps<TRow>
  * - `"inline"` (default) — horizontal two-column grid, key left / value right.
  * - `"stacked"` — key label above each value.
  *
- * Values rendered by {@link PropertyValue}. Optional per-property schema
- * refines value rendering (schema is NOT required).
+ * Two densities:
+ * - `"compact"` (default) — small keys, tight rows: an inspector, a card.
+ * - `"comfortable"` — a detail page: a fixed label column, body-size text,
+ *   rows apart by space alone (no rules between them).
  *
- * Shared by the graph view's node/edge cards and the table inspector so all
- * property displays look identical.
+ * Without a schema, every property shows, keyed by its name, rendered by
+ * {@link PropertyValue} from its value; `propertySchemas` refines that per
+ * property. With a `schema` (an object JSON Schema), the schema decides, as it
+ * does for EntityTable's columns: which fields and in which order
+ * (`x-ui-column`), their labels (`x-ui-title`, `title`), and how each value
+ * renders (`x-ui-cell`, or a local renderer from `renderers`).
+ *
+ * Shared by the graph view's node/edge cards, the table inspector and detail
+ * pages, so all property displays look alike.
  */
 
 /** Layout mode for the property list. */
 type PropertyListLayout = "inline" | "stacked";
+/** Density: an inspector's (compact) or a detail page's (comfortable). */
+type PropertyListDensity = "compact" | "comfortable";
 interface PropertyListProps {
     /** Property name -> value. */
     properties: Record<string, unknown>;
-    /** Optional property name -> schema, to refine value rendering. */
+    /** Optional property name -> schema, to refine value rendering. Ignored with `schema`. */
     propertySchemas?: Record<string, JsonSchemaProperty>;
+    /** An object JSON Schema deciding the fields, their order, labels and rendering. */
+    schema?: JsonSchema;
+    /** Per-field overrides of `schema`, as EntityTable's uiSchema. */
+    uiSchema?: TableUiSchema;
+    /** Local cell renderers (`x-` names) the schema's x-ui-cell may name; given the whole record as the row. */
+    renderers?: Record<string, CellRenderer>;
     /** Layout mode. Default "inline" (horizontal key-value grid). */
     layout?: PropertyListLayout;
+    /** Density. Default "compact". */
+    density?: PropertyListDensity;
     /** Show a "Properties" section header. Default false. */
     showHeader?: boolean;
     /** Click value to copy it to the clipboard. Default true. */
@@ -935,7 +1267,7 @@ interface PropertyListProps {
     emptyLabel?: string;
     className?: string;
 }
-declare function PropertyList({ properties, propertySchemas, layout, showHeader, copyable, emptyLabel, className, }: PropertyListProps): React__default.ReactElement;
+declare function PropertyList(props: PropertyListProps): React__default.ReactElement;
 
 /**
  * PropertyValue — read-only, type-aware rendering of a single property value.
@@ -951,6 +1283,7 @@ declare function PropertyList({ properties, propertySchemas, layout, showHeader,
  * Schema is OPTIONAL and only REFINES rendering when present:
  *   - x-ui-cell / inferred type/format (date, datetime, boolean, number)
  *   - x-ui-cell: "json" forces a JSON tree even for a string value
+ *   - a local renderer (`renderers`, `x-` names) as EntityTable's, given the row
  * A plain string is treated as text by default — it is NOT auto-parsed as
  * JSON (avoids fragile, surprising behaviour). Schema is the only signal that
  * turns a JSON-looking string into a tree.
@@ -963,8 +1296,30 @@ interface PropertyValueProps {
     className?: string;
     /** Strings longer than this clamp with a "Show more" toggle. */
     clampChars?: number;
+    /** Local cell renderers (`x-` names) the schema's x-ui-cell may name, as EntityTable's. */
+    renderers?: Record<string, CellRenderer>;
+    /** The record the value belongs to: a renderer reads sibling fields from it. */
+    row?: Record<string, unknown>;
+}
+declare function PropertyValue({ value, schema, className, clampChars, renderers, row, }: PropertyValueProps): React__default.ReactElement;
+
+/**
+ * Resolve the fields a PropertyList shows from a JSON Schema -- as EntityTable
+ * resolves its columns (order, hidden, label, cell), so a record reads the same
+ * in a table and on its detail page.
+ *
+ * Pure: no React, no DOM.
+ */
+
+/** One field of a PropertyList: its key, its label, and the schema its value renders by. */
+interface PropertyField {
+    key: string;
+    label: string;
+    /** The property, with its resolved x-ui-cell and x-ui-cell-options. */
+    schema: JsonSchemaProperty;
 }
-declare function PropertyValue({ value, schema, className, clampChars, }: PropertyValueProps): React__default.ReactElement;
+/** The schema's fields in order, hidden ones dropped, each labelled and with its cell. */
+declare function resolvePropertyFields(schema: JsonSchema, uiSchema?: TableUiSchema): PropertyField[];
 
 /**
  * EntitySelect -- async searchable single-select for entity references.
@@ -1053,6 +1408,20 @@ declare function EntitySelect(props: EntitySelectProps): React$1.ReactElement;
  * Loading and error states per node are communicated via the node data
  * itself (isLoading, isError flags). The caller controls data fetching.
  *
+ * Large trees: with virtualize, only the rows in view are rendered -- the tree
+ * scrolls itself, in a box of bounded height the caller gives it -- and each
+ * row states its level and place among its siblings (aria-level, -setsize,
+ * -posinset), since the others are not in the DOM. Focus and the active node
+ * follow a row out of view: it is scrolled to, then focused. Off by default.
+ *
+ * Sticky parents (with virtualize): the ancestors of the topmost row in view
+ * stay pinned at the top -- deep in a level of thousands, its parent is one
+ * click away. Home/End focus the first and the last visible node.
+ *
+ * Type-to-find: given getTypeAheadLabel, typing moves focus to the next
+ * visible row whose label starts with what was typed (WAI-ARIA tree view).
+ * Off without it.
+ *
  * Extractable to @petrarca/sonnet-ui. Contains no app-specific imports.
  */
 
@@ -1097,8 +1466,35 @@ interface TreeViewProps<TData = Record<string, unknown>> {
      *  (nodes sharing the same parent). Clearing all selections resets the
      *  constraint so a different sibling group can be selected next. */
     constrainSelectionToSiblings?: boolean;
+    /** The node that is open (e.g. the file shown next to the tree): marked,
+     *  announced as selected and scrolled into view once shown. Independent of
+     *  the checkbox selection. */
+    activeId?: string;
+    /** Accessible name of the tree. Default "Tree". */
+    label?: string;
     /** Pixels of indentation per depth level. Default 20. */
     indentPx?: number;
+    /**
+     * Render only the rows in view. The tree then scrolls itself and needs a
+     * bounded height (h-full in a box of known height, or a fixed height).
+     * Default false: every visible row is rendered, as before.
+     */
+    virtualize?: boolean;
+    /** A row's height before it is measured, in pixels (virtualize). Default 32. */
+    rowHeight?: number;
+    /**
+     * Type-to-find: a node's label, as typed to find it. Given, typing moves
+     * focus to the next visible row whose label starts with what was typed
+     * (case-insensitive; one character again moves on to the next match).
+     */
+    getTypeAheadLabel?: (node: TreeNode<TData>) => string;
+    /**
+     * With virtualize: pin the ancestors of the topmost row in view at the top,
+     * so a long level's parent stays visible and one click away (it is scrolled
+     * to, focused and reported as a click). A visual aid, hidden from assistive
+     * technology -- ArrowLeft moves to the parent. Default false.
+     */
+    stickyParents?: boolean;
     className?: string;
 }
 /** Imperative handle exposed via ref for programmatic focus. */
@@ -1193,6 +1589,8 @@ declare const EntityTree: <TData extends Record<string, unknown>>(props: EntityT
  *     Faceted mode           -- on submit only (Enter on empty input after
  *                               chips are composed). Chip accumulation is
  *                               internal state; the caller never sees it.
+ *     Free text, debounce    -- the chips and the text, after the user stops
+ *                               typing (faceted with textKey)
  *     Remove chip / Clear    -- immediately (destructive ops need instant feedback)
  *
  * Faceted field selection:
@@ -1204,6 +1602,12 @@ declare const EntityTree: <TData extends Record<string, unknown>>(props: EntityT
  *   If the input ends with a space, facet matching is suppressed --
  *   the value is committed against facets[0] (implicit default).
  *
+ * Free text (faceted, with textKey):
+ *   The typed text is the search itself, not a facet value: it stays in the
+ *   input and is submitted with the chips as a term keyed textKey. Facets
+ *   come from the picker only (typing does not narrow or select them); while
+ *   a facet's value is entered, the text is held and comes back after.
+ *
  * Extractable to @petrarca/sonnet-ui: no app-specific imports.
  */
 
@@ -1260,6 +1664,8 @@ declare const DEFAULT_SEARCH_WIDGETS: SearchWidgetRegistry;
  *   Simple    -- no schema prop; produces a single search term
  *   Faceted   -- schema prop provided; facets derived from schema properties,
  *                value entry delegates to search widgets
+ *   Free text -- faceted plus textKey: the typed text is the query, submitted
+ *                with the chips; facets come from the picker
  *
  * Faceted field picker:
  *   - Opens on ArrowDown or chevron button click
@@ -1300,10 +1706,24 @@ interface SearchInputProps {
      * code OR display). Ignored in faceted mode.
      */
     searchFields?: string[];
+    /**
+     * Faceted mode only. The key of the free-text term: typed text is the
+     * search itself -- it stays in the input and is submitted with the chips as
+     * a term with this key -- and facets come from the picker (the chevron or
+     * ArrowDown). One field for a query and its filters. Without it, typed text
+     * narrows the picker or becomes a value of the first facet.
+     */
+    textKey?: string;
     placeholder?: string;
     className?: string;
     /** Disable all interaction (e.g. when a prerequisite is not met). */
     disabled?: boolean;
+    /**
+     * Faceted mode only: the filter the chips (and the free text) make, each
+     * time they change -- before Enter commits them through onChange. For a
+     * page with a control of its own that runs the search (a Run button).
+     */
+    onDraftChange?: (draft: FilterExpr) => void;
 }
 declare function SearchInput(props: SearchInputProps): React__default.ReactElement;
 
@@ -1316,7 +1736,7 @@ type Props$2 = {
  *
  * Displayed in CytoscapeControls toolbar with enabled/disabled state.
  */
-declare function ClipboardButton({ hasItems, onClick }: Props$2): react_jsx_runtime.JSX.Element;
+declare function ClipboardButton({ hasItems, onClick }: Props$2): React$1.JSX.Element;
 
 /**
  * ClipboardItem - Lightweight representation of an item in the clipboard.
@@ -1341,7 +1761,7 @@ type Props$1 = {
  * 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;
+declare function ClipboardItemComponent({ item, onAddItem, onRemove }: Props$1): React$1.JSX.Element;
 
 type Props = {
     onAddItem: (item: ClipboardItem, keepInClipboard: boolean) => void;
@@ -1351,6 +1771,7 @@ type Props = {
  *
  * Displays clipboard items with add and clear all functionality.
  */
-declare function ClipboardMenu({ onAddItem }: Props): react_jsx_runtime.JSX.Element;
+declare function ClipboardMenu({ onAddItem }: Props): React$1.JSX.Element;
 
-export { Alert, AlertDescription, AlertTitle, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Button, CELL_RENDERERS, Calendar, type CalendarProps, 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, DEFAULT_SEARCH_WIDGETS, DateInput, type DateInputProps, DateTimeInput, type DateTimeInputProps, 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, IconButton, type IconButtonProps, Input, InputError, InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea, Label, Popover, PopoverContent, PopoverTrigger, PropertyList, type PropertyListLayout, type PropertyListProps, PropertyValue, type PropertyValueProps, ResizeHandle, type ResizeHandleProps, type ResolvedColumn, type RowAction, ScrollArea, ScrollBar, SearchInput, type SearchInputProps, type SearchMode, type SearchWidget, type SearchWidgetProps, type SearchWidgetRegistry, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, 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, TabsSeparator, TabsTrigger, Textarea, TimeInput, type TimeInputProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TreeNode, TreeView, type TreeViewHandle, type TreeViewProps, badgeVariants, buttonVariants, createRenderer, useStore as useStepper };
+export { Alert, AlertDescription, AlertTitle, Avatar, AvatarFallback, AvatarImage, Badge, Button, CELL_RENDERERS, Calendar, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, ClipboardButton, ClipboardItemComponent as ClipboardItem, ClipboardMenu, CodeableConceptDisplay, CodedValueDisplay, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, CopyButton, DEFAULT_SEARCH_WIDGETS, DangerZone, DateInput, DateTimeInput, 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, EntityTable, EntityTree, IconButton, Input, InputError, InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea, JsonTree, Label, ListRow, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PropertyList, PropertyValue, RadioGroup, RadioGroupItem, ResizeHandle, ScrollArea, ScrollBar, SearchInput, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetBody, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetTitle, SheetTrigger, SimpleGroup, SimpleStack, SimpleTooltip, Skeleton, Spinner, SplitButton, Stepper, StepperContent, StepperDescription, StepperIndicator, StepperItem, StepperList, StepperNext, StepperPrev, StepperSeparator, StepperTitle, StepperTrigger, Tabs, TabsContent, TabsList, TabsSeparator, TabsTrigger, Textarea, TimeInput, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, TreeView, ViewSwitch, badgeVariants, buttonVariants, createRenderer, resolvePropertyFields, useStore as useStepper };
+export type { BadgeProps, CalendarProps, CellRenderer, CellRendererProps, CodeableConceptDisplayProps, CodedValueDisplayProps, CopyButtonProps, DangerZoneAction, DangerZoneProps, DateInputProps, DateTimeInputProps, EntitySelectProps, EntityTableProps, EntityTreeHandle, EntityTreeProps, IconButtonProps, JsonTreeProps, ListRowProps, PropertyField, PropertyListDensity, PropertyListLayout, PropertyListProps, PropertyValueProps, ResizeHandleProps, ResolvedColumn, RowAction, SearchInputProps, SearchMode, SearchWidget, SearchWidgetProps, SearchWidgetRegistry, SplitButtonItem, SplitButtonProps, StepperProps, TableDensity, TableLoadMore, TableUiSchema, TimeInputProps, TreeNode, TreeViewHandle, TreeViewProps, ViewSwitchOption, ViewSwitchProps };