@skdx/react 0.27.0 → 0.29.0

package/dist/tree-select/types.d.cts

@@ -1,360 +1,395 @@
 import type * as React from 'react';
 import type { TreeCheckedState } from '../tree/types.cjs';
+import type { PassThroughProps } from '../utils/passThrough.cjs';
 import type { PopperContentProps } from '../utils/popper.cjs';
 import type { PortalProps } from '../utils/portal.cjs';
 import type { PrimitivePropsWithRef } from '../utils/primitive.cjs';
 import type { InteractOutsideEvent } from '../utils/useDismiss.cjs';
 import type { TreeSelectFlatNode, TreeSelectIndex } from './collection.cjs';
 /**
- * One node of a {@link TreeSelect}'s `collection`. Plain data, not elements:
- * cascading check state, `valueStrategy` projection, and filtering all need to
- * see branches that are collapsed (and therefore unmounted), which a
- * children-based tree cannot offer.
+ * One node of a TreeSelect's collection — plain data, not elements, needed
+ * for cascading state, filtering, and projection across collapsed branches.
  */
 export interface TreeSelectNode {
-    /** Unique identifier across the whole collection — what lands in `value`, and what every callback names. */
+    /** Unique identifier across the whole collection; what lands in value and callback names. */
     value: string;
     /**
-     * Human-readable text: rendered as the node's content, matched by `filter`, and shown by `TreeSelectValue`.
+     * Human-readable text rendered as node content, matched by filter, shown by TreeSelectValue.
      * @default undefined — falls back to `value`.
      */
-    label?: string;
+    label?: string | undefined;
     /**
-     * Excludes this node from checking, cascade propagation, keyboard
-     * navigation, and its parent's checked-ness calculation. Inherited by the
-     * whole subtree — a disabled branch cannot be toggled through its children.
+     * Excludes node from checking, cascade, navigation, and parent calculations;
+     * inherited by the whole subtree.
      * @default false
      */
-    disabled?: boolean;
+    disabled?: boolean | undefined;
     /**
-     * Child nodes. A node with an empty (or absent) `children` is a leaf: it is
-     * not expandable and reports no `aria-expanded`.
+     * Child nodes. Empty or absent children makes this a leaf (not expandable).
      * @default undefined — a leaf.
      */
-    children?: TreeSelectNode[];
+    children?: TreeSelectNode[] | undefined;
+    /**
+     * Marks an unloaded branch as expandable before children arrive, giving
+     * loadChildren something to run on; ignored once the node has children.
+     * @default undefined — branch-ness decided by children alone.
+     */
+    hasChildren?: boolean | undefined;
 }
-/**
- * Whether checking a node propagates through its subtree. `'cascade'` makes
- * the tree a tri-state checkbox tree: checking a parent checks every enabled
- * descendant, and a partially-checked parent reports `aria-checked="mixed"`.
- * `'independent'` disables propagation entirely — each node stands alone.
- *
- * Only meaningful while `multiple` is set; a single-select tree has one
- * checked node by definition and never cascades.
- */
-export type TreeSelectCheckStrategy = 'cascade' | 'independent';
-/**
- * Which of the checked nodes are actually emitted in `value`.
- *
- * - `'all'` — every checked node, parents and descendants alike.
- * - `'leaf'` — only checked leaves; branches are dropped.
- * - `'shallowest'` — only the topmost fully-checked node of each branch,
- *   collapsing a fully-checked subtree to the single node that implies it.
- *
- * Ignored (treated as `'all'`) under `checkStrategy="independent"`, where no
- * node implies any other and dropping one would silently lose a selection.
- */
+/** Propagation direction when checking a node — both ways, down only, up only, or none — meaningful only when multiple is set. */
+export type TreeSelectCheckStrategy = 'cascade' | 'descendants' | 'ancestors' | 'independent';
+/** Which checked nodes appear in value — all, leaves only, or the shallowest node of each fully-checked subtree — ignored where projection cannot be undone. */
 export type TreeSelectValueStrategy = 'all' | 'leaf' | 'shallowest';
 /** Predicate deciding whether a node matches the current filter text. */
 export type TreeSelectFilter = (node: TreeSelectNode, inputValue: string) => boolean;
