@servicetitan/anvil2 3.14.1 → 3.15.1

package/dist/src/beta/components/Toolbar/ToolbarSelect.d.ts

@@ -2,66 +2,25 @@ import { ListboxItemType } from '../../../components/Listbox';
 import { default as Popover } from '../../../internal/components/Popover';
 import { ToolbarItemAppearance } from './types';
 import { DataTrackingId } from '../../../types';
-/**
- * Type for items in the ToolbarSelect dropdown
- * @extends ItemType<T & { id: string }>
- */
 type ToolbarSelectItem<T = Record<string, unknown>> = ListboxItemType<T & {
     id: string;
 }>;
-/**
- * Props for the ToolbarSelect component
- * @extends Omit<React.ComponentPropsWithoutRef<typeof Popover.Button>, "appearance" | "onChange">
- */
+/** @extends Omit<React.ComponentPropsWithoutRef<typeof Popover.Button>, "appearance" | "onChange"> */
 export type ToolbarSelectProps<T = Record<string, unknown>> = Omit<React.ComponentPropsWithoutRef<typeof Popover.Button>, "appearance" | "onChange"> & {
-    /**
-     * Visual appearance of the select button
-     * @default ghost
-     */
+    /** Visual emphasis within the toolbar. Defaults to `ghost`. */
     appearance?: ToolbarItemAppearance;
-    /**
-     * Callback function when selection changes
-     */
+    /** Called with the selected item's ID. */
     onChange?: (optionId: string) => void;
-    /**
-     * Currently selected item ID (controlled mode)
-     */
+    /** Controlled selected ID. Omit to select and manage the first item internally. */
     selected?: string;
-    /**
-     * Array of selectable items
-     */
+    /** Options displayed in the listbox; the first is the uncontrolled default. */
     items: ToolbarSelectItem<T>[];
-    /**
-     * Accessible label for the select dropdown dialog (e.g. "Status options").
-     */
+    /** Accessible name for the options popover, such as "Status options". */
     accessibleLabel: string;
 } & DataTrackingId;
 /**
- * ToolbarSelect component provides a dropdown selector within a toolbar.
- *
- * Features:
- * - Dropdown menu with selectable options
- * - Controlled and uncontrolled usage patterns
- * - Automatic overflow menu integration
- * - Accessibility support with proper ARIA labels
- * - Ghost and primary appearance options
- * - Dropdown arrow icon indicator
- * - Listbox integration for keyboard navigation
- *
- * @example
- * <ToolbarSelect
- *   items={fontOptions}
- *   selected="arial"
- *   accessibleLabel="Font family"
- *   onChange={(id) => setFont(id)}
- * />
- *
- * @example
- * <ToolbarSelect
- *   appearance="primary"
- *   items={colorOptions}
- *   accessibleLabel="Text color"
- * />
+ * Single-select toolbar control that inherits its size and participates in
+ * roving focus and collapse overflow.
  */
 export declare const ToolbarSelect: import('react').ForwardRefExoticComponent<Omit<Omit<Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children"> & import('../../..').LayoutUtilProps & DataTrackingId & {
     aiMark?: boolean | import('../../..').AiIconName;
@@ -84,26 +43,15 @@ export declare const ToolbarSelect: import('react').ForwardRefExoticComponent<Om
     children?: never;
     icon?: import('../../..').IconProps["svg"];
 } & import('react').RefAttributes<HTMLButtonElement>, "ref">, "onChange" | "appearance"> & {
-    /**
-     * Visual appearance of the select button
-     * @default ghost
-     */
+    /** Visual emphasis within the toolbar. Defaults to `ghost`. */
     appearance?: ToolbarItemAppearance;
-    /**
-     * Callback function when selection changes
-     */
+    /** Called with the selected item's ID. */
     onChange?: (optionId: string) => void;
-    /**
-     * Currently selected item ID (controlled mode)
-     */
+    /** Controlled selected ID. Omit to select and manage the first item internally. */
     selected?: string;
-    /**
-     * Array of selectable items
-     */
+    /** Options displayed in the listbox; the first is the uncontrolled default. */
     items: ToolbarSelectItem<Record<string, unknown>>[];
-    /**
-     * Accessible label for the select dropdown dialog (e.g. "Status options").
-     */
+    /** Accessible name for the options popover, such as "Status options". */
     accessibleLabel: string;
 } & DataTrackingId & import('react').RefAttributes<HTMLButtonElement>>;
 export {};

