@malva-ui/core 0.1.12 → 0.1.14

package/types/malva-ui-core-toolbar.d.ts

@@ -0,0 +1,91 @@
+import * as i0 from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@angular/aria/toolbar';
+import { Toolbar, ToolbarWidget } from '@angular/aria/toolbar';
+
+declare class MlvToolbar {
+    readonly gap: i0.InputSignal<number>;
+    readonly equalSize: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvToolbar, "mlv-toolbar", never, { "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "equalSize": { "alias": "equalSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MlvToolbarSpacer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbarSpacer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvToolbarSpacer, "mlv-toolbar-spacer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Opt-in roving-focus behaviour for a `mlv-toolbar`, backed by
+ * `@angular/aria`'s headless `ngToolbar` pattern.
+ *
+ * Apply `mlvToolbarRoving` to the `<mlv-toolbar>` element and
+ * {@link MlvToolbarWidget} (`mlvToolbarWidget`) to each interactive
+ * child to turn the toolbar into a single Tab stop whose items are traversed
+ * with the arrow keys (plus `Home`/`End`), per the WAI-ARIA toolbar pattern:
+ *
+ * ```html
+ * <mlv-toolbar mlvToolbarRoving>
+ *   <button mlvButton mlvToolbarWidget>Save</button>
+ *   <button mlvButton mlvToolbarWidget>Print</button>
+ * </mlv-toolbar>
+ * ```
+ *
+ * This is **opt-in** on purpose: `mlv-toolbar` projects arbitrary content, so
+ * applying the aria toolbar pattern unconditionally would (a) require every
+ * consumer to annotate their children and (b) mark a widget-less toolbar as a
+ * focusable, `aria-disabled` element. Plain `mlv-toolbar` usage is therefore
+ * left completely untouched.
+ *
+ * The aria pattern's knobs are re-exposed so consumers can pin them where the
+ * element is used (a host directive's inputs cannot be set from the wrapper's
+ * own `host` metadata):
+ *
+ * - `orientation` (`'horizontal'` default) — arrow-key axis.
+ * - `wrap` (`true` default) — whether arrow navigation wraps at the ends.
+ * - `softDisabled` (`true` default) — keep disabled widgets focusable-but-inert
+ *   (`false` skips them during navigation).
+ * - `disabled` — disable the whole toolbar.
+ * - `value` / `valueChange` — selection model for toggle/radio-style toolbars
+ *   (an array of the selected widget values; see {@link MlvToolbarWidget}).
+ */
+declare class MlvToolbarRoving<V> {
+    /** @protected The host `ngToolbar` pattern instance. */
+    protected readonly _toolbar: Toolbar<V>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbarRoving<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvToolbarRoving<any>, "mlv-toolbar[mlvToolbarRoving]", ["mlvToolbarRoving"], {}, {}, never, never, true, [{ directive: typeof i1.Toolbar; inputs: { "orientation": "orientation"; "wrap": "wrap"; "disabled": "disabled"; "softDisabled": "softDisabled"; "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+/**
+ * Marks an interactive element as a widget inside a
+ * {@link MlvToolbarRoving} (`mlvToolbarRoving`) toolbar, backed by
+ * `@angular/aria`'s `ngToolbarWidget`.
+ *
+ * The widget's `value` is exposed through the selector attribute itself, so a
+ * plain action button needs no extra binding and a selection-group button
+ * supplies its identity inline:
+ *
+ * ```html
+ * <!-- action buttons: value defaults to '' -->
+ * <button mlvButton mlvToolbarWidget>Save</button>
+ *
+ * <!-- toggle/radio group: distinct values feed the toolbar's [(value)] model -->
+ * <button mlvButton mlvToolbarWidget="left">Left</button>
+ * <button mlvButton mlvToolbarWidget="center">Center</button>
+ * ```
+ *
+ * **Deviation from the migration plan:** the plan called for synthesising the
+ * required `value` internally via `mlvNextId`. In `@angular/aria` 22.0.5
+ * `ngToolbarWidget.value` is a *required* input, and a wrapper directive cannot
+ * set its own host directive's input from the wrapper's `host` metadata (doing
+ * so raises `NG0950`). The value must therefore be supplied where the element
+ * is declared; exposing it through the selector alias keeps that ergonomic
+ * (omitted → `''`) without forcing every consumer to bind it.
+ */
+declare class MlvToolbarWidget<V> {
+    /** @protected The host `ngToolbarWidget` pattern instance. */
+    protected readonly _widget: ToolbarWidget<V>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbarWidget<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvToolbarWidget<any>, "[mlvToolbarWidget]", ["mlvToolbarWidget"], {}, {}, never, never, true, [{ directive: typeof i1.ToolbarWidget; inputs: { "value": "mlvToolbarWidget"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+export { MlvToolbar, MlvToolbarRoving, MlvToolbarSpacer, MlvToolbarWidget };

package/types/malva-ui-core-tooltip.d.ts

@@ -0,0 +1,200 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvTone } from '@malva-ui/cdk/utils';
+
+/**
+ * Tone variant for the tooltip panel.
+ *
+ * Extends the shared {@link MlvTone} semantic vocabulary
+ * (`'info' | 'success' | 'warning' | 'danger'`) with neutral, surface, and brand options:
+ *
+ * - `'neutral'` — fixed neutral-900 background with a light foreground (default)
+ * - `'surface'` — theme-aware base surface with primary text
+ * - `'primary'` — primary accent color
+ */
+type MlvTooltipTone = MlvTone | 'neutral' | 'surface' | 'primary';
+/**
+ * Preferred placement of the tooltip relative to the trigger element.
+ * CDK will use the first placement that fits in the viewport.
+ */
+type MlvTooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+
+/**
+ * Tooltip directive — attach to any element to show a tooltip on hover and focus.
+ *
+ * The tooltip content is passed as the directive binding value (`mlvTooltip`).
+ * The tooltip appears after `tooltipDelay` ms and disappears immediately on
+ * mouseleave, focusout, or Escape key.
+ *
+ * @example Basic usage
+ * ```html
+ * <button [mlvTooltip]="'Save changes'">Save</button>
+ * ```
+ *
+ * @example With options
+ * ```html
+ * <button
+ *   [mlvTooltip]="'Delete item'"
+ *   tooltipPlacement="bottom"
+ *   tooltipTone="danger"
+ *   [tooltipDelay]="500"
+ * >Delete</button>
+ * ```
+ *
+ * @example Disabled tooltip
+ * ```html
+ * <button [mlvTooltip]="'Info'" tooltipDisabled>Button</button>
+ * ```
+ *
+ * @example No arrow
+ * ```html
+ * <button [mlvTooltip]="'Info'" [tooltipArrow]="false">Button</button>
+ * ```
+ */
+declare class MlvTooltip {
+    /** @private Host element reference. */
+    private readonly _elementRef;
+    /** @private CDK Overlay for creating floating panels. */
+    private readonly _overlay;
+    /**
+     * @private Resolves the direction scoped to the tooltip's host. The panel is
+     * portaled to the overlay container on `<body>`, outside any `[dir]` scope
+     * the host sits in, so the direction must travel on the overlay config — it
+     * also drives `start`/`end` mirroring in the position strategy.
+     */
+    private readonly _rtl;
+    /** @private Environment injector, required for ComponentPortal creation. */
+    private readonly _injector;
+    /** @private Renderer for DOM attribute manipulation. */
+    private readonly _renderer;
+    /** @private Zone for running timer callbacks inside change detection. */
+    private readonly _ngZone;
+    /** @private DestroyRef for cleanup on directive destruction. */
+    private readonly _destroyRef;
+    /**
+     * The tooltip text content.
+     * This is also the directive selector binding: `[mlvTooltip]="'my text'"`.
+     */
+    readonly mlvTooltip: _angular_core.InputSignal<string>;
+    /** Preferred placement of the tooltip relative to the trigger. Defaults to `'top'`. */
+    readonly tooltipPlacement: _angular_core.InputSignal<MlvTooltipPlacement>;
+    /** Tone variant of the tooltip panel. Defaults to `'neutral'` (fixed dark neutral background). */
+    readonly tooltipTone: _angular_core.InputSignal<MlvTooltipTone>;
+    /**
+     * Delay in milliseconds before the tooltip appears after hover or focus.
+     * Defaults to `300`.
+     */
+    readonly tooltipDelay: _angular_core.InputSignal<number>;
+    /**
+     * When `true`, suppresses the tooltip entirely.
+     * Supports attribute syntax: `<element tooltipDisabled>`.
+     */
+    readonly tooltipDisabled: _angular_core.InputSignalWithTransform<BooleanInput, string | boolean>;
+    /**
+     * When `true` (default), renders a directional arrow pointing toward the trigger.
+     * Set to `false` to hide the arrow.
+     * Supports attribute syntax: `<element [tooltipArrow]="false">`.
+     */
+    readonly tooltipArrow: _angular_core.InputSignalWithTransform<BooleanInput, string | boolean>;
+    /**
+     * @private Reference to the dynamically created `MlvTooltipPanel` instance.
+     */
+    private _componentRef;
+    /**
+     * @private CDK overlay reference managing the floating panel.
+     */
+    private _overlayRef;
+    /**
+     * @private Timer handle for the `tooltipDelay` show timer.
+     */
+    private _showTimer;
+    /**
+     * @private Timer handle for the grace-period hide timer. Gives the pointer
+     * time to travel from the trigger onto the tooltip panel (WCAG 1.4.13).
+     */
+    private _hideTimer;
+    /**
+     * @private Grace period (ms) before hiding on mouseleave, allowing the pointer
+     * to reach the hoverable tooltip panel without it disappearing.
+     */
+    private readonly _hideDelay;
+    /**
+     * @private Cleanup functions for the panel hover listeners, invoked on hide.
+     */
+    private _panelListeners;
+    /**
+     * @private Stable unique ID for this tooltip instance, used by `aria-describedby`.
+     */
+    private readonly _tooltipId;
+    constructor();
+    /** @protected Schedules tooltip display on mouseenter. */
+    protected _onMouseEnter(): void;
+    /**
+     * @protected Cancels pending show and schedules a delayed hide on mouseleave.
+     * The grace period lets the pointer move onto the tooltip panel without it
+     * disappearing (WCAG 1.4.13 — content on hover must be hoverable).
+     */
+    protected _onMouseLeave(): void;
+    /** @protected Schedules tooltip display on focusin (keyboard users). */
+    protected _onFocusIn(): void;
+    /** @protected Cancels pending show and hides tooltip on focusout. */
+    protected _onFocusOut(): void;
+    /** @protected Cancels pending show and hides tooltip on Escape key. */
+    protected _onEscape(): void;
+    /**
+     * @private Schedules tooltip display after `tooltipDelay` ms inside NgZone.
+     */
+    private _scheduleShow;
+    /**
+     * @private Clears the pending show timer if one is active.
+     */
+    private _clearShowTimer;
+    /**
+     * @private Schedules the tooltip to hide after the `_hideDelay` grace period.
+     */
+    private _scheduleHide;
+    /**
+     * @private Clears the pending hide timer if one is active.
+     */
+    private _clearHideTimer;
+    /**
+     * @private Creates the CDK overlay, attaches `MlvTooltipPanel`, and wires
+     * `aria-describedby` on the host element. If the tooltip is already visible
+     * this method is a no-op.
+     */
+    private _show;
+    /**
+     * @private Disposes the CDK overlay, destroys the component reference, and
+     * removes `aria-describedby` from the host element.
+     */
+    private _hide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvTooltip, "[mlvTooltip]", never, { "mlvTooltip": { "alias": "mlvTooltip"; "required": true; "isSignal": true; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; "isSignal": true; }; "tooltipTone": { "alias": "tooltipTone"; "required": false; "isSignal": true; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; "isSignal": true; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; "isSignal": true; }; "tooltipArrow": { "alias": "tooltipArrow"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Internal tooltip panel component.
+ *
+ * This component is not intended for direct consumer use — it is created
+ * programmatically by `MlvTooltip` and attached to a CDK overlay.
+ *
+ * Renders the floating tooltip panel with optional directional arrow.
+ * Placement and tone variant are controlled via inputs set by the directive.
+ */
+declare class MlvTooltipPanel {
+    /** The text content to display inside the tooltip panel. */
+    readonly content: _angular_core.InputSignal<string>;
+    /** The tone variant of the tooltip panel. */
+    readonly tone: _angular_core.InputSignal<MlvTooltipTone>;
+    /** Whether the directional arrow is visible. */
+    readonly showArrow: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The preferred placement of the tooltip relative to the trigger. */
+    readonly placement: _angular_core.InputSignal<MlvTooltipPlacement>;
+    /** Unique ID for the tooltip panel, used by `aria-describedby` on the trigger. */
+    readonly tooltipId: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTooltipPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvTooltipPanel, "mlv-tooltip-panel", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "showArrow": { "alias": "showArrow"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { MlvTooltip, MlvTooltipPanel };
+export type { MlvTooltipPlacement, MlvTooltipTone };

package/types/malva-ui-core-tree.d.ts

@@ -0,0 +1,289 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken, OnInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { TreeItem } from '@angular/aria/tree';
+
+/**
+ * Represents a single node in the tree data structure.
+ * The generic parameter `T` is the type of the node's data payload.
+ */
+interface MlvTreeNode<T = unknown> {
+    /** Unique identifier for the node. Used for tracking and key management. */
+    id: string | number;
+    /** The data payload associated with this node. */
+    data: T;
+    /** Human-readable label shown in the default node template. */
+    label: string;
+    /** Pre-loaded children of this node. If omitted and `loadChildren` is set, children are loaded lazily. */
+    children?: MlvTreeNode<T>[];
+    /**
+     * Async callback for lazy-loading child nodes.
+     * When defined, the node shows a loading spinner on first expand until the promise resolves.
+     */
+    loadChildren?: () => Promise<MlvTreeNode<T>[]>;
+    /** When true, the node is rendered as disabled — not selectable or expandable via keyboard. */
+    disabled?: boolean;
+    /** Optional icon name (Lucide icon) shown before the label in the default template. */
+    icon?: string;
+    /** When true, the node starts expanded. Only applies to initial render. */
+    expanded?: boolean;
+}
+/**
+ * Internal flat-list representation of a tree node used for rendering.
+ * Calculated from the tree data by depth and expansion state.
+ */
+interface MlvFlatTreeNode<T = unknown> {
+    /** Reference to the original tree node. */
+    node: MlvTreeNode<T>;
+    /** Depth level (0 = root). Used for indentation. */
+    depth: number;
+    /** Whether this node is currently expanded. */
+    isExpanded: boolean;
+    /** Whether this node has children (loaded or lazy). */
+    hasChildren: boolean;
+    /** Whether this node is currently loading children (lazy load in progress). */
+    isLoading: boolean;
+    /** Unique key for `@for` tracking. */
+    key: string | number;
+}
+/** Selection mode for the tree component. */
+type MlvTreeSelectMode = 'none' | 'single' | 'multi';
+
+/**
+ * Context provided to the `[mlvTreeNodeDef]` template.
+ */
+interface MlvTreeNodeDefContext<T = unknown> {
+    /** The flat tree node for the current row. */
+    $implicit: MlvFlatTreeNode<T>;
+}
+/**
+ * Structural directive that marks a `<ng-template>` as a custom node template.
+ *
+ * Usage:
+ * ```html
+ * <mlv-tree [nodes]="nodes">
+ *   <ng-template mlvTreeNodeDef let-flatNode>
+ *     <span>{{ flatNode.node.label }}</span>
+ *   </ng-template>
+ * </mlv-tree>
+ * ```
+ */
+declare class MlvTreeNodeDef<T = unknown> {
+    /** The template reference for this custom node slot. */
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * Type guard for correct template variable inference.
+     * @internal
+     */
+    static ngTemplateContextGuard<T>(_dir: MlvTreeNodeDef<T>, _ctx: unknown): _ctx is MlvTreeNodeDefContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTreeNodeDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvTreeNodeDef<any>, "[mlvTreeNodeDef]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Public accessor interface that the recursive `MlvTreeSubtree` uses to
+ * communicate with its parent `MlvTree` via the `MLV_TREE` injection
+ * token.
+ *
+ * All members map to the corresponding public members of `MlvTree`.
+ * Selection, roving focus, keyboard navigation, expansion state and all ARIA
+ * attributes are owned by the `@angular/aria` `Tree`/`TreeItem`/`TreeItemGroup`
+ * directives applied inside the subtree template; this accessor only surfaces
+ * the Malva UI-specific glue (lazy loading, custom templates, `nodeActivate`,
+ * `nodeToggle`, and the single-select deselect-on-re-click affordance).
+ */
+interface MlvTreeAccessor {
+    /** Current selection mode. */
+    selectMode(): MlvTreeSelectMode;
+    /** Indentation size in rem per depth level. */
+    indentSize(): number;
+    /** Whether the given node id is currently expanded. */
+    _isExpanded(id: string | number): boolean;
+    /** Whether the given node id is currently loading lazy children. */
+    _isLoading(id: string | number): boolean;
+    /** Whether the given node id is currently selected. */
+    _isSelected(id: string | number): boolean;
+    /**
+     * Returns the effective children of a node: lazily-loaded children when
+     * present, otherwise the static `children` array.
+     */
+    _children(node: MlvTreeNode): MlvTreeNode[];
+    /** Whether a node renders an expandable group (static, loaded, or lazy children). */
+    _hasChildren(node: MlvTreeNode): boolean;
+    /** Custom node template directive, if any. */
+    _nodeDefDirective(): MlvTreeNodeDef | undefined;
+    /**
+     * Reacts to the aria `TreeItem.expanded` model changing (keyboard, pointer,
+     * chevron, or programmatic). Syncs the expansion set, triggers lazy loading,
+     * and emits `nodeToggle`.
+     */
+    _onExpandedChange(node: MlvTreeNode, expanded: boolean): void;
+    /**
+     * Chevron toggle handler. Guards disabled nodes, stops propagation so the
+     * aria tree does not also select the row, and flips the aria item's
+     * `expanded` model (which routes through `_onExpandedChange`).
+     */
+    _onToggle(node: MlvTreeNode, item: TreeItem<string | number>, event: Event): void;
+    /**
+     * Row pointer handler. Emits `nodeActivate` in `none` mode and implements the
+     * single-select deselect-on-re-click affordance (aria's `selectOne` never
+     * deselects on its own).
+     */
+    _onRowClick(node: MlvTreeNode, event: MouseEvent): void;
+    /** Row Enter/Space handler used to emit `nodeActivate` in `none` mode. */
+    _onActivateKey(node: MlvTreeNode): void;
+}
+/**
+ * Injection token that provides the parent `MlvTree` as a
+ * `MlvTreeAccessor` to nested `MlvTreeSubtree` instances.
+ */
+declare const MLV_TREE: InjectionToken<MlvTreeAccessor>;
+
+/** `aria-current` type surfaced when the tree is used as a navigation tree. */
+type MlvTreeCurrentType = 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+/**
+ * Hierarchical data tree component for displaying nested data.
+ *
+ * Built on the `@angular/aria` headless `Tree`/`TreeItem`/`TreeItemGroup`
+ * directives (applied inside the component — consumers never see `ng*`
+ * selectors). aria owns roles, `aria-level`/`setsize`/`posinset`, roving
+ * `tabindex`, keyboard navigation (arrows, Home/End), text typeahead, and
+ * selection; the component keeps the Malva UI data-driven `nodes` API, the
+ * `mlv-expand` animated expand/collapse, lazy loading, custom node templates,
+ * and multi-select checkboxes.
+ *
+ * Features:
+ * - Expand/collapse nodes with smooth animated height transition via `mlv-expand`
+ * - Single-select and multi-select checkbox mode
+ * - Lazy loading via `loadChildren` callbacks with spinner
+ * - Full keyboard navigation and text typeahead (owned by `@angular/aria`)
+ * - Custom node templates via `[mlvTreeNodeDef]`
+ * - Optional navigation-tree mode (`nav` + `currentType`) for sidebar-style trees
+ * - Generic typed `MlvTreeNode<T>` interface
+ * - Recursive rendering via internal `MlvTreeSubtree`
+ *
+ * @example
+ * ```html
+ * <mlv-tree [nodes]="treeData" selectMode="multi" (selectionChange)="onSelect($event)" />
+ * ```
+ */
+declare class MlvTree<T = unknown> implements OnInit, MlvTreeAccessor {
+    /** The tree nodes to render. Supports nested children. */
+    readonly nodes: _angular_core.InputSignal<MlvTreeNode<T>[]>;
+    /**
+     * Selection mode:
+     * - `'none'` — no selection (default); rows are activated (`nodeActivate`)
+     * - `'single'` — click/Space/Enter selects one node at a time
+     * - `'multi'` — checkbox-based multi-select
+     */
+    readonly selectMode: _angular_core.InputSignal<MlvTreeSelectMode>;
+    /** Indentation per depth level in `rem`. Defaults to `1.5`. */
+    readonly indentSize: _angular_core.InputSignal<number>;
+    /**
+     * When true, renders vertical and horizontal connector lines between parent and child nodes
+     * (file-explorer pattern). Defaults to `false`.
+     */
+    readonly showConnectors: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When true, the tree renders as a navigation tree: selected rows expose
+     * `aria-current` (of `currentType`) instead of `aria-selected`. Suited to
+     * sidebar-style navigation trees. Defaults to `false`.
+     */
+    readonly nav: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The `aria-current` type used when `nav` is enabled. Defaults to `'page'`. */
+    readonly currentType: _angular_core.InputSignal<MlvTreeCurrentType>;
+    /** Emits the set of selected node IDs whenever the selection changes. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<Set<string | number>>;
+    /** Emits when a node is activated (clicked or Enter in single-select/none mode). */
+    readonly nodeActivate: _angular_core.OutputEmitterRef<MlvTreeNode<T>>;
+    /** Emits when a node's expanded state changes. */
+    readonly nodeToggle: _angular_core.OutputEmitterRef<{
+        node: MlvTreeNode<T>;
+        expanded: boolean;
+    }>;
+    /**
+     * @public Selected node ids, mirrored to the aria `Tree.value` model (aria
+     * selection is always an array — a single-select tree holds at most one id).
+     */
+    readonly _value: _angular_core.WritableSignal<(string | number)[]>;
+    /**
+     * @private Selection membership set derived from `_value`. Rebuilt only when
+     * the selection changes, giving `_isSelected` an O(1) lookup instead of an
+     * O(selected) array scan on every node (twice per row) per change-detection
+     * pass. Mirrors the `_expandedIds`/`_loadingIds` Set pattern.
+     */
+    private readonly _selectedIdSet;
+    /** @public Internal expansion state set (node id → expanded). */
+    readonly _expandedIds: _angular_core.WritableSignal<Set<string | number>>;
+    /** @public Map of node id → loaded children (for lazy nodes). */
+    readonly _loadedChildren: _angular_core.WritableSignal<Map<string | number, MlvTreeNode<T>[]>>;
+    /** @private Set of node ids currently loading lazy children. */
+    private readonly _loadingIds;
+    /** @public The custom node template if provided. */
+    readonly _nodeDefDirective: _angular_core.Signal<MlvTreeNodeDef<any> | undefined>;
+    ngOnInit(): void;
+    /** @private Collect nodes that have `expanded: true` initially. */
+    private _collectInitialExpanded;
+    /** @public Whether the given node id is currently expanded. */
+    _isExpanded(id: string | number): boolean;
+    /** @public Whether the given node id is currently loading lazy children. */
+    _isLoading(id: string | number): boolean;
+    /** @public Whether the given node id is currently selected. */
+    _isSelected(id: string | number): boolean;
+    /**
+     * @public Effective children of a node — lazily-loaded children when present,
+     * otherwise the static `children` array.
+     */
+    _children(node: MlvTreeNode<T>): MlvTreeNode<T>[];
+    /** @public Whether a node renders an expandable group (static/loaded/lazy children). */
+    _hasChildren(node: MlvTreeNode<T>): boolean;
+    /**
+     * @public Reacts to the aria `TreeItem.expanded` model changing (keyboard,
+     * pointer, chevron, or programmatic). Syncs the expansion set, triggers lazy
+     * loading, and emits `nodeToggle`.
+     */
+    _onExpandedChange(node: MlvTreeNode<T>, expanded: boolean): void;
+    /**
+     * @public Chevron toggle handler. Guards disabled nodes, stops propagation so
+     * the aria tree does not also select the row, and flips the aria item's
+     * `expanded` model (which routes through `_onExpandedChange`).
+     */
+    _onToggle(node: MlvTreeNode<T>, item: TreeItem<string | number>, event: Event): void;
+    /**
+     * @public Row pointer handler. Emits `nodeActivate` in `none` mode and
+     * implements the single-select deselect-on-re-click affordance (aria's
+     * `selectOne` never deselects on its own).
+     */
+    _onRowClick(node: MlvTreeNode<T>, event: MouseEvent): void;
+    /** @public Row Enter/Space handler used to emit `nodeActivate` in `none` mode. */
+    _onActivateKey(node: MlvTreeNode<T>): void;
+    /**
+     * @public Bridges the aria `Tree.value` model to `selectionChange`. Also
+     * emits `nodeActivate` for user-driven single-select (pointer or keyboard);
+     * programmatic selection goes through `setSelection` instead.
+     */
+    _onAriaValueChange(value: (string | number)[]): void;
+    /** @private Load lazy children then keep the node expanded to reveal them. */
+    private _loadLazy;
+    /** @private Recursively find a node by id across static and loaded children. */
+    private _findNode;
+    /** @public Exposes the currently selected node ids. */
+    get selectedIds(): Set<string | number>;
+    /** Programmatically set the selected node IDs. */
+    setSelection(ids: Set<string | number>): void;
+    /** Programmatically expand a node by ID. */
+    expandNode(nodeId: string | number): void;
+    /** Programmatically collapse a node by ID. */
+    collapseNode(nodeId: string | number): void;
+    /** Expand all nodes. */
+    expandAll(): void;
+    /** Collapse all nodes. */
+    collapseAll(): void;
+    /** @private Collect all node IDs recursively. */
+    private _collectAllIds;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTree<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvTree<any>, "mlv-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "indentSize": { "alias": "indentSize"; "required": false; "isSignal": true; }; "showConnectors": { "alias": "showConnectors"; "required": false; "isSignal": true; }; "nav": { "alias": "nav"; "required": false; "isSignal": true; }; "currentType": { "alias": "currentType"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeActivate": "nodeActivate"; "nodeToggle": "nodeToggle"; }, ["_nodeDefDirective"], never, true, never>;
+}
+
+export { MLV_TREE, MlvTree, MlvTreeNodeDef };
+export type { MlvFlatTreeNode, MlvTreeAccessor, MlvTreeCurrentType, MlvTreeNode, MlvTreeNodeDefContext, MlvTreeSelectMode };