-/** @internal Shared state distributed from {@link TreeSelect} to its parts via context. Not part of the public API. */
+/** How the popup draws the hierarchy — one indented tree, or one tree per open level side by side. */
+export type TreeSelectLayout = 'tree' | 'columns';
+/** @internal One showing column: the branch it belongs to plus the rows TreeSelectTree renders for it. */
+export interface TreeSelectColumnView {
+    /** The branch whose children this column lists, or `null` for the root column. */
+    parent: string | null;
+    rows: readonly {
+        value: string;
+        depth: number;
+    }[];
+}
+/** @internal Shared state distributed from TreeSelect to its parts via context. */
 export interface TreeSelectContextValue {
     collection: readonly TreeSelectNode[];
     index: TreeSelectIndex;
     /** Every node value in collection pre-order. */
     order: readonly string[];
-    /** The emitted value: the checked set projected through `valueStrategy`. */
+    /** The checked set projected through valueStrategy. */
     value: readonly string[];
     multiple: boolean;
-    /** Whether checking actually propagates: `checkStrategy === 'cascade'` *and* `multiple`. */
+    /** Whether checking propagates: checkStrategy is not independent and multiple is set. */
     cascade: boolean;
     disabled: boolean;
     readOnly: boolean;
-    /** A node's tri-state value, derived from its enabled leaf descendants under `cascade`. */
+    /** Node's tri-state value derived from enabled leaf descendants. */
     checkStateOf: (value: string) => TreeCheckedState;
-    /** Toggles a node (respecting `checkStrategy`), emits the projected value, and closes when `closeOnSelect`. */
+    /** Toggle node, emit projected value, close if closeOnSelect is set. */
     commit: (value: string) => void;
     open: boolean;
     onOpenChange: (open: boolean) => void;
-    /** Effective expanded ids — the caller's expansion plus, while filtering, the ancestors of every match. */
+    /** Caller's expansion plus, while filtering, ancestors of every match. */
     expandedIds: string[];
     expanded: ReadonlySet<string>;
     setExpanded: (value: string, expand: boolean) => void;
-    /** Adapter turning the composed `Tree`'s whole-array expansion callback back into a single-node change. */
+    /** Node values whose loadChildren call is still pending. */
+    loadingValues: ReadonlySet<string>;
+    /** Adapter for Tree's array expansion callback to single-node change. */
     onTreeExpandedIdsChange: (ids: string[]) => void;
-    /** Values whose check state is fully `true`, handed to the composed `Tree` as its `selectedIds`. */
-    selectedIds: string[];
-    /** Whether a node survives the current filter (always `true` when not filtering). */
+    /** Whether clicking a branch row toggles its expansion as well as checking. */
+    expandOnClick: boolean;
+    /** Whether a node survives the current filter (always true when not filtering). */
     isVisible: (value: string) => boolean;
+    /** The layout actually drawn: `'tree'` while a filter narrows a `'columns'` popup. */
+    layout: TreeSelectLayout;
+    /** The showing columns left to right; empty unless the effective layout is `'columns'`. */
+    columns: readonly TreeSelectColumnView[];
+    /** DOM id of a column's tree; column 0 keeps `treeId` so the tree layout is unaffected. */
+    columnTreeId: (columnIndex: number) => string;
+    /** DOM id of the tree holding the active node, which `aria-controls` must name. */
+    activeTreeId: string;
     /** Visible, expanded nodes in navigation order. */
     flat: readonly TreeSelectFlatNode[];
     flatMap: ReadonlyMap<string, TreeSelectFlatNode>;
     activeValue: string | null;
     setActiveValue: (value: string | null) => void;
-    /** DOM id of a node's `treeitem`, for `aria-activedescendant`. */
+    /** DOM id of a node's treeitem for aria-activedescendant. */
     itemId: (value: string) => string;
     treeId: string;
-    contentId: string;
     triggerRef: React.RefObject<HTMLButtonElement | null>;
     contentRef: React.RefObject<HTMLDivElement | null>;
     inputRef: React.RefObject<HTMLInputElement | null>;
-    /** Whether a `TreeSelectInput` is mounted — it takes DOM focus, and with it `aria-activedescendant`, off the trigger. */
+    /** Whether TreeSelectInput is mounted; it takes focus and aria-activedescendant from trigger. */
     hasInput: boolean;
     setHasInput: (hasInput: boolean) => void;
     inputValue: string;
     onInputValueChange: (value: string) => void;
-    /** A node's `label`, or its `value` when it has none. */
+    /** Node's label or its value when label is absent. */
     getLabel: (value: string) => string;
-    /** The shared keydown handler both `TreeSelectTrigger` and `TreeSelectInput` delegate to. */
+    /** Shared keydown handler that both TreeSelectTrigger and TreeSelectInput delegate to. */
     onNavigationKeyDown: (event: React.KeyboardEvent<HTMLElement>, options: {
         typeahead: boolean;
         selectOnSpace: boolean;
     }) => void;
+    /** Node values `TreeSelectTree` actually renders when `rows` windows the collection, or `null` when unrestricted; navigation draws from this set. */
+    visibleRowValues: ReadonlySet<string> | null;
+    /** Reported by TreeSelectTree whenever its `rows` prop changes. */
+    setVisibleRowValues: (values: ReadonlySet<string> | null) => void;
 }