package/dist/src/beta/components/Toolbar/internal/ToolbarContext.d.ts

@@ -1,45 +1,13 @@
 import { RefObject } from 'react';
 import { ToolbarItemProps, ToolbarOverflowTypes, ToolbarSize } from '../types';
-/**
- * Context for sharing toolbar state with child components
- */
 export type ToolbarContextProps = {
-    /**
-     * Array of toolbar items that should appear in the overflow menu
-     */
     overflowItems: ToolbarItemProps[];
-    /**
-     * Function to add an item to the overflow menu
-     */
     addItem: (element: ToolbarItemProps) => void;
-    /**
-     * Function to remove an item from the overflow menu
-     */
     removeItem: (element: ToolbarItemProps) => void;
-    /**
-     * Reference to the toolbar container element
-     */
     toolbarRef: RefObject<HTMLDivElement>;
-    /**
-     * Array of item IDs in their original order
-     */
     orderedIds?: string[];
-    /**
-     * Overflow behavior type. Defaults to wrap behavior when omitted.
-     * @default "wrap"
-     */
     overflow?: ToolbarOverflowTypes;
-    /**
-     * Size of toolbar child components
-     */
     size: ToolbarSize;
 };
-/**
- * Context for managing toolbar state including overflow and size
- */
 export declare const ToolbarContext: import('react').Context<ToolbarContextProps>;
-/**
- * Hook to access the toolbar size from context
- * @returns The current toolbar size
- */
 export declare const useToolbarSize: () => ToolbarSize;

package/dist/src/beta/components/Toolbar/internal/ToolbarItemOverflowContext.d.ts

@@ -1,19 +1,6 @@
-/**
- * Context for denoting if the current item is rendered in the overflow menu
- */
 type OverflowItemContextType = {
-    /**
-     * Whether the current item is rendered inside the overflow menu
-     */
     isInOverflowMenu: boolean;
 };
-/**
- * Context for managing overflow menu state
- */
 export declare const OverflowItemContext: import('react').Context<OverflowItemContextType>;
-/**
- * Hook for accessing overflow menu context
- * @returns OverflowItemContextType - The overflow menu context
- */
 export declare const useOverFlowItemContext: () => OverflowItemContextType;
 export {};

package/dist/src/beta/components/Toolbar/internal/ToolbarItemWrapper.d.ts

@@ -1,40 +1,14 @@
 import { ToolbarItemProps } from '../types';
