@servicetitan/anvil2 3.14.1 → 3.15.1

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

@@ -3,144 +3,158 @@ import { AiMarkWithTooltipOrPopoverProps, DataAttributes, LayoutUtilProps, Size
 import { OptionContent } from '../../../internal/types/optionContent';
 import { MultiSelectFieldChipProps } from '../../../components/MultiSelectField/types';
 /**
- * Partial chip props that can be returned from the TreeSelectField `getChipProps` callback.
- * Supports `icon` or `avatar` (mutually exclusive) and all other chip props as optional overrides.
- * Core props (`label`, `onClose`, `className`, `title`, `size`) are managed by the component.
- * Selected values with `disabled: true` omit `onClose` so the chip is locked.
+ * Per-selection chip overrides. The field owns label, removal, class, title,
+ * while `icon` and `avatar` remain mutually exclusive.
  */
 export type TreeSelectFieldChipProps = MultiSelectFieldChipProps;
-/**
- * Rich content configuration for a TreeSelectField option row.
- * Controls the avatar, icon, description, and chip display within an option.
- */
+/** Avatar, icon, description, and chip content for an option row. */
 export type TreeSelectFieldOptionContent = OptionContent;
-/**
- * A node in the tree structure.
- * @property id - Unique identifier for the node.
- * @property label - Display text for the node.
- * @property searchText - Additional text to match during search, beyond label.
- * @property disabled - Whether the node is disabled for selection. When a
- *   disabled node is already in the field `value`, its chip is locked (no close
- *   control) and backspace skips it — same as MultiSelectField.
- * @property extra - Pass-through data for consumer convenience.
- * @property children - Child nodes. undefined=leaf, []=empty branch, [...]=branch, null=unloaded (lazy).
- * @property childCount - Server-provided count, optionally displayed on branch nodes.
- * @property path - Optional ancestor ids, root→parent. Selection-ancestry
- *   metadata, primarily meaningful on value objects: when a selected node lives
- *   under branches that aren't currently loaded, `path` lets the field show the
- *   correct ancestor check states without a parent-of lookup. The field emits
- *   it on selections whose ancestry it knows, and reads it from incoming value
- *   so a persisted-then-restored selection resolves exactly. Not a structural
- *   tree attribute — omit it on `loadOptions` results.
- */
+/** Node returned by {@link TreeSelectFieldProps.loadOptions}. */
 export type TreeSelectFieldNode = {
+    /** Stable identifier used for selection, expansion, and ARIA ids. */
     id: string | number;
+    /** Visible option text and the selected-value label. */
     label: string;
+    /** Additional text considered by the default synchronous filter. */
     searchText?: string;
+    /** Prevents selection; selected disabled values also cannot be removed. */
     disabled?: boolean;
+    /** Consumer data copied to emitted values. */
     extra?: Record<string, unknown>;
+    /** Rich option-row content. */
     content?: TreeSelectFieldOptionContent;
+    /**
+     * `undefined` is a leaf, `[]` an empty branch, an array a loaded branch, and
+     * `null` a branch whose children load on expansion.
+     */
     children?: TreeSelectFieldNode[] | null;
+    /** Total immediate children when the loaded or filtered array is incomplete. */
     childCount?: number;
+    /**
+     * Ancestor ids from root to parent for restoring selection state before
+     * ancestors load. Omit from loaded tree nodes.
+     */
     path?: (string | number)[];
 };
 /**
- * The value shape stored in the value array. Intentionally slim — just enough to render chips and identify the node.
- * @property id - The node's unique identifier.
- * @property label - The node's display text.
- * @property extra - Pass-through data from the node.
- * @property path - Optional ancestor ids, root→parent. See {@link TreeSelectFieldNode.path}.
- * @property disabled - When true, the chip is locked (no close control; backspace
- *   skips it). Emitted from the tree when the matching node is disabled; can
- *   also be set on controlled values to lock a selection.
+ * Controlled selection shape copied from a node.
+ * `path` preserves ancestor check states across unloaded trees; `disabled`
+ * locks the selected chip.
  */
 export type TreeSelectFieldValue = Pick<TreeSelectFieldNode, "id" | "label" | "extra" | "path" | "disabled">;
 /**
- * Controls which nodes are selectable and how the value array is shaped.
- * - "ALL" — any node selectable, all checked nodes in value
- * - "BRANCH_PRIORITY" — any node selectable, branches replace leaves when fully checked
- * - "BRANCH_ONLY" — only branches selectable, leaves visible but inert
- * - "LEAF_PRIORITY" — only leaves selectable (branches expand), leaves + childless branches in value
- * - "LEAF_ONLY" — only leaves selectable (branches expand), strictly leaves in value
+ * Controls node selectability and linked-mode value compaction.
+ * Independent mode stores the clicked node directly; single mode emits its one
+ * selected node.
+ * - `"ALL"` — retain every checked node.
+ * - `"BRANCH_PRIORITY"` — fully checked branches replace descendants.
+ * - `"BRANCH_ONLY"` — only branches are selectable and retained.
+ * - `"LEAF_PRIORITY"` — retain leaves and childless branches.
+ * - `"LEAF_ONLY"` — retain leaves; nonempty branches cascade and empty branches are inert.
  */
 export type TreeSelectFieldValueConsistsOf = "ALL" | "BRANCH_PRIORITY" | "BRANCH_ONLY" | "LEAF_PRIORITY" | "LEAF_ONLY";
-/**
- * Imperative handle for the TreeSelectField component.
- * @property clearCache - Clears the options cache.
- * @property invalidate - Clears the cache and triggers a fresh options load.
- * @property expandAll - Expands all tree nodes.
- * @property collapseAll - Collapses all tree nodes.
- */
+/** Cache and expansion controls for {@link TreeSelectField}. */
 export type TreeSelectFieldHandle = {
+    /** Clears cached search/child results and recorded lazy ancestry. */
     clearCache: () => void;
+    /** Clears caches and ancestry, then reloads the current search without caching it. */
     invalidate: () => void;
+    /** Expands every currently loaded branch. */
     expandAll: () => void;
+    /** Collapses every branch. */
     collapseAll: () => void;
 };
-/**
- * Props for the TreeSelectField component.
- * @property label - Required label for accessibility.
- * @property value - Controlled value array. Always an array, even in single-select mode.
- * @property onSelectedOptionsChange - Callback when selection changes.
- * @property loadOptions - Async function to load tree nodes. Called with parentNode for lazy branch loading.
- * @property selectionMode - "single": one node at a time. "independent": no cascade. "linked" (default): parent-child cascade.
- * @property valueConsistsOf - Controls which nodes are selectable and how the value is shaped.
- * @property defaultExpandLevel - Initial expand depth. 0=collapsed, Infinity=all.
- * @extends LayoutUtilProps
- */
 export type TreeSelectFieldProps = {
+    /** Base id for the input, tree, and its popover or dialog. Generated when omitted. */
     id?: string;
+    /** Names the tree and dialog and provides the fallback field label. */
     label: string;
+    /** Replaces the visible, input-associated field label. */
     labelNode?: ReactNode;
+    /** Visually hides the label while retaining it for assistive technology. */
     hideLabel?: boolean;
+    /** Text shown when no value is selected. */
     placeholder?: string;
+    /** Trigger field size. Defaults to `"medium"`; dialog uses `"medium"`. */
     size?: Extract<Size, "small" | "medium" | "large">;
+    /** Uses a popover on desktop and dialog on mobile unless forced. Defaults to `"auto"`. */
     displayMenuAs?: "auto" | "popover" | "dialog";
+    /** Applies error styling; strings render as messages. React elements are deprecated. */
     error?: boolean | string | string[] | ReactElement;
+    /** Supplemental guidance rendered below the field. */
     hint?: ReactElement | string;
-    /** Additional information to display in a tooltip next to the label. */
+    /** Tooltip content shown beside the label. */
     moreInfo?: ReactNode;
     /**
-     * AI mark configuration to display next to the label.
-     * Can be a boolean to show a simple AI mark, or an object with tooltip/popover configuration.
+     * Shows an AI mark beside the label. `true` uses the simple mark; pass
+     * tooltip or popover configuration for an explanatory mark.
      */
     labelAiMark?: AiMarkWithTooltipOrPopoverProps["aiMark"];
+    /** Descriptive text rendered below the field. */
     description?: ReactElement | string;
+    /** Warning messages rendered below the field. */
     warning?: string | string[];
+    /** Adds the required indicator to the label. */
     required?: boolean;
+    /** Prevents focus, opening, selection, and chip removal. */
     disabled?: boolean;
+    /** Keeps the field focusable and navigable while preventing selection changes. */
     readOnly?: boolean;
+    /** Content before the selection and search area. */
     prefix?: string | ReactElement;
+    /** Content after the selection and search area. */
     suffix?: string | ReactElement;
     className?: string;
     style?: CSSProperties;
+    /**
+     * Hides multi-select search in the field trigger. Dialog multi-select keeps
+     * search; single-select always uses a read-only label input.
+     */
     disableSearch?: boolean;
+    /** Delay before search calls `loadOptions`. Defaults to `200`. */
     debounceMs?: number;
+    /**
+     * Controlled query passed to `loadOptions` and used to substring-filter
+     * loaded labels, search text, and descendant paths.
+     */
     searchValue?: string;
+    /** Runs immediately on search edits and with `""` when closing resets search. */
     onSearchChange?: (v: string) => void;
+    /** Restricts trigger chips to one row. Dialog chips always use one row. Defaults to `false`. */
     singleRow?: boolean;
+    /** Maximum trigger chips before `+N`. Defaults to `10`; dialog uses `20`. */
     maxChips?: number;
     /**
-     * Callback to customize chip props for each selected option.
-     * Allows customizing chip appearance (color, icon, avatar, etc.) per option.
-     * Core props (label, onClose, className, title, size) are managed by the component and excluded from this type.
-     * Selected values with `disabled: true` omit onClose so the chip is locked.
-     * @param value - The selected value the chip represents
-     * @returns Partial chip props to merge onto the chip
+     * Customizes each selection chip without overriding field-owned behavior.
+     * Disabled values omit the chip's remove action.
      */
     getChipProps?: (value: TreeSelectFieldValue) => TreeSelectFieldChipProps;
+    /** Enables windowed tree rendering for large data sets. Defaults to `false`. */
     virtualize?: boolean;
+    /** Controlled selections; remains an array in single-selection mode. */
     value: TreeSelectFieldValue[];
+    /** Receives the next controlled selection. */
     onSelectedOptionsChange: (nodes: TreeSelectFieldValue[]) => void;
+    /** Controls single selection, independent checks, or linked parent-child checks. Defaults to `"linked"`. */
     selectionMode?: "single" | "independent" | "linked";
+    /** Selection and linked-mode retention strategy. Defaults to `"LEAF_PRIORITY"`. */
     valueConsistsOf?: TreeSelectFieldValueConsistsOf;
+    /** Initial uncontrolled expansion depth. Defaults to `0`; use `Infinity` to expand every loaded level. */
     defaultExpandLevel?: number;
+    /** Controlled set of expanded branch ids. */
     expandedIds?: Set<string | number>;
+    /** Receives the next expanded-id set in controlled expansion mode. */
     onExpandedIdsChange?: (ids: Set<string | number>) => void;
+    /**
+     * Loads roots/search results with the query. Lazy-child calls pass `""` and
+     * `parentNode`; mark unloaded branches with `children: null`.
+     */
     loadOptions: (searchValue: string, parentNode?: TreeSelectFieldNode) => TreeSelectFieldNode[] | Promise<TreeSelectFieldNode[]>;
+    /** Configures separate search and child-result caches, each enabled with at most 15 entries by default. */
     cache?: {
         enabled?: boolean;
         maxSize?: number;
     };
+    /** Loads on mount for `"auto"` or `"immediate"`, and on first open for `"open"`. Defaults to `"auto"`. */
     initialLoad?: "auto" | "immediate" | "open";
 } & LayoutUtilProps & DataAttributes;

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

@@ -2,30 +2,16 @@ import { KeyboardEvent } from 'react';
 import { TreeSelectFieldNode, TreeSelectFieldValue } from '../TreeSelectField/types';
 import { DataAttributes } from '../../../types';
 /**
- * TreeSelectMenu component for selecting tree nodes from a dropdown triggered by any element.
- *
- * Features:
- * - Attaches to any trigger element via a render prop
- * - Async tree data loading via loadOptions callback with optional LRU caching
- * - Single-select and multi-select modes with linked/independent cascade
- * - Cascading parent/child selection in linked mode
- * - Search filtering across visible nodes
- * - Lazy branch expansion with on-demand children loading
- * - Virtualized rendering for large trees via the virtualize prop
- * - Full keyboard navigation (ArrowDown/Up, ArrowRight/Left, Enter, Home/End, Escape)
- * - Supports both popover and dialog display modes
- * - Adaptive display based on device (mobile uses dialog)
- * - Configurable popover width
- * - Imperative handle for clearCache, invalidate, expandAll, collapseAll
- * - Full accessibility support with ARIA tree attributes
+ * Searchable tree selection opened by a consumer-rendered trigger.
+ * Supports async root/search loading and lazy branch loading in a popover or dialog.
  *
  * @example
  * <TreeSelectMenu
- *   trigger={(props) => <Button {...props}>Select Categories</Button>}
+ *   trigger={(triggerProps) => <Button {...triggerProps}>Select categories</Button>}
  *   label="Categories"
  *   value={selected}
  *   onSelectedOptionsChange={setSelected}
- *   loadOptions={async (search) => fetchCategories(search)}
+ *   loadOptions={loadCategories}
  * />
  */
 export declare const TreeSelectMenu: import('react').ForwardRefExoticComponent<{

package/dist/src/beta/components/TreeSelectMenu/TreeSelectMenuSync.d.ts

@@ -2,62 +2,24 @@ import { MatchSorterOptions } from 'match-sorter';
 import { TreeSelectMenuNode, TreeSelectMenuProps } from './types';
 import { TreeSyncFilterFn } from '../TreeSelectField/internal/treeSync';
 export type { TreeSyncFilterFn };
-/**
- * Props for the TreeSelectMenuSync component.
- * @property options - The static tree options to display.
- * @property filter - Custom filter function or MatchSorterOptions to control how nodes are filtered during search.
- *   By default, filters by label and searchText using match-sorter, preserving parent nodes of any match.
- * @extends TreeSelectMenuProps
- */
 export type TreeSelectMenuSyncProps = Omit<TreeSelectMenuProps, "loadOptions" | "debounceMs" | "cache" | "initialLoad"> & {
-    /**
-     * The static tree options to display in the menu.
-     */
+    /** Complete tree used for selection and client-side search. */
     options: TreeSelectMenuNode[];
     /**
-     * Controls how options are filtered when the user types a search value.
-     * Can be a function that returns nodes in the desired display order,
-     * or a MatchSorterOptions object to customize the default match-sorter behavior.
-     *
-     * By default, nodes are filtered by `label` and `searchText` using match-sorter,
-     * and parents of matching nodes are preserved in the tree structure.
-     *
-     * @example
-     * <TreeSelectMenuSync
-     *   options={options}
-     *   filter={(nodes, searchValue) => {
-     *     return nodes.filter((node) =>
-     *       node.label.toLowerCase().includes(searchValue.toLowerCase())
-     *     );
-     *   }}
-     * />
+     * Custom function or match-sorter options. The default matches `label` and
+     * `searchText`. Default and option-object filters preserve ancestors of
+     * matches; a function replaces that behavior.
      *
      * @example
-     * <TreeSelectMenuSync
-     *   options={options}
-     *   filter={{ keys: ["label"] }}
-     * />
+     * filter={(nodes, searchValue) => customTreeFilter(nodes, searchValue)}
+     * // or
+     * filter={{ keys: ["label"] }}
      */
     filter?: TreeSyncFilterFn | MatchSorterOptions<TreeSelectMenuNode>;
 };
 /**
- * TreeSelectMenuSync is a simplified wrapper around TreeSelectMenu for static (non-async) tree data.
- *
- * Features:
- * - Accepts static `options` instead of `loadOptions`.
- * - Performs client-side filtering with tree-structure awareness (parents of matches are preserved).
- * - Accepts a custom filter function or MatchSorterOptions to customize filtering behavior.
- * - Invalidates the menu when the options contents change.
- * - Supports all other props of TreeSelectMenu.
- *
- * @example
- * <TreeSelectMenuSync
- *   trigger={(props) => <Button {...props}>Select location</Button>}
- *   label="Select location"
- *   options={locationTree}
- *   value={selected}
- *   onSelectedOptionsChange={setSelected}
- * />
+ * Static-data variant of {@link TreeSelectMenu}.
+ * Filters `options` on the client and refreshes the menu when they change.
  */
 export declare const TreeSelectMenuSync: {
     (props: TreeSelectMenuSyncProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/TreeSelectMenu/parts.d.ts

@@ -1,10 +1,10 @@
 /**
  * `data-anv-part` names for TreeSelectMenu interactive sub-elements.
  *
- * Only trigger chrome is owned here. Tree `menu` / `option` / `expand-toggle`
- * come from TreeSelectField internals; `popover` / `dialog` / footer buttons
- * from shared option shells. Consumer `data-*` merges into the trigger
- * render-prop bag (no wrapper root).
+ * Only the trigger and search input are owned here. Tree parts come from
+ * TreeSelectField internals; shell and footer parts come from shared option
+ * shells. Consumer `data-*` merges into the trigger bag because there is no
+ * wrapper root.
  */
 export declare const PARTS: {
     readonly trigger: "trigger";

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

@@ -2,103 +2,93 @@ import { KeyboardEvent, ReactElement, RefObject } from 'react';
 import { DataAttributes } from '../../../types';
 import { ConfirmationProp } from '../../../internal/types/confirmationTypes';
 import { TreeSelectFieldNode as TreeSelectMenuNode, TreeSelectFieldValue as TreeSelectMenuValue, TreeSelectFieldValueConsistsOf as TreeSelectMenuValueConsistsOf, TreeSelectFieldHandle, TreeSelectFieldOptionContent as TreeSelectMenuOptionContent } from '../TreeSelectField/types';
-/**
- * Configures a "Clear" button in the menu footer. Presence of this prop
- * enables the button; omit to suppress.
- *
- * - `onClick` — called when the user clicks Clear.
- * - `label` — button label (default "Clear").
- * - `disabled` — whether the button is inert. Filter adapters typically tie
- *   this to `!isActive(filter)` so the button is dim when nothing is selected.
- */
+/** Configuration for the optional footer Clear button. */
 export type TreeSelectMenuClearConfig = {
+    /** Runs before the menu closes; update the controlled value in this handler. */
     onClick: () => void;
+    /** Button text. Defaults to `"Clear"`. */
     label?: string;
+    /** Prevents clearing while preserving the button in the footer. */
     disabled?: boolean;
 };
 export type { TreeSelectMenuNode, TreeSelectMenuValue, TreeSelectMenuValueConsistsOf, TreeSelectMenuOptionContent, };
-/**
- * Imperative handle for the TreeSelectMenu component.
- * @property clearCache - Clears the options cache.
- * @property invalidate - Clears the cache and triggers a fresh options load.
- * @property expandAll - Expands all tree nodes.
- * @property collapseAll - Collapses all tree nodes.
- */
+/** Cache and expansion controls for {@link TreeSelectMenu}. */
 export type TreeSelectMenuHandle = TreeSelectFieldHandle;
-/**
- * Props provided to the trigger render function.
- * @property ref - Ref to attach to the trigger element for positioning and focus restoration
- * @property onClick - Click handler to toggle the menu
- * @property onKeyDown - Key handler for keyboard navigation
- * @property aria-haspopup - ARIA attribute indicating the trigger opens a tree
- * @property aria-controls - ARIA attribute linking to the tree element
- * @property aria-expanded - ARIA attribute indicating whether the menu is open
- * @property data-state - Data attribute indicating the open/close state
- */
+/** Props to spread onto the button returned by the trigger render function. */
 export type TreeSelectMenuTriggerProps = {
+    /** Positions the popover and receives restored focus after explicit closes. */
     ref: RefObject<HTMLButtonElement>;
+    /** Toggles the menu. */
     onClick: () => void;
+    /** Opens the menu with ArrowDown, Enter, or Space. */
     onKeyDown: (e: KeyboardEvent<HTMLButtonElement>) => void;
+    /** Identifies the controlled popup as a tree. */
     "aria-haspopup": "tree";
+    /** References the tree element. */
     "aria-controls": string;
+    /** Reflects whether the menu is open. */
     "aria-expanded": boolean;
+    /** Open/closed token for the trigger: `"open"` or `"close"`. */
     "data-state": "open" | "close";
 } & DataAttributes;
-/**
- * Props for the TreeSelectMenu component.
- * @property id - Optional id for the menu; an internal id is generated when omitted.
- * @property trigger - Render function that receives trigger props and returns the element that opens the menu.
- * @property onMenuKeyDown - Called for key events on the open menu, after internal navigation handling.
- * @property onImplicitClose - Called when the menu closes implicitly (outside click, blur, Escape).
- * @property onExplicitClose - Called when the menu closes from an explicit selection or trigger toggle.
- * @property label - Accessible label for the menu. Used by screen readers but not rendered visually.
- * @property searchPlaceholder - Placeholder text for the search input inside the menu.
- * @property displayMenuAs - "auto" (default): popover on desktop, dialog on mobile; or force "popover"/"dialog".
- * @property virtualize - When true, renders the tree with windowed virtualization for large datasets.
- * @property disableSearch - Hides the search input and disables search filtering.
- * @property popoverWidth - Width of the popover. Accepts a CSS width value or "reference" to match trigger width.
- * @property debounceMs - Milliseconds to debounce search input before calling loadOptions. Defaults to 200.
- * @property onSearchChange - Called when the search value changes. Pair with controlled search wiring.
- * @property value - Controlled value array. Always an array, even in single-select mode.
- * @property onSelectedOptionsChange - Callback when selection changes.
- * @property selectionMode - "single": one node at a time. "independent": no cascade. "linked" (default): parent-child cascade.
- * @property valueConsistsOf - Controls which nodes are selectable and how the value is shaped.
- * @property defaultExpandLevel - Initial expand depth. 0=collapsed, Infinity=all.
- * @property expandedIds - Controlled set of expanded branch node ids. Pair with onExpandedIdsChange.
- * @property onExpandedIdsChange - Called when the expanded set changes (controlled expansion).
- * @property loadOptions - Async function to load tree nodes. Called with parentNode for lazy branch loading.
- * @property cache - LRU cache configuration for loadOptions results ({ enabled, maxSize }).
- * @property initialLoad - When loadOptions first runs: "immediate" on mount, "open" when the menu opens, or "auto".
- * @property confirmation - When set, selections are buffered as a draft inside the open menu and only commit on Apply; dismissing the menu discards the draft. Pass `true` for default Apply/Cancel labels, or an object to customize.
- * @property clear - Configures a "Clear" button in the menu footer. Omit to suppress.
- */
 export type TreeSelectMenuProps = {
+    /** Base id for the tree and its popover or dialog. Generated when omitted. */
     id?: string;
+    /** Renders the button that opens the menu; spread the supplied props onto it. */
     trigger: (props: TreeSelectMenuTriggerProps) => ReactElement;
+    /**
+     * Runs before the menu's keyboard handling.
+     * Call `preventDefault` to suppress its default behavior.
+     */
     onMenuKeyDown?: (e: KeyboardEvent) => void;
+    /** Runs when Tab or popover dismissal closes through the non-restoring focus path. */
     onImplicitClose?: () => void;
+    /** Runs after an intentional close that restores focus to the trigger. */
     onExplicitClose?: () => void;
+    /** Names the tree and supplies the dialog title. */
     label: string;
+    /** Search-field placeholder. Defaults to `"Search..."`; ignored when search is disabled. */
     searchPlaceholder?: string;
+    /** Uses a popover on desktop and dialog on mobile unless forced. Defaults to `"auto"`. */
     displayMenuAs?: "auto" | "popover" | "dialog";
+    /** Enables windowed tree rendering for large data sets. Defaults to `false`. */
     virtualize?: boolean;
+    /** Removes the search field so the tree handles keyboard input directly. Defaults to `false`. */
     disableSearch?: boolean;
+    /** Popover width, or `"reference"` to match the trigger. Defaults to `320`. */
     popoverWidth?: "reference" | number | string;
+    /** Delay before search calls {@link loadOptions}. Defaults to `200`. */
     debounceMs?: number;
+    /** Runs immediately on search edits and with `""` when closing resets search. */
     onSearchChange?: (v: string) => void;
+    /** Controlled selections; remains an array in single-selection mode. */
     value: TreeSelectMenuValue[];
+    /** Receives immediate changes, or the applied draft when confirmation is enabled. */
     onSelectedOptionsChange: (nodes: TreeSelectMenuValue[]) => void;
+    /** Controls single selection, independent checks, or linked parent-child checks. Defaults to `"linked"`. */
     selectionMode?: "single" | "independent" | "linked";
+    /** Controls which node kinds are selectable and retained in {@link value}. Defaults to `"LEAF_PRIORITY"`. */
     valueConsistsOf?: TreeSelectMenuValueConsistsOf;
+    /** Initial uncontrolled expansion depth. Defaults to `0`; use `Infinity` to expand every loaded level. */
     defaultExpandLevel?: number;
+    /** Controlled set of expanded branch ids. */
     expandedIds?: Set<string | number>;
+    /** Receives the next expanded-id set in controlled expansion mode. */
     onExpandedIdsChange?: (ids: Set<string | number>) => void;
+    /**
+     * Loads root/search results, or the children of `parentNode` for lazy branches.
+     * Mark an unloaded branch with `children: null`.
+     */
     loadOptions: (searchValue: string, parentNode?: TreeSelectMenuNode) => TreeSelectMenuNode[] | Promise<TreeSelectMenuNode[]>;
+    /** Configures separate search and child-result caches, each enabled with at most 15 entries by default. */
     cache?: {
         enabled?: boolean;
         maxSize?: number;
     };
+    /** Loads on mount for `"auto"` or `"immediate"`, and on first open for `"open"`. Defaults to `"auto"`. */
     initialLoad?: "auto" | "immediate" | "open";
+    /** Buffers changes until Apply; dismissing the menu discards the draft. */
     confirmation?: ConfirmationProp;
+    /** Adds a footer Clear button that closes the menu after invoking its handler. */
     clear?: TreeSelectMenuClearConfig;
 } & DataAttributes;

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

@@ -2,82 +2,54 @@ import { ReactNode } from 'react';
 import { TextFieldProps } from '../../../components/TextField';
 import { DistributiveOmit } from '../../../types';
 export type TypeaheadTextFieldOption<T = string> = {
+    /** Text committed to the input when the option is selected. */
     label: string;
+    /** Consumer value returned through `onSelectOption`. */
     value: T;
 };
 type LoadOptionsResult<T> = TypeaheadTextFieldOption<T>[] | Promise<TypeaheadTextFieldOption<T>[]>;
 export type TypeaheadTextFieldProps<T = string> = DistributiveOmit<TextFieldProps, "value" | "defaultValue" | "onChange" | "suffix"> & {
-    /**
-     * Controlled input value.
-     */
+    /** Current input text in controlled mode. */
     value?: string;
-    /**
-     * Default input value for uncontrolled mode.
-     */
+    /** Initial input text in uncontrolled mode. */
     defaultValue?: string;
-    /**
-     * Fired whenever the input value changes (from typing, selection, or clear).
-     */
+    /** Runs when typing, selection, or clearing changes the input text. */
     onChange?: (value: string) => void;
-    /**
-     * Returns suggestions for the current input value.
-     * May be synchronous or return a Promise.
-     */
+    /** Resolves suggestions for the current input after the configured delay. */
     loadOptions: (search: string) => LoadOptionsResult<T>;
-    /**
-     * Fired when a suggestion is selected from the menu.
-     */
+    /** Runs after the input adopts the selected option's label. */
     onSelectOption?: (option: TypeaheadTextFieldOption<T>) => void;
     /**
-     * Debounce in ms between an input change and the loadOptions call.
+     * Delay in milliseconds before each `loadOptions` request.
      * @default 300
      */
     debounceMs?: number;
     /**
-     * Label shown when there are no suggestions to render.
+     * Status shown when no suggestions are available.
      * @default "No suggestions found"
      */
     noSuggestionsLabel?: string;
     /**
-     * Label shown while suggestions are loading and there are no options yet.
+     * Status announced while loading with no options to display.
      * @default "Loading..."
      */
     loadingLabel?: string;
-    /**
-     * Custom renderer for the label of an option row.
-     */
+    /** Replaces row content; selection still commits the option's `label`. */
     renderOption?: (option: TypeaheadTextFieldOption<T>) => ReactNode;
     /**
-     * If true, the suggestion menu opens whenever the input is focused and has
-     * a non-empty value.
+     * Opens and reloads suggestions when a non-empty input receives focus.
      * @default true
      */
     openOnFocus?: boolean;
     /**
-     * If true, also opens the menu on focus/click when the input is empty.
-     * Useful for "show all" style menus that don't require pre-typing.
+     * Allows focus or click to load suggestions for an empty input.
      * @default false
      */
     openOnEmptyFocus?: boolean;
 };
 /**
- * TypeaheadTextField component — a text input that shows an async
- * suggestion menu as the user types.
- *
- * Features:
- * - `loadOptions` fetches suggestions (sync or async) for the current input
- * - Debounced fetching via `debounceMs`
- * - Custom suggestion rendering via `renderOption`
- * - Configurable open-on-focus behavior, including for an empty input
- * - Loading and no-suggestions states with customizable labels
- * - All standard TextField props (label, hint, error, prefix, etc.)
- *
- * @example
- * <TypeaheadTextField
- *   label="City"
- *   loadOptions={(search) => fetchCities(search)}
- *   onSelectOption={(option) => console.log(option)}
- * />
+ * Text field with a debounced suggestion list that accepts synchronous or
+ * asynchronous option loading.
  */
 export declare function TypeaheadTextField<T = string>({ value: valueProp, defaultValue, onChange, loadOptions, onSelectOption, debounceMs, noSuggestionsLabel, loadingLabel, renderOption, openOnFocus, openOnEmptyFocus, onFocus, onBlur, onKeyDown, onClick, disabled, readOnly, loading: loadingProp, ...textFieldProps }: TypeaheadTextFieldProps<T>): import("react/jsx-runtime").JSX.Element;
 export declare namespace TypeaheadTextField {

package/dist/src/beta/components/TypeaheadTextField/internal/SuggestionItem.d.ts

@@ -1,29 +1,12 @@
 import { HTMLAttributes, ReactNode } from 'react';
 export type SuggestionItemProps = HTMLAttributes<HTMLDivElement> & {
-    /** Visible label content for the option. */
     label: ReactNode;
-    /**
-     * Reflects ARIA selection state on the `role="option"` element. Drives the
-     * `aria-activedescendant` highlight: set it for the option the user has
-     * navigated to with the arrow keys and would commit on Enter. Do not use it
-     * for "this suggestion was previously chosen", which isn't a meaningful
-     * state for a suggestion list.
-     */
     selected?: boolean;
-    /** Disables selection and dims the row. */
     disabled?: boolean;
 };
+/** Non-focusable option row; the input retains focus via active descendant. */
 export declare const SuggestionItem: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
-    /** Visible label content for the option. */
     label: ReactNode;
-    /**
-     * Reflects ARIA selection state on the `role="option"` element. Drives the
-     * `aria-activedescendant` highlight: set it for the option the user has
-     * navigated to with the arrow keys and would commit on Enter. Do not use it
-     * for "this suggestion was previously chosen", which isn't a meaningful
-     * state for a suggestion list.
-     */
     selected?: boolean;
-    /** Disables selection and dims the row. */
     disabled?: boolean;
 } & import('react').RefAttributes<HTMLDivElement>>;