-/** @internal Per-node state distributed from {@link TreeSelectItem} to `TreeSelectItemIndicator` via context. Not part of the public API. */
+/** @internal Per-node state distributed from TreeSelectItem to TreeSelectItemIndicator via context. */
 export interface TreeSelectItemContextValue {
     value: string;
     checkState: TreeCheckedState;
     disabled: boolean;
     expanded: boolean;
     hasChildren: boolean;
-    /** Whether this node is the virtually-focused one named by `aria-activedescendant`. */
+    /** Whether this node is the virtually-focused one named by aria-activedescendant. */
     active: boolean;
 }
-/** Props for the {@link TreeSelect} root. */
-export interface TreeSelectProps {
+/** Props for the TreeSelect root; standard attributes land on the derived TreeSelectTrigger, since TreeSelect itself renders no DOM. */
+export interface TreeSelectProps extends PassThroughProps {
     /**
-     * The `TreeSelectTrigger`/`TreeSelectPortal` parts, rendered as children — `TreeSelect` itself renders no DOM.
+     * The TreeSelectTrigger/TreeSelectPortal parts, rendered as children.
      * @default undefined — renders nothing without children.
      */
-    children?: React.ReactNode;
+    children?: React.ReactNode | undefined;
     /**
-     * The hierarchical data the popup's tree is built from. Node `value`s must be
-     * unique across the whole collection — every callback, `value` entry and DOM
-     * id is keyed by them.
+     * Hierarchical data the tree is built from; node values must be unique across the whole collection.
      */
     collection: readonly TreeSelectNode[];
     /**
-     * Checked node values, for controlled usage — always an array, whether or not
-     * `multiple`, and always in the shape `valueStrategy` describes. Pair with
-     * `onValueChange`.
-     * @default undefined — uncontrolled, tracks its own checked set internally.
+     * Controlled checked node values, always in the shape valueStrategy describes. Pair with onValueChange.
+     * @default undefined — uncontrolled.
      */
-    value?: string[];
+    value?: string[] | undefined;
     /**
-     * Initially checked node values, for uncontrolled usage. Same shape as `value`.
+     * Initially checked node values for uncontrolled usage.
      * @default [] — nothing checked.
      */
-    defaultValue?: string[];
+    defaultValue?: string[] | undefined;
     /**
-     * Fires with the whole new value whenever the checked set changes, controlled
-     * or not — projected through `valueStrategy`, not the node that was toggled.
+     * Fires with the new value whenever the checked set changes, projected through valueStrategy.
      * @default undefined — no-op if omitted.
      */
-    onValueChange?: (value: string[]) => void;
+    onValueChange?: ((value: string[]) => void) | undefined;
     /**
-     * Allows more than one node to be checked: the tree gets
-     * `aria-multiselectable`, activating a node toggles it rather than replacing
-     * the selection, and `checkStrategy` starts to mean something.
+     * Allows more than one node to be checked; tree gets aria-multiselectable and checkStrategy becomes meaningful.
      * @default false
      */
-    multiple?: boolean;
+    multiple?: boolean | undefined;
     /**
-     * Whether checking a node propagates through its subtree — see
-     * {@link TreeSelectCheckStrategy}. Ignored unless `multiple`.
-     * @default 'cascade' — checking a parent checks its whole enabled subtree, and a partially-checked parent reports `aria-checked="mixed"`.
+     * Whether and in which direction checking propagates; see TreeSelectCheckStrategy. Ignored unless multiple.
+     * @default 'cascade'
      */
-    checkStrategy?: TreeSelectCheckStrategy;
+    checkStrategy?: TreeSelectCheckStrategy | undefined;
     /**
-     * Which checked nodes appear in the emitted `value` — see
-     * {@link TreeSelectValueStrategy}. Ignored under
-     * `checkStrategy="independent"`.
-     * @default 'all' — every checked node, which is the most faithful round-trip but the most verbose payload; `'shallowest'` is usually what an API wants.
+     * Which checked nodes appear in the emitted value; see TreeSelectValueStrategy. Ignored where checkStrategy lacks the direction to rebuild.
+     * @default 'all'
      */
-    valueStrategy?: TreeSelectValueStrategy;
+    valueStrategy?: TreeSelectValueStrategy | undefined;
     /**
-     * Expanded node values, for controlled usage. Pair with `onExpandedChange`.
-     * While filtering, the ancestors of every match are expanded *on top of* this
-     * value without being written back to it.
-     * @default undefined — uncontrolled, tracks its own expanded set internally.
+     * Controlled expanded node ids, paired with onExpandedChange; while filtering, ancestors of every match are expanded on top of this value.
+     * @default undefined — uncontrolled.
      */
-    expandedValue?: string[];
+    expanded?: string[] | undefined;
     /**
-     * Initially expanded node values, for uncontrolled usage.
+     * Initially expanded node values for uncontrolled usage.
      * @default [] — every branch collapsed.
      */
-    defaultExpandedValue?: string[];
+    defaultExpanded?: string[] | undefined;
     /**
-     * Fires with the new expanded set whenever a branch is expanded or collapsed,
-     * controlled or not. Never fires for the transient expansion filtering adds.
+     * Fires with the new expanded set whenever a branch expands or collapses, never for filter-driven expansion.
      * @default undefined — no-op if omitted.
      */
-    onExpandedChange?: (expandedValue: string[]) => void;
+    onExpandedChange?: ((expanded: string[]) => void) | undefined;
     /**
-     * Whether the popup is open, for controlled usage. Pair with `onOpenChange`.
+     * Whether the popup is open for controlled usage. Pair with onOpenChange.
      * @default undefined — uncontrolled, tracks its own open state internally.
      */
-    open?: boolean;
+    open?: boolean | undefined;
     /**
-     * Initial open state, for uncontrolled usage.
+     * Initial open state for uncontrolled usage.
      * @default false
      */
-    defaultOpen?: boolean;
+    defaultOpen?: boolean | undefined;
     /**
      * Fires with the new open state whenever it changes, controlled or not.
      * @default undefined — no-op if omitted.
      */
-    onOpenChange?: (open: boolean) => void;
+    onOpenChange?: ((open: boolean) => void) | undefined;
     /**
-     * Fires with the new open state once the change has finished on screen —
-     * after `TreeSelectContent`'s enter or exit animation ends, or as soon as it
-     * has settled when the popup declares no animation. Use it for work that must
-     * not race the transition; use `onOpenChange` for work that must not wait for it.
+     * Fires once the open state change finishes on screen, after animation ends or immediately if none.
      * @default undefined — no-op if omitted.
      */
-    onOpenChangeComplete?: (open: boolean) => void;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
     /**
-     * The `TreeSelectInput`'s filter text, for controlled usage. Pair with `onInputValueChange`.
+     * The TreeSelectInput's filter text for controlled usage. Pair with onInputValueChange.
      * @default undefined — uncontrolled, tracks its own filter text internally.
      */
-    inputValue?: string;
+    inputValue?: string | undefined;
     /**
-     * Initial filter text, for uncontrolled usage.
+     * Initial filter text for uncontrolled usage.
      * @default '' — unfiltered.
      */
-    defaultInputValue?: string;
+    defaultInputValue?: string | undefined;
     /**
      * Fires with the new filter text as the user types, controlled or not.
      * @default undefined — no-op if omitted.
      */
-    onInputValueChange?: (inputValue: string) => void;
+    onInputValueChange?: ((inputValue: string) => void) | undefined;
+    /**
+     * Decides whether a node matches the filter; matches keep their ancestor chain and subtree visible.
+     * @default defaultTreeSelectFilter
+     */
+    filter?: TreeSelectFilter | undefined;
     /**
-     * Decides whether a node matches the filter text. A match keeps its whole
-     * ancestor chain visible (a matched leaf under a hidden parent would be
-     * unreachable) and its whole subtree visible.
-     * @default defaultTreeSelectFilter — case-insensitive substring match on `label ?? value`.
+     * Blocks the whole control; trigger is disabled and no key changes anything.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Form field name; each selected node value submits separately under this name.
+     * @default undefined — submits nothing.
+     */
+    name?: string | undefined;
+    /**
+     * Id of the form the submitted entries belong to, for a TreeSelect not a DOM descendant of it.
+     * @default undefined — entries belong to the nearest ancestor form.
      */
-    filter?: TreeSelectFilter;
+    form?: string | undefined;
     /**
-     * Blocks the whole control: the trigger is a disabled `<button>`, the popup
-     * cannot open, and no key changes anything.
+     * Lets the user open and navigate the tree without changing the value, unlike disabled which also removes from the tab order.
      * @default false
      */
-    disabled?: boolean;
+    readOnly?: boolean | undefined;
+    /**
+     * Closes the popup as soon as a node is checked, returning focus to trigger.
+     * @default !multiple
+     */
+    closeOnSelect?: boolean | undefined;
+    /**
+     * Loads a node's children the first time it expands, for non-materialized collection. Mark branches with hasChildren; does not run while filtering.
+     * @default undefined — collection is complete as given.
+     */
+    loadChildren?: ((nodeValue: string) => void | Promise<void>) | undefined;
     /**
-     * Lets the user open, navigate and read the tree but never change the value —
-     * unlike `disabled`, which also removes it from the tab order.
+     * Formats the announced message each time filter matches change while the popup is open.
+     * @default defaultGetMatchCountLabel
+     */
+    getMatchCountLabel?: ((count: number) => string) | undefined;
+    /**
+     * Supplies the label for a value whose node is not in collection, consulted by TreeSelectValue before the raw-value fallback.
+     * @default undefined — unknown value renders as itself.
+     */
+    getValueLabel?: ((value: string) => string) | undefined;
+    /**
+     * Whether clicking a branch row toggles its expansion as well as checking it; ArrowRight/ArrowLeft are unaffected either way. Ignored (treated as true) under `layout="columns"`, where the row is the only thing that opens a column.
      * @default false
      */
-    readOnly?: boolean;
+    expandOnClick?: boolean | undefined;
+    /**
+     * How the popup presents the hierarchy: one indented tree, or one tree per open level side by side. A non-empty filter draws `'columns'` as a tree.
+     * @default 'tree'
+     */
+    layout?: TreeSelectLayout | undefined;
+    /**
+     * Renders a node's content when deriving anatomy, forwarded to TreeSelectTree; ignored under full manual composition.
+     * @default undefined — renders each node's label ?? value as plain text.
+     */
+    renderNode?: ((node: TreeSelectNode) => React.ReactNode) | undefined;
+    /**
+     * Placeholder for the derived trigger while nothing is checked, read only while deriving anatomy.
+     * @default undefined
+     */
+    placeholder?: string | undefined;
+    /**
+     * Empty-state message shown when no node matches the filter; only read while deriving anatomy.
+     * @default 'No matches'
+     */
+    emptyMessage?: string | undefined;
     /**
-     * Closes the popup as soon as a node is checked, returning focus to the trigger.
-     * @default !multiple — a single-select answer is complete on the first pick; a multi-select one is not.
+     * Accessible name for derived components; only read while deriving anatomy. Falls back to placeholder.
+     * @default undefined — if neither is set, no attribute is emitted.
      */
-    closeOnSelect?: boolean;
+    'aria-label'?: string | undefined;
     /**
-     * Formats the message announced (through the shared `LiveAnnouncer`) each
-     * time the number of filter matches changes while the popup is open —
-     * filtering is silent for screen-reader users otherwise. Return an empty
-     * string to announce nothing.
-     * @default defaultGetMatchCountLabel — e.g. `"3 matches available"`
+     * Size rung the skin scales the panel by, fed to the derived Content.
+     * @default undefined — the skin's own default size.
      */
-    getMatchCountLabel?: (count: number) => string;
+    size?: 'sm' | 'lg' | (string & {}) | undefined;
 }
 /** Props for {@link TreeSelectTrigger}, the `role="combobox"` button that opens the popup. */
 export interface TreeSelectTriggerProps extends PrimitivePropsWithRef<'button'> {
 }
-/** Props for {@link TreeSelectValue}, the trigger's read-out of the current selection. */
+/** Props for TreeSelectValue, the trigger's read-out of the current selection. */
 export interface TreeSelectValueProps extends PrimitivePropsWithRef<'span'> {
     /**
-     * Stand-in content rendered while nothing at all is checked.
-     * @default undefined — renders nothing when empty.
+     * Stand-in content rendered while nothing is checked.
+     * @default undefined
      */
-    placeholder?: React.ReactNode;
+    placeholder?: React.ReactNode | undefined;
 }
-/** Props for {@link TreeSelectPortal}, which teleports the popup to `document.body` while open. */
+/** Props for TreeSelectPortal, which teleports the popup to document.body while open. */
 export interface TreeSelectPortalProps extends PortalProps {
     /**
-     * Render (and mount `TreeSelectContent`) even while closed, instead of
-     * unmounting. Useful for animation libraries that need the outgoing content
-     * present in the DOM during an exit transition.
+     * Renders and mounts TreeSelectContent even while closed, for animation libraries needing the outgoing content during exit.
      * @default false
      */
-    forceMount?: boolean;
+    forceMount?: boolean | undefined;
 }
-/**
- * Props for {@link TreeSelectContent}, the popup panel. Extends
- * {@link PopperContentProps} (`side`, `align`, `sideOffset`, `alignOffset`,
- * `avoidCollisions`, `collisionPadding`) for floating-ui positioning relative
- * to the trigger — note `TreeSelectContent` defaults `side` to `'bottom'`,
- * `align` to `'start'`, and `sideOffset` to `4`, instead of the popper base
- * defaults (`'bottom'` / `'center'` / `0`).
- */
+/** Props for TreeSelectContent, the popup panel; extends PopperContentProps (side, align, sideOffset, alignOffset, avoidCollisions, collisionPadding). */
 export interface TreeSelectContentProps extends PopperContentProps {
     /**
-     * Keep this popup mounted even while closed, instead of unmounting it.
+     * Mounts this popup even while closed, instead of unmounting it.
      * @default false
      */
-    forceMount?: boolean;
+    forceMount?: boolean | undefined;
     /**
-     * Fires on Escape while the popup is open, before it closes. Call
-     * `event.preventDefault()` to keep it open.
+     * Fires on Escape while the popup is open, before it closes; call preventDefault() to keep it open.
      * @default undefined — no-op if omitted.
      */
-    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => void) | undefined;
     /**
-     * Fires on a pointer-down outside the popup and trigger. `preventDefault()` keeps it open.
+     * Fires on a pointer-down outside the popup and trigger; call preventDefault() to keep it open.
      * @default undefined — no-op if omitted.
      */
-    onPointerDownOutside?: (event: PointerEvent) => void;
+    onPointerDownOutside?: ((event: PointerEvent) => void) | undefined;
     /**
-     * Fires when focus moves outside the popup and trigger, carrying a
-     * cancelable stand-in for the uncancelable `focusin`. `preventDefault()`
-     * keeps it open.
+     * Fires when focus moves outside the popup and trigger; call preventDefault() to keep open.
      * @default undefined — no-op if omitted.
      */
-    onFocusOutside?: (event: CustomEvent<FocusEvent>) => void;
+    onFocusOutside?: ((event: CustomEvent<FocusEvent>) => void) | undefined;
     /**
-     * Fires for *either* kind of outside interaction, immediately before the
-     * specific handler and with the same event — so one `preventDefault()`
-     * vetoes both paths.
+     * Fires for either kind of outside interaction, before the specific handler with the same event.
      * @default undefined — no-op if omitted.
      */
-    onInteractOutside?: (event: InteractOutsideEvent) => void;
+    onInteractOutside?: ((event: InteractOutsideEvent) => void) | undefined;
+    /**
+     * Size rung the skin scales the panel by, mirrored to `data-size`.
+     * @default undefined — the skin's own default size.
+     */
+    size?: 'sm' | 'lg' | (string & {}) | undefined;
 }
-/** Props for {@link TreeSelectTree}, the `role="tree"` inside the popup. */
-export interface TreeSelectTreeProps extends Omit<PrimitivePropsWithRef<'div'>, 'children' | 'defaultValue'> {
+/** Props for TreeSelectTree, the role="tree" inside the popup. */
+export interface TreeSelectTreeProps extends Omit<PrimitivePropsWithRef<'div'>, 'children' | 'defaultValue' | 'ref'> {
+    /**
+     * Renders a node's content (label, indicators); returned nodes render inside the node's treeitem.
+     * @default undefined — renders the node's label ?? value as plain text.
+     */
+    renderLabel?: ((node: TreeSelectNode) => React.ReactNode) | undefined;
     /**
-     * Renders a node's content — the label, and anything beside it such as a
-     * `TreeItemIndicator` chevron or a `TreeSelectItemIndicator` checkmark. The
-     * returned nodes render *inside* the node's `treeitem`, so both indicators
-     * find their context there.
-     * @default undefined — renders the node's `label ?? value` as plain text.
+     * Renders exactly this row set instead of the whole collection; rows render flat as { value, depth } pairs with row.depth supplying aria-level.
+     * @default undefined — renders every visible node from collection, nested.
      */
-    renderLabel?: (node: TreeSelectNode) => React.ReactNode;
+    rows?: readonly Pick<TreeSelectFlatNode, 'value' | 'depth'>[] | undefined;
 }
-/** Props for a single {@link TreeSelectItem} node. Normally rendered for you by `TreeSelectTree`. */
+/** Props for TreeSelectColumns, the `role="presentation"` track holding one tree per open level. */
+export type TreeSelectColumnsProps = Omit<PrimitivePropsWithRef<'div'>, 'defaultValue'>;
+/** Props for a single TreeSelectItem node. Normally rendered by TreeSelectTree. */
 export interface TreeSelectItemProps extends Omit<PrimitivePropsWithRef<'div'>, 'children'> {
     /** The collection node this row stands for. */
     node: TreeSelectNode;
     /**
      * The row's content — the label, plus any indicators.
-     * @default undefined — renders an empty row.
+     * @default undefined
      */
-    children?: React.ReactNode;
+    children?: React.ReactNode | undefined;
 }
-/** Props for {@link TreeSelectItemIndicator}, the checkmark shown on a checked (or partially checked) node. */
+/** Props for TreeSelectItemIndicator, the checkmark shown on checked or partially-checked nodes. */
 export interface TreeSelectItemIndicatorProps extends PrimitivePropsWithRef<'span'> {
     /**
-     * Render even while the node is unchecked, instead of returning `null` —
-     * for animating the check in and out, or for reserving its space.
+     * Renders even while the node is unchecked, for animating the check or reserving its space.
      * @default false
      */
-    forceMount?: boolean;
+    forceMount?: boolean | undefined;
 }
-/** Props for {@link TreeSelectEmpty}, shown in place of the tree when the filter matches nothing. */
+/** Props for TreeSelectEmpty, shown in place of the tree when the filter matches nothing. */
 export interface TreeSelectEmptyProps extends PrimitivePropsWithRef<'div'> {
 }
-/** Props for {@link TreeSelectInput}, the optional filter text field inside the popup. */
+/** Props for TreeSelectInput, the optional filter text field inside the popup. */
 export interface TreeSelectInputProps extends Omit<PrimitivePropsWithRef<'input'>, 'value' | 'defaultValue'> {
 }