-/**
- * Props for the ToolbarItemWrapper component
- */
 export type ToolbarItemWrapperProps = {
-    /**
-     * Toolbar item configuration without ID (ID is generated internally)
-     */
     item: Omit<ToolbarItemProps, "id">;
-    /**
-     * The toolbar item component to wrap
-     */
     children: React.ReactNode;
-    /** Optional override for the intersection observer root element */
     observerRoot?: Element | null;
-    /** Optional override for visibility change handling */
     onVisibilityChange?: (isVisible: boolean) => void;
-    /** Optional margin offset for the intersection observer root */
     rootMargin?: string;
-    /** Optional class name to apply to the wrapper element */
     className?: string;
 };
 /**
- * ToolbarItemWrapper manages item visibility and focus behavior within a toolbar.
- *
- * Features:
- * - Intersection observation for overflow detection
- * - Automatic overflow menu integration in collapse mode
- * - Focus management and keyboard navigation
- * - ARIA compliance for accessibility
- * - Visibility state management
- * - Proper tab index handling
- * - Context integration with toolbar state
- *
- * @example
- * <ToolbarItemWrapper item={{ itemType: "button", itemProps: buttonProps }}>
- *   <ToolbarButton {...buttonProps} />
- * </ToolbarItemWrapper>
+ * Registers controls that no longer fit for collapse overflow and keeps the active
+ * control in the toolbar's roving-tabindex pool.
  */
 export declare const ToolbarItemWrapper: ({ item, children, observerRoot, onVisibilityChange, rootMargin, className, }: ToolbarItemWrapperProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Toolbar/internal/ToolbarOverflowMenu.d.ts

@@ -1,29 +1,12 @@
 import { ReactElement } from 'react';
-/**
- * Props for the ToolbarOverflowMenu component
- */
 export type ToolbarOverflowMenuProps = {
-    /**
-     * Additional items to display in the overflow menu
-     */
+    /** Items appended after controls collapsed from the toolbar. */
     additionalItems?: ReactElement[];
-    /**
-     * Direction of the parent toolbar
-     * @default horizontal
-     */
+    /** Parent orientation used to choose the overflow icon. */
     direction?: "vertical" | "horizontal";
 };
 /**
- * ToolbarOverflowMenu component displays toolbar items that don't fit in the main toolbar.
- *
- * Features:
- * - Automatic rendering when items overflow in collapse mode
- * - Maintains consistent item ordering with the main toolbar
- * - Preserves item state between toolbar and overflow menu
- * - Provides accessible navigation with keyboard and screen readers
- * - Adapts to both horizontal and vertical toolbar layouts
- * - Context-aware rendering for child components
- * - Proper ARIA menu semantics
- * - Keyboard navigation support
+ * Recreates clipped controls in their original order, followed by any
+ * consumer-supplied overflow items.
  */
 export declare const ToolbarOverflowMenu: ({ additionalItems, direction, }: ToolbarOverflowMenuProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Toolbar/internal/utils/accessibility.d.ts

@@ -1,26 +1,18 @@
 import { KeyboardEvent } from 'react';
 /**
- * Gets all visible focusable elements for a specific toolbar instance.
- * Filters out hidden items and includes the overflow trigger if present.
+ * Returns the toolbar's visible roving-focus controls, followed by its overflow
+ * trigger when present.
  */
 export declare function getToolbarElements(toolbarElement: HTMLElement): Element[];
 /**
- * Updates tabindex values for all items in a toolbar.
- * Sets tabindex="0" for the active item and tabindex="-1" for all others.
+ * Applies roving tabindex and returns the active control, defaulting to the
+ * first visible control.
  */
 export declare function updateToolbarItemsTabIndex(toolbarElement: HTMLElement, activeItem?: Element | number): Element | undefined;
 /**
- * Handles keyboard navigation within the toolbar component following ARIA practices.
- *
- * Navigation behavior:
- * - Left/Right arrows move focus in horizontal toolbars
- * - Up/Down arrows move focus in vertical toolbars
- * - Home/End move to first/last items
- * - Navigation wraps around at the ends
- * - Only visible items are included in navigation
+ * Moves focus along the toolbar's orientation with wrapping arrow-key
+ * navigation and Home/End shortcuts.
  */
 export declare function handleToolbarKeyDown(event: KeyboardEvent<HTMLElement>, toolbarElement: HTMLElement): void;
-/**
- * Handles keyboard navigation within overflow menu using arrow keys
- */
+/** Moves overflow-menu focus with wrapping vertical arrows and Home/End. */
 export declare const handleMenuKeyboardNavigation: (event: KeyboardEvent<HTMLUListElement>) => void;

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

@@ -4,42 +4,23 @@ import { ToolbarButtonProps } from './ToolbarButton';
 import { ToolbarButtonLinkProps } from './ToolbarButtonLink';
 import { ToolbarButtonToggleProps } from './ToolbarButtonToggle';
 import { ToolbarSelectProps } from './ToolbarSelect';
-/**
- * Toolbar size options
- */
+/** Sizes supported by every toolbar control. */
 export type ToolbarSize = Extract<Size, "xsmall" | "small" | "medium" | "large">;
-/**
- * Toolbar overflow options
- */
+/** `wrap` keeps controls inline; `collapse` moves clipped controls into a menu. */
 export type ToolbarOverflowTypes = "wrap" | "collapse";
-/**
- * Toolbar item appearance options
- */
+/** Appearances available to toolbar actions and selects. */
 export type ToolbarItemAppearance = Extract<ButtonAppearance, "ghost" | "primary">;
-/**
- * Types of toolbar item
- */
+/** Discriminates controls recreated in the overflow menu. */
 export type ToolbarItemTypes = "button" | "buttonToggle" | "buttonLink" | "select";
-/**
- * Props for item in the toolbar overflow menu
- */
+/** Props accepted by controls that can move into the overflow menu. */
 export type CombinedToolbarItemProps = ToolbarButtonProps | ToolbarButtonToggleProps | ToolbarButtonLinkProps | ToolbarSelectProps;
-/**
- * Props for a toolbar item
- */
+/** Stored control descriptor used to recreate a clipped item in the overflow menu. */
 export type ToolbarItemProps = {
     itemType: ToolbarItemTypes;
     itemProps: CombinedToolbarItemProps;
     id?: string;
 };
-/**
- * TODO:
- * This should actually be on the Button component itself to enforce the accessibility rules.
- * This could be a breaking change though, so we should consider moving this to the Button component in the future.
- *
- * Generic type that adds accessibility requirements to any base props type.
- * This enforces proper accessibility for both buttons and toggles.
- */
+/** Requires an icon and accessible name when visible children are omitted. */
 export type WithAriaLabelEnforcement<T> = (T & {
     children?: never;
     icon: IconProps["svg"] | {

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

@@ -1,29 +1,8 @@
 import { TreeSelectFieldHandle, TreeSelectFieldNode, TreeSelectFieldValue } from './types';
 import { DataAttributes } from '../../../types';
 /**
- * TreeSelectField component for selecting one or more nodes from a hierarchical tree structure.
- *
- * Features:
- * - Async tree data loading via loadOptions callback with optional LRU caching
- * - Single-select and multi-select modes
- * - Multi-select chips display with optional singleRow and maxChips limits
- * - Search filtering that preserves tree structure
- * - Cascading parent/child selection (linked mode) or independent node selection
- * - 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, Backspace)
- * - Imperative handle for clearCache, invalidate, expandAll, collapseAll
- * - Accessible label, error, hint, description, and warning helper text
- * - Prefix and suffix slot support
- * - Supports layout utilities for positioning and spacing
- *
- * @example
- * <TreeSelectField
- *   label="Select Categories"
- *   value={selected}
- *   onSelectedOptionsChange={setSelected}
- *   loadOptions={async (search) => fetchCategories(search)}
- * />
+ * Hierarchical select rendered in a popover or dialog.
+ * Multi-select supports search; every mode uses a controlled value array.
  */
 export declare const TreeSelectField: import('react').ForwardRefExoticComponent<{
     id?: string;

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

@@ -2,61 +2,25 @@ import { MatchSorterOptions } from 'match-sorter';
 import { TreeSelectFieldNode, TreeSelectFieldProps } from './types';
 import { TreeSyncFilterFn } from './internal/treeSync';
 export type { TreeSyncFilterFn };
-/**
- * Props for the TreeSelectFieldSync 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 TreeSelectFieldProps
- */
 export type TreeSelectFieldSyncProps = Omit<TreeSelectFieldProps, "loadOptions" | "debounceMs" | "cache" | "initialLoad"> & {
-    /**
-     * The static tree options to display in the field.
-     */
+    /** Complete tree used for selection and client-side search. */
     options: TreeSelectFieldNode[];
     /**
-     * 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
-     * <TreeSelectFieldSync
-     *   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 stage; the field still applies its
+     * loaded-row substring filter.
      *
      * @example
-     * <TreeSelectFieldSync
-     *   options={options}
-     *   filter={{ keys: ["label"] }}
-     * />
+     * filter={(nodes, searchValue) => customTreeFilter(nodes, searchValue)}
+     * // or
+     * filter={{ keys: ["label"] }}
      */
     filter?: TreeSyncFilterFn | MatchSorterOptions<TreeSelectFieldNode>;
 };
 /**
- * TreeSelectFieldSync is a simplified wrapper around TreeSelectField 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 field when the options contents change.
- * - Supports all other props of TreeSelectField.
- *
- * @example
- * <TreeSelectFieldSync
- *   label="Select location"
- *   options={locationTree}
- *   value={selected}
- *   onSelectedOptionsChange={setSelected}
- * />
+ * Static-data variant of {@link TreeSelectField}.
+ * Filters `options` on the client and refreshes the field when they change.
  */
 export declare const TreeSelectFieldSync: {
     (props: TreeSelectFieldSyncProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/TreeSelectField/internal/TreeContent.d.ts

@@ -1,31 +1,15 @@
 import { TreePanelProps } from './TreePanel';
-/**
- * Props for the TreeContent component.
- *
- * @property loading - Whether the tree is currently loading data; renders a spinner while true.
- * @property hasNoVisibleNodes - True when there are no nodes to render (e.g. a search returned no matches); renders an empty-state message.
- * @property virtualize - When true, renders the virtualized panel; otherwise renders the standard panel.
- * @property panelProps - Props forwarded to the underlying TreePanel or VirtualizedTreePanel.
- */
 export type TreeContentProps = {
+    /** Replaces the panel with its loading state. */
     loading: boolean;
+    /** Replaces the panel with its no-match state. */
     hasNoVisibleNodes: boolean;
+    /** Uses windowed rendering for the panel. */
     virtualize?: boolean;
     panelProps: TreePanelProps;
 };
 /**
- * Renders the body of a tree select popover or dialog: a centered spinner
- * while loading, a "No match found" message when there are no visible
- * nodes, or the (optionally virtualized) tree panel.
- *
- * Used by both TreeSelectField and TreeSelectMenu to keep the three
- * states consistent across the field's dialog and popover branches and
- * the menu's render path.
- *
- * Features:
- * - Centered medium Spinner while loading
- * - "No match found" empty state (small, subdued text)
- * - Switches between TreePanel and VirtualizedTreePanel via the `virtualize` flag
- * - Forwards a ref to the underlying tree panel for focus management
+ * Shared loading, empty, and tree-panel body for tree fields and menus.
+ * Forwards its ref only when a panel is mounted.
  */
 export declare const TreeContent: import('react').ForwardRefExoticComponent<TreeContentProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/beta/components/TreeSelectField/internal/TreePanel.d.ts

@@ -1,19 +1,5 @@
 import { TreeSelectFieldNode } from '../types';
 import { VisibleNode } from './types';
-/**
- * Props for the TreePanel component.
- * @property {VisibleNode[]} visibleNodes - Flat list of nodes currently visible in the tree.
- * @property {(id: string | number) => "checked" | "unchecked" | "indeterminate" | "loading"} getCheckState - Returns the check state for a given node id.
- * @property {(id: string | number) => void} toggleNode - Toggles the selection state of a node.
- * @property {(id: string | number) => void} toggleExpand - Toggles the expanded state of a branch node.
- * @property {(id: string | number) => Record<string, unknown>} getTreeItemProps - Returns ARIA/accessibility props for a tree item.
- * @property {Record<string, unknown>} treeProps - Props to spread onto the tree container element.
- * @property {string | undefined} activeDescendantId - The id of the currently active/focused tree item.
- * @property {boolean} [branchesSelectable] - When true, branch nodes can be selected.
- * @property {boolean} [leavesSelectable] - When true, leaf nodes can be selected.
- * @property {boolean} [emptyBranchesSelectable] - When true, empty branches can be selected.
- * @property {(node: TreeSelectFieldNode) => void} [onLoadChildren] - Callback to trigger lazy loading of children.
- */
 export type TreePanelProps = {
     visibleNodes: VisibleNode[];
     getCheckState: (id: string | number) => "checked" | "unchecked" | "indeterminate" | "loading";
@@ -29,28 +15,5 @@ export type TreePanelProps = {
     onHover?: (id: string | number) => void;
     onLoadChildren?: (node: TreeSelectFieldNode) => void;
 };
-/**
- * TreePanel component that renders the tree dropdown content.
- *
- * Features:
- * - Renders a flat list of visible nodes with depth-based indentation
- * - Supports expand/collapse controls for branch nodes
- * - Shows loading indicator for lazily-loaded branches
- * - Checkboxes for multi-select mode (hidden in single-select mode)
- * - Optional breadcrumb display for flattened search results
- * - Optional child count display for branch nodes
- * - Full accessibility support with ARIA tree/treeitem roles
- * - Focusable container via forwardRef
- *
- * @example
- * <TreePanel
- *   visibleNodes={visibleNodes}
- *   getCheckState={getCheckState}
- *   toggleNode={toggleNode}
- *   toggleExpand={toggleExpand}
- *   getTreeItemProps={getTreeItemProps}
- *   treeProps={treeProps}
- *   activeDescendantId={activeDescendantId}
- * />
- */
+/** Renders every visible node in the tree panel. */
 export declare const TreePanel: import('react').ForwardRefExoticComponent<TreePanelProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/beta/components/TreeSelectField/internal/TreeRow.d.ts

@@ -1,26 +1,17 @@
 import { TreeSelectFieldNode } from '../types';
 import { VisibleNode } from './types';
-/**
- * Props for the TreeRow component.
- * @property {VisibleNode} visible - The visible node data including depth, expand state, and branch info.
- * @property {"checked" | "unchecked" | "indeterminate"} checkState - The checkbox state for this row.
- * @property {Record<string, unknown>} itemProps - ARIA/accessibility props from getTreeItemProps.
- * @property {boolean} [branchesSelectable] - When true, branch nodes can be selected. Defaults to true.
- * @property {boolean} [leavesSelectable] - When true, leaf nodes can be selected. Defaults to true.
- * @property {boolean} [emptyBranchesSelectable] - When true, empty branches (children: []) can be selected. Defaults to true.
- * @property {boolean} [isActive] - When true, applies a highlight background for keyboard focus.
- * @property {(id: string | number) => void} onToggleNode - Callback to toggle selection of the node.
- * @property {(id: string | number) => void} onToggleExpand - Callback to toggle expansion of a branch node.
- * @property {(node: TreeSelectFieldNode) => void} [onLoadChildren] - Callback to trigger lazy loading of children.
- * @property {number} depth - Depth of the node in the tree, used to calculate indentation.
- */
 export type TreeRowProps = {
     visible: VisibleNode;
+    /** Includes `"loading"` while a cascading selection awaits lazy descendants. */
     checkState: "checked" | "unchecked" | "indeterminate" | "loading";
     itemProps: Record<string, unknown>;
+    /** Allows branch rows to select instead of only expand. Defaults to `true`. */
     branchesSelectable?: boolean;
+    /** Allows leaf rows to select. Defaults to `true`. */
     leavesSelectable?: boolean;
+    /** Allows branches with no children to select. Defaults to `true`. */
     emptyBranchesSelectable?: boolean;
+    /** Preserves navigation and expansion while preventing selection. */
     readOnly?: boolean;
     isActive?: boolean;
     onToggleNode: (id: string | number) => void;
@@ -29,28 +20,5 @@ export type TreeRowProps = {
     onLoadChildren?: (node: TreeSelectFieldNode) => void;
     depth: number;
 };
-/**
- * TreeRow renders a single row in the tree dropdown.
- *
- * Features:
- * - Depth-based indentation via inline paddingInlineStart
- * - Expand/collapse icon using Icon component with keyboard_arrow_right/down icons
- * - Spinning icon animation for lazy-loading branch nodes
- * - Checkbox in multi-select mode, hidden in single-select mode
- * - Rich content support via node.content (title, description, chips, avatar, icon)
- * - Label text with overflow ellipsis
- * - Disabled state with reduced opacity and default cursor
- * - Active (keyboard focus) state with highlight background
- * - Full ARIA semantics via spread itemProps
- *
- * @example
- * <TreeRow
- *   visible={visibleNode}
- *   checkState={getCheckState(visibleNode.node.id)}
- *   itemProps={getTreeItemProps(visibleNode.node.id)}
- *   onToggleNode={toggleNode}
- *   onToggleExpand={toggleExpand}
- *   depth={visibleNode.depth}
- * />
- */
+/** Renders one indented tree row with selection and branch expansion controls. */
 export declare function TreeRow({ visible, checkState, itemProps, branchesSelectable, leavesSelectable, emptyBranchesSelectable, readOnly, isActive, onToggleNode, onToggleExpand, onHover, onLoadChildren, depth, }: TreeRowProps): import("react/jsx-runtime").JSX.Element;