@acorex/components 21.0.0-next.4 → 21.0.0-next.40

package/tree-view/index.d.ts

@@ -1,184 +1,674 @@
 import * as _angular_core from '@angular/core';
-import { EventEmitter, TemplateRef } from '@angular/core';
-import * as i4 from '@acorex/cdk/common';
-import { AXClickEvent, NXComponent, AXExpandToggleIcons, AXValueChangedEvent } from '@acorex/cdk/common';
-import { AXPlatform } from '@acorex/core/platform';
-import * as i3 from '@angular/common';
-import * as i5 from '@acorex/components/decorators';
-import * as i6 from '@acorex/components/check-box';
-import * as i7 from '@acorex/components/form';
-import * as i8 from '@angular/forms';
-import * as i9 from '@acorex/components/tooltip';
-import * as i10 from '@acorex/components/loading';
+import { TemplateRef } from '@angular/core';
+import { AXEvent, AXHtmlEvent, AXValueChangedEvent } from '@acorex/cdk/common';
+import { AXDropListDroppedEvent } from '@acorex/cdk/drag-drop';
 
-declare class AXTreeItemClickBaseEvent extends AXClickEvent {
-    nativeElement: any;
+/**
+ * TreeView Component - Design Tokens
+ *
+ * The component supports the following CSS custom properties (design tokens):
+ *
+ * **Layout & Spacing:**
+ * - `--ax-comp-tree-view-indent-size`: Indentation size for each tree level.
+ *   Default: `12px`
+ * - `--ax-comp-tree-view-node-margin`: Vertical margin between nodes.
+ *   Default: `0.125rem`
+ *
+ * **Node Styling:**
+ * - `--ax-comp-tree-view-node-border-radius`: Border radius for tree nodes.
+ *   Default: `6px`
+ * - `--ax-comp-tree-view-node-hover-bg`: Background color on node hover.
+ *   Default: `rgba(var(--ax-sys-color-on-lightest-surface), 0.04)`
+ * - `--ax-comp-tree-view-node-selected-bg`: Background color for selected nodes.
+ *   Default: `rgba(var(--ax-sys-color-primary-500), 0.12)`
+ *
+ * **Tree Lines (with-line look):**
+ * - `--ax-comp-tree-view-line-color`: Color for tree structure lines.
+ *   Default: `rgba(var(--ax-sys-color-on-lightest-surface), 0.15)`
+ *
+ * **Drag & Drop:**
+ * - `--ax-comp-tree-view-drag-preview-opacity`: Opacity of dragged element preview.
+ *   Default: `0.9`
+ * - `--ax-comp-tree-view-drag-placeholder-bg`: Background for drag placeholder.
+ *   Default: `rgba(var(--ax-sys-color-on-lightest-surface), 0.02)`
+ * - `--ax-comp-tree-view-drop-active-bg`: Background when hovering over valid drop zone.
+ *   Default: `rgba(var(--ax-sys-color-primary-500), 0.08)`
+ * - `--ax-comp-tree-view-drop-active-outline`: Outline color for active drop zones.
+ *   Default: `rgba(var(--ax-sys-color-primary-500), 0.3)`
+ *
+ * **Dynamic Tokens (set via TypeScript):**
+ * - `--ax-tree-view-indent-size`: Dynamically set from `indentSize` input
+ * - `--ax-tree-view-line-offset`: Dynamically calculated as `indentSize / 2`
+ * - `--ax-tree-view-line-color`: Optional override for line color
+ *
+ * @example
+ * ```css
+ * // Customize tree appearance
+ * ax-tree-view {
+ *   --ax-comp-tree-view-indent-size: 16px;
+ *   --ax-comp-tree-view-node-selected-bg: rgba(var(--ax-sys-color-primary-600), 0.15);
+ *   --ax-comp-tree-view-line-color: rgba(var(--ax-sys-color-on-lightest-surface), 0.1);
+ *   --ax-comp-tree-view-node-hover-bg: rgba(var(--ax-sys-color-primary-500), 0.06);
+ * }
+ * ```
+ *
+ * @remarks
+ * All color tokens use Acorex design system variables (`--ax-sys-color-*`) for automatic
+ * light/dark mode support. Colors adapt based on the active theme without additional configuration.
+ */
+interface AXTreeViewBeforeDropEvent extends AXEvent {
+    movedNode: AXTreeViewNode;
+    previousParent?: AXTreeViewNode;
+    currentParent?: AXTreeViewNode;
+    previousIndex: number;
+    currentIndex: number;
+    canceled: boolean;
 }
-type AXTreeViewSelectionBehavior = 'autoExpand' | 'cascade' | 'indeterminate';
-type AXTreeViewExpandBehavior = 'click' | 'dbClick' | 'defult';
-type AXTreeViewOperationMethod = 'expand' | 'active' | 'visible' | 'disabled';
-type AXTreeViewLook = 'with-line' | 'defult';
-type AXTreeViewSelectionScope = 'all' | 'parent' | 'children';
-declare abstract class AXTreeViewBase {
-    abstract getChildren(item: unknown): unknown[];
-    abstract hasChildren(item: unknown): boolean;
-    abstract itemTemplate: any;
-    abstract disableField(): string;
-    abstract childrenField(): string;
-    abstract valueField(): string;
-    abstract activeField(): string;
-    abstract hasChildField(): string;
-    abstract tooltipField(): string;
-    abstract showEmptyNodeMassage(): boolean;
-    abstract expandOn(): AXTreeViewExpandBehavior;
-    abstract focusNodeEnabled(): boolean;
-    abstract toggleIcons(): {
-        expanded: string;
-        collapsed: string;
-    } | null;
-    abstract itemsPromise: boolean;
-    abstract itemsSignal(): unknown[];
-    abstract fetchData(item: unknown): void;
-    abstract setNodeLoading(value: unknown, loading: boolean): void;
-    abstract handleUnActiveNode(items: unknown[]): void;
-    abstract onCollapsedChanged: EventEmitter<{
-        component: any;
-        data: unknown;
-        nativeElement: any;
-    }>;
-    abstract onNodeClick: EventEmitter<{
-        component: any;
-        data: unknown;
-        nativeElement: any;
-    }>;
-    abstract onNodedbClick: EventEmitter<{
-        component: any;
-        data: unknown;
-        nativeElement: any;
-    }>;
+interface AXTreeViewNode {
+    id: string;
+    label: string;
+    icon?: string;
+    expanded?: boolean;
+    selected?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    visible?: boolean;
+    children?: AXTreeViewNode[];
+    childrenCount?: number;
+    loading?: boolean;
+    data?: unknown;
 }
-
-declare class AXTreeViewItemComponent extends NXComponent {
-    constructor();
-    treeView: AXTreeViewBase;
-    item: _angular_core.InputSignal<unknown>;
-    isExpanded: _angular_core.ModelSignal<boolean>;
-    isActive: _angular_core.ModelSignal<boolean>;
-    isLoading: _angular_core.InputSignal<boolean>;
-    executorChanges: _angular_core.InputSignal<AXTreeViewOperationMethod>;
-    protected platformService: AXPlatform;
-    protected arrowIcon: _angular_core.Signal<string>;
-    protected handleArrowNodeClick(): void;
-    protected handleTextClick(): void;
-    protected handleTextDbClick(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXTreeViewItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXTreeViewItemComponent, "ax-tree-view-item", never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "executorChanges": { "alias": "executorChanges"; "required": false; "isSignal": true; }; }, { "isExpanded": "isExpandedChange"; "isActive": "isActiveChange"; }, never, ["ax-check-box", "ax-prefix", "ax-text", "ax-suffix", "*"], true, never>;
+interface AXTreeViewNodeToggleEvent extends AXHtmlEvent {
+    node: AXTreeViewNode;
+}
+interface AXTreeViewNodeSelectEvent extends AXHtmlEvent {
+    node: AXTreeViewNode;
+}
+interface AXTreeViewDropEvent extends AXEvent {
+    node: AXTreeViewNode;
+    previousParent?: AXTreeViewNode;
+    currentParent?: AXTreeViewNode;
+    previousIndex: number;
+    currentIndex: number;
+}
+interface AXTreeViewItemTemplateContext {
+    $implicit: AXTreeViewNode;
+    node: AXTreeViewNode;
+    level: number;
+    expanded: boolean;
+    childrenCount: number;
+    loading: boolean;
+}
+type AXTreeViewViewLook = 'default' | 'card' | 'with-line';
+type AXTreeViewDragMode = 'none' | 'handler' | 'item';
+type AXTreeViewDragOperationType = 'order-only' | 'move' | 'both';
+type AXTreeViewSelectMode = 'single' | 'multiple';
+/**
+ * Function type for lazy loading tree nodes
+ */
+type AXTreeViewCallback = (id?: string) => AXTreeViewNode[] | Promise<AXTreeViewNode[]>;
+/**
+ * Data source type - can be static array or lazy loading function
+ */
+type AXTreeViewDataSource = AXTreeViewNode[] | AXTreeViewCallback;
+/**
+ * Flat node representation for keyboard navigation
+ */
+interface AXTreeViewFlatNode {
+    node: AXTreeViewNode;
+    level: number;
+    parent?: AXTreeViewNode;
+}
+/**
+ * Children selection state for parent node calculation
+ */
+interface AXTreeViewChildrenSelectionState {
+    allSelected: boolean;
+    someSelected: boolean;
 }
 
-declare class AXTreeViewComponent extends NXComponent {
+declare class AXTreeViewComponent {
     #private;
-    /** @ignore */
-    private get __hostClass();
-    itemsSignal: _angular_core.WritableSignal<unknown[]>;
-    itemsPromise: any;
-    items: _angular_core.InputSignal<unknown[] | ((selectedItemId?: string | number) => unknown[] | Promise<unknown[]>)>;
-    protected get resolvedItems(): unknown[];
-    showCheckbox: _angular_core.InputSignal<boolean>;
-    hasCheckboxField: _angular_core.InputSignal<string>;
-    selectionMode: _angular_core.InputSignal<"single" | "multiple">;
-    selectionBehavior: _angular_core.InputSignal<AXTreeViewSelectionBehavior>;
-    selectionScope: _angular_core.InputSignal<AXTreeViewSelectionScope>;
-    focusNodeEnabled: _angular_core.InputSignal<boolean>;
-    valueField: _angular_core.InputSignal<string>;
-    textField: _angular_core.InputSignal<string>;
-    visibleField: _angular_core.InputSignal<string>;
-    disableField: _angular_core.InputSignal<string>;
-    hasChildField: _angular_core.InputSignal<string>;
-    selectedField: _angular_core.InputSignal<string>;
-    expandedField: _angular_core.InputSignal<string>;
-    tooltipField: _angular_core.InputSignal<string>;
-    childrenField: _angular_core.InputSignal<string>;
-    activeField: _angular_core.InputSignal<string>;
-    indeterminateField: _angular_core.InputSignal<string>;
-    parentField: _angular_core.InputSignal<string>;
-    iconField: _angular_core.InputSignal<string>;
-    toggleIcons: _angular_core.InputSignal<AXExpandToggleIcons>;
-    look: _angular_core.InputSignal<AXTreeViewLook>;
-    showEmptyNodeMassage: _angular_core.InputSignal<boolean>;
-    onSelectionChanged: _angular_core.OutputEmitterRef<AXTreeItemClickBaseEvent>;
-    onItemSelectedChanged: _angular_core.OutputEmitterRef<AXTreeItemClickBaseEvent>;
-    onNodeClick: _angular_core.OutputEmitterRef<AXTreeItemClickBaseEvent>;
-    onCollapsedChanged: _angular_core.OutputEmitterRef<AXTreeItemClickBaseEvent>;
-    onNodedbClick: _angular_core.OutputEmitterRef<AXTreeItemClickBaseEvent>;
-    executorChanges: _angular_core.WritableSignal<AXTreeViewOperationMethod>;
-    itemTemplate?: TemplateRef<unknown>;
-    emptyTemplate?: TemplateRef<unknown>;
-    protected platformService: AXPlatform;
-    expandOn: _angular_core.InputSignal<AXTreeViewExpandBehavior>;
-    protected handleNodeSelectionClick(event: AXValueChangedEvent, item: unknown): void;
-    /**
-     *
-     * auto expand
-     *
-     */
-    private toggleExpand;
-    /**
-     *
-     * expand and change value parent change
-     *
-     */
-    private expandAndToggleSelection;
-    private applySelectionToChildren;
-    /**
-     *
-     * indeterminate logic
-     *
-     */
-    private updateParentSelection;
-    private findParent;
-    /**
-     *
-     * find node selected true for emit Selections
-     *
-     */
-    private findSelectedNodes;
-    /**
-     *
-     * find for emit Selections single mode
-     *
-     */
-    private handleUnSelectNode;
-    /**
-     *
-     * lazy load logic
-     *
-     */
-    fetchData(selectedNode?: unknown): void;
-    private findNode;
-    /**
-     *
-     * emit when arrow click
-     *
-     */
-    protected handleNodeExpandClick(node: AXTreeItemClickBaseEvent): void;
-    handleUnActiveNode(unActiveSource: unknown[]): void;
-    private loadingState;
-    protected isNodeLoading(nodeId: string | number): boolean;
-    setNodeLoading(nodeId: string | number, isLoading: boolean): void;
-    executeOnTreeNode(node: unknown, operation: AXTreeViewOperationMethod, value: boolean): void;
+    private readonly treeService;
+    private readonly platformService;
+    private readonly destroyRef;
+    /** Tree data source - can be static array or lazy loading function */
+    readonly datasource: _angular_core.ModelSignal<AXTreeViewDataSource>;
+    /** Selection mode: 'single' (click to select) or 'multiple' (checkbox selection) */
+    readonly selectMode: _angular_core.InputSignal<AXTreeViewSelectMode>;
+    /** Whether to show checkboxes for selection (only applies to multiple mode) */
+    readonly showCheckbox: _angular_core.InputSignal<boolean>;
+    /** When true, selecting a parent also selects all loaded children (only for multiple mode) */
+    readonly checkChildrenOnSelect: _angular_core.InputSignal<boolean>;
+    /** When true, selecting a child makes parents indeterminate (only for multiple mode) */
+    readonly intermediateState: _angular_core.InputSignal<boolean>;
+    /** When true, clicking on a node toggles its selection (works for both single and multiple modes) */
+    readonly checkOnClick: _angular_core.InputSignal<boolean>;
+    /** Drag and drop mode: 'none' (disabled), 'handler' (drag handle), 'item' (entire item) */
+    readonly dragMode: _angular_core.InputSignal<AXTreeViewDragMode>;
+    /** Drag operation type: 'order-only' (reorder only), 'move' (move between parents), 'both' (allow both) */
+    readonly dragOperationType: _angular_core.InputSignal<AXTreeViewDragOperationType>;
+    /** Whether to show icons */
+    readonly showIcons: _angular_core.InputSignal<boolean>;
+    /** Whether to show children count badge */
+    readonly showChildrenBadge: _angular_core.InputSignal<boolean>;
+    /** Custom icon for expanded nodes */
+    readonly expandedIcon: _angular_core.InputSignal<string>;
+    /** Custom icon for collapsed nodes */
+    readonly collapsedIcon: _angular_core.InputSignal<string>;
+    /** Indent size in pixels for each level */
+    readonly indentSize: _angular_core.InputSignal<number>;
+    /** Node height in pixels */
+    readonly nodeHeight: _angular_core.InputSignal<"compact" | "normal" | "comfortable">;
+    /** Visual style variant */
+    readonly look: _angular_core.InputSignal<AXTreeViewViewLook>;
+    /** Custom template for tree items */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<AXTreeViewItemTemplateContext>>;
+    /** Emitted before a drop operation - set canceled to true to prevent drop */
+    readonly onBeforeDrop: _angular_core.OutputEmitterRef<AXTreeViewBeforeDropEvent>;
+    /** Emitted when a node is toggled (expanded/collapsed) */
+    readonly onNodeToggle: _angular_core.OutputEmitterRef<AXTreeViewNodeToggleEvent>;
+    /** Emitted when a node is selected/deselected */
+    readonly onNodeSelect: _angular_core.OutputEmitterRef<AXTreeViewNodeSelectEvent>;
+    /** Emitted when nodes are reordered within the same parent */
+    readonly onOrderChange: _angular_core.OutputEmitterRef<AXTreeViewDropEvent>;
+    /** Emitted when a node is moved to a different parent */
+    readonly onMoveChange: _angular_core.OutputEmitterRef<AXTreeViewDropEvent>;
+    /** Emitted for any item change (order or move) */
+    readonly onItemsChange: _angular_core.OutputEmitterRef<AXTreeViewDropEvent>;
+    /** Internal signal for tree nodes */
+    protected readonly nodes: _angular_core.WritableSignal<AXTreeViewNode[]>;
+    /** Internal signal for tracking loading state */
+    protected readonly loadingNodes: _angular_core.WritableSignal<Set<string>>;
+    /** Currently focused node ID for keyboard navigation */
+    protected readonly focusedNodeId: _angular_core.WritableSignal<string>;
+    /** RTL detection signal */
+    protected readonly isRtl: _angular_core.WritableSignal<boolean>;
+    /** Computed chevron icons that flip for RTL */
+    protected readonly directionExpandedIcon: _angular_core.Signal<string>;
+    protected readonly directionCollapsedIcon: _angular_core.Signal<string>;
+    /** Flag to prevent infinite loops when syncing datasource */
+    private isUpdatingFromDatasource;
+    /** Computed to check if datasource is a function */
+    private readonly isLazyDataSource;
+    /**
+     * Expand all nodes in the tree (with lazy loading support)
+     */
+    expandAll(): Promise<void>;
+    /**
+     * Collapse all nodes in the tree
+     */
+    collapseAll(): void;
+    /**
+     * Get count of selected nodes
+     */
+    getSelectedCount(): number;
+    /**
+     * Check if any nodes are selected
+     */
+    hasSelection(): boolean;
+    /**
+     * Get all selected nodes
+     */
+    getSelectedNodes(): AXTreeViewNode[];
+    /**
+     * Delete selected nodes from the tree
+     */
+    deleteSelected(): void;
+    /**
+     * Select all nodes in the tree
+     */
+    selectAll(): void;
+    /**
+     * Deselect all nodes in the tree
+     */
+    deselectAll(): void;
+    /**
+     * Find a node by ID in the tree
+     */
+    findNode(id: string): AXTreeViewNode | null;
+    /**
+     * Refresh the tree to trigger change detection
+     */
     refresh(): void;
-    setNodeExpandAndChildren(valueFields: (number | string)[], value: boolean): Promise<void>;
-    private findNodesByValueField;
-    private expandNodeAndAllChildren;
+    /**
+     * Check if a node is currently loading
+     */
+    isNodeLoading(nodeId: string): boolean;
+    /**
+     * Edit/update a node's properties
+     * @param nodeId - The ID of the node to edit
+     * @param updates - Partial node object with properties to update
+     * @returns true if node was found and updated, false otherwise
+     */
+    editNode(nodeId: string, updates: Partial<AXTreeViewNode>): boolean;
+    /**
+     * Add a child node to a parent node
+     * @param parentId - The ID of the parent node
+     * @param childNode - The child node to add
+     * @param index - Optional index to insert at (default: append to end)
+     * @returns true if parent was found and child was added, false otherwise
+     */
+    addChild(parentId: string, childNode: AXTreeViewNode, index?: number): boolean;
+    /**
+     * Remove a node from the tree
+     * @param nodeId - The ID of the node to remove
+     * @returns The removed node if found, null otherwise
+     */
+    removeNode(nodeId: string): AXTreeViewNode | null;
+    /**
+     * Expand a specific node
+     * @param nodeId - The ID of the node to expand
+     * @returns Promise that resolves when expansion is complete (if lazy loading)
+     */
+    expandNode(nodeId: string): Promise<void>;
+    /**
+     * Collapse a specific node
+     * @param nodeId - The ID of the node to collapse
+     */
+    collapseNode(nodeId: string): void;
+    /**
+     * Toggle expansion state of a specific node
+     * @param nodeId - The ID of the node to toggle
+     * @returns Promise that resolves when toggle is complete (if lazy loading)
+     */
+    toggleNodeExpansion(nodeId: string): Promise<void>;
+    /**
+     * Programmatically select a node
+     * @param nodeId - The ID of the node to select
+     * @returns true if node was found and selected, false otherwise
+     */
+    selectNode(nodeId: string): boolean;
+    /**
+     * Programmatically deselect a node
+     * @param nodeId - The ID of the node to deselect
+     * @returns true if node was found and deselected, false otherwise
+     */
+    deselectNode(nodeId: string): boolean;
+    /**
+     * Get parent node of a given node
+     * @param nodeId - The ID of the node
+     * @returns The parent node if found, null otherwise
+     */
+    getParent(nodeId: string): AXTreeViewNode | null;
+    /**
+     * Get children of a node
+     * @param nodeId - The ID of the parent node
+     * @returns Array of child nodes, or null if node not found
+     */
+    getChildren(nodeId: string): AXTreeViewNode[] | null;
+    /**
+     * Get all root nodes
+     * @returns Array of root nodes
+     */
+    getRootNodes(): AXTreeViewNode[];
+    /**
+     * Get all nodes in a flat array
+     * @returns Array of all nodes in the tree
+     */
+    getAllNodes(): AXTreeViewNode[];
+    /**
+     * Get the path to a node (array of parent IDs from root to node)
+     * @param nodeId - The ID of the node
+     * @returns Array of node IDs representing the path, or empty array if node not found
+     */
+    getNodePath(nodeId: string): string[];
+    /**
+     * Get the level/depth of a node (0 = root level)
+     * @param nodeId - The ID of the node
+     * @returns The level of the node, or -1 if node not found
+     */
+    getNodeLevel(nodeId: string): number;
+    /**
+     * Programmatically move a node to a new parent
+     * @param nodeId - The ID of the node to move
+     * @param newParentId - The ID of the new parent (undefined for root level)
+     * @param index - Optional index to insert at (default: append to end)
+     * @returns true if move was successful, false otherwise
+     */
+    moveNode(nodeId: string, newParentId?: string, index?: number): boolean;
+    /**
+     * Clone a node (creates a deep copy)
+     * @param nodeId - The ID of the node to clone
+     * @returns The cloned node, or null if node not found
+     */
+    cloneNode(nodeId: string): AXTreeViewNode | null;
+    /**
+     * Focus a specific node by ID
+     * @param nodeId - The ID of the node to focus
+     * @returns true if node was found and focused, false otherwise
+     */
+    focusNode(nodeId: string): boolean;
+    /**
+     * Get all expanded nodes
+     * @returns Array of expanded nodes
+     */
+    getExpandedNodes(): AXTreeViewNode[];
+    /**
+     * Get all collapsed nodes that have children
+     * @returns Array of collapsed nodes with children
+     */
+    getCollapsedNodes(): AXTreeViewNode[];
+    /**
+     * Check if a node is expanded
+     * @param nodeId - The ID of the node
+     * @returns true if node is expanded, false otherwise
+     */
+    isNodeExpanded(nodeId: string): boolean;
+    /**
+     * Check if a node is selected
+     * @param nodeId - The ID of the node
+     * @returns true if node is selected, false otherwise
+     */
+    isNodeSelected(nodeId: string): boolean;
+    /**
+     * Check if a node has children
+     * @param nodeId - The ID of the node
+     * @returns true if node has children, false otherwise
+     */
+    hasChildren(nodeId: string): boolean;
+    /**
+     * Get template context for a node
+     */
+    getTemplateContext(node: AXTreeViewNode, level?: number): AXTreeViewItemTemplateContext;
+    /**
+     * Calculate padding-inline for a node based on its level
+     */
+    getNodePaddingInline(level: number): number;
+    /**
+     * Check if node should show expand toggle
+     */
+    shouldShowExpandToggle(node: AXTreeViewNode): boolean;
+    /**
+     * Check if checkboxes should be shown (only for multiple mode)
+     */
+    shouldShowCheckbox(): boolean;
+    /**
+     * Generate unique list ID for each node
+     */
+    getListId(node?: AXTreeViewNode): string;
+    /**
+     * Check if a node is currently focused
+     */
+    isNodeFocused(nodeId: string): boolean;
+    /**
+     * Get ARIA level for a node
+     */
+    getNodeAriaLevel(level: number): number;
+    /**
+     * Get ARIA expanded state for a node
+     */
+    getNodeAriaExpanded(node: AXTreeViewNode): string | null;
+    /**
+     * Get ARIA selected state for a node
+     */
+    getNodeAriaSelected(node: AXTreeViewNode): string | null;
+    /**
+     * Handle node click - for single selection mode or multiple mode with checkOnClick enabled
+     */
+    onNodeClick(node: AXTreeViewNode, event: Event): void;
+    /**
+     * Toggle node expansion state with lazy loading support
+     */
+    toggleNode(node: AXTreeViewNode, event: Event): Promise<void>;
+    /**
+     * Toggle node selection state with indeterminate support (for multiple mode)
+     */
+    toggleSelection(node: AXTreeViewNode, event: AXValueChangedEvent): void;
+    /**
+     * Handle drop events for tree nodes
+     */
+    onDrop(event: AXDropListDroppedEvent, parentNode?: AXTreeViewNode): void;
+    /**
+     * Handle drop events when dropping directly onto a node (to make it a child)
+     */
+    onDropOntoNode(event: AXDropListDroppedEvent, targetNode: AXTreeViewNode): void;
+    /**
+     * Handle node focus event
+     */
+    onNodeFocus(nodeId: string): void;
+    /**
+     * Handle tree container focus - focus first node if none is focused
+     */
+    onTreeFocus(event: FocusEvent): void;
+    /**
+     * Handle tree container blur
+     */
+    onTreeBlur(event: FocusEvent): void;
+    /**
+     * Handle keyboard navigation
+     */
+    handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Load root items when datasource is a function
+     */
+    private loadRootItems;
+    /**
+     * Load children for a node using lazy loading
+     */
+    private loadNodeChildren;
+    /**
+     * Internal method to refresh nodes signal and sync back to datasource if it's an array
+     * Creates new array references for all nested children to ensure reactivity
+     */
+    private refreshNodes;
+    /**
+     * Recursively ensure all children arrays have new references to trigger change detection
+     * Mutates the tree structure by replacing children arrays with new array references
+     */
+    private ensureNewArrayReferences;
+    /**
+     * Handle single selection mode
+     */
+    private handleSingleSelection;
+    /**
+     * Handle multiple selection mode with checkOnClick
+     */
+    private handleMultipleSelection;
+    /**
+     * Get array reference by drop list ID
+     */
+    private getArrayByListId;
+    /**
+     * Find parent node by list ID
+     */
+    private findParentByListId;
+    /**
+     * Check if move operation is allowed based on dragOperationType
+     */
+    private canMoveToParent;
+    /**
+     * Check if reorder operation is allowed based on dragOperationType
+     */
+    private canReorder;
+    /**
+     * Handle reordering within the same list   */
+    private handleReorder;
+    /**
+     * Handle moving between different lists
+     */
+    private handleMove;
+    /**
+     * Emit beforeDrop event and return whether to continue
+     */
+    private emitBeforeDropEvent;
+    /**
+     * Emit drop events based on operation type
+     */
+    private emitDropEvents;
+    /**
+     * Get the currently focused node
+     */
+    private getFocusedNode;
+    /**
+     * Set focus to a node by ID
+     */
+    private focusNodeById;
+    /**
+     * Handle keyboard navigation keys
+     */
+    private handleNavigationKey;
+    /**
+     * Handle Space key selection
+     */
+    private handleSpaceKeySelection;
+    /**
+     * Handle Enter key selection
+     */
+    private handleEnterKeySelection;
+    /**
+     * Handle Ctrl/Cmd + Enter key selection
+     */
+    private handleCtrlEnterSelection;
+    /**
+     * Type guard to check if value is an Event
+     */
+    private isEvent;
+    /**
+     * Handle errors consistently
+     */
+    private handleError;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXTreeViewComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXTreeViewComponent, "ax-tree-view", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "hasCheckboxField": { "alias": "hasCheckboxField"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selectionBehavior": { "alias": "selectionBehavior"; "required": false; "isSignal": true; }; "selectionScope": { "alias": "selectionScope"; "required": false; "isSignal": true; }; "focusNodeEnabled": { "alias": "focusNodeEnabled"; "required": false; "isSignal": true; }; "valueField": { "alias": "valueField"; "required": false; "isSignal": true; }; "textField": { "alias": "textField"; "required": false; "isSignal": true; }; "visibleField": { "alias": "visibleField"; "required": false; "isSignal": true; }; "disableField": { "alias": "disableField"; "required": false; "isSignal": true; }; "hasChildField": { "alias": "hasChildField"; "required": false; "isSignal": true; }; "selectedField": { "alias": "selectedField"; "required": false; "isSignal": true; }; "expandedField": { "alias": "expandedField"; "required": false; "isSignal": true; }; "tooltipField": { "alias": "tooltipField"; "required": false; "isSignal": true; }; "childrenField": { "alias": "childrenField"; "required": false; "isSignal": true; }; "activeField": { "alias": "activeField"; "required": false; "isSignal": true; }; "indeterminateField": { "alias": "indeterminateField"; "required": false; "isSignal": true; }; "parentField": { "alias": "parentField"; "required": false; "isSignal": true; }; "iconField": { "alias": "iconField"; "required": false; "isSignal": true; }; "toggleIcons": { "alias": "toggleIcons"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "showEmptyNodeMassage": { "alias": "showEmptyNodeMassage"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; }; "expandOn": { "alias": "expandOn"; "required": false; "isSignal": true; }; }, { "onSelectionChanged": "onSelectionChanged"; "onItemSelectedChanged": "onItemSelectedChanged"; "onNodeClick": "onNodeClick"; "onCollapsedChanged": "onCollapsedChanged"; "onNodedbClick": "onNodedbClick"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXTreeViewComponent, "ax-tree-view", never, { "datasource": { "alias": "datasource"; "required": true; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "checkChildrenOnSelect": { "alias": "checkChildrenOnSelect"; "required": false; "isSignal": true; }; "intermediateState": { "alias": "intermediateState"; "required": false; "isSignal": true; }; "checkOnClick": { "alias": "checkOnClick"; "required": false; "isSignal": true; }; "dragMode": { "alias": "dragMode"; "required": false; "isSignal": true; }; "dragOperationType": { "alias": "dragOperationType"; "required": false; "isSignal": true; }; "showIcons": { "alias": "showIcons"; "required": false; "isSignal": true; }; "showChildrenBadge": { "alias": "showChildrenBadge"; "required": false; "isSignal": true; }; "expandedIcon": { "alias": "expandedIcon"; "required": false; "isSignal": true; }; "collapsedIcon": { "alias": "collapsedIcon"; "required": false; "isSignal": true; }; "indentSize": { "alias": "indentSize"; "required": false; "isSignal": true; }; "nodeHeight": { "alias": "nodeHeight"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; }, { "datasource": "datasourceChange"; "onBeforeDrop": "onBeforeDrop"; "onNodeToggle": "onNodeToggle"; "onNodeSelect": "onNodeSelect"; "onOrderChange": "onOrderChange"; "onMoveChange": "onMoveChange"; "onItemsChange": "onItemsChange"; }, never, never, true, never>;
 }
 
 declare class AXTreeViewModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXTreeViewModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXTreeViewModule, never, [typeof AXTreeViewComponent, typeof AXTreeViewItemComponent, typeof i3.CommonModule, typeof i4.AXCommonModule, typeof i5.AXDecoratorModule, typeof i6.AXCheckBoxModule, typeof i7.AXFormModule, typeof i8.FormsModule, typeof i9.AXTooltipModule, typeof i10.AXLoadingModule], [typeof AXTreeViewComponent, typeof AXTreeViewItemComponent]>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXTreeViewModule, never, [typeof AXTreeViewComponent], never>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXTreeViewModule>;
 }
 
-export { AXTreeItemClickBaseEvent, AXTreeViewBase, AXTreeViewComponent, AXTreeViewItemComponent, AXTreeViewModule };
-export type { AXTreeViewExpandBehavior, AXTreeViewLook, AXTreeViewOperationMethod, AXTreeViewSelectionBehavior, AXTreeViewSelectionScope };
+/**
+ * Service for tree node operations
+ * Handles all business logic for tree node manipulation
+ */
+declare class AXTreeViewService {
+    private static readonly ROOT_LIST_ID;
+    private static readonly NODE_DROP_PREFIX;
+    private static readonly LIST_PREFIX;
+    /**
+     * Find a node by ID in the tree
+     */
+    findNodeById(nodes: AXTreeViewNode[], id: string): AXTreeViewNode | null;
+    /**
+     * Find parent node of a given node
+     */
+    findParentNode(nodes: AXTreeViewNode[], targetNode: AXTreeViewNode): AXTreeViewNode | undefined;
+    /**
+     * Check if targetNode is a descendant of ancestorNode (or the same node)
+     * Prevents circular references by checking if target exists in ancestor's children tree
+     */
+    isValidDropTarget(movedNode: AXTreeViewNode, targetNode: AXTreeViewNode): boolean;
+    /**
+     * Check if targetNode is a descendant of ancestorNode
+     */
+    private isNodeDescendantOf;
+    /**
+     * Build a flat list of all visible focusable nodes
+     */
+    buildFlatNodeList(nodes: AXTreeViewNode[]): AXTreeViewFlatNode[];
+    /**
+     * Check if node has children
+     */
+    hasChildren(node: AXTreeViewNode): boolean;
+    /**
+     * Check if node can be lazy loaded
+     */
+    canLazyLoad(node: AXTreeViewNode, isLazyDataSource: boolean): boolean;
+    /**
+     * Recursively select/deselect all children
+     */
+    selectAllChildren(children: AXTreeViewNode[], selected: boolean): void;
+    /**
+     * Get selection state of children
+     */
+    getChildrenSelectionState(children: AXTreeViewNode[]): AXTreeViewChildrenSelectionState;
+    /**
+     * Update parent node states based on children selection (with intermediate state support)
+     */
+    updateParentStates(nodes: AXTreeViewNode[], changedNode: AXTreeViewNode, intermediateState: boolean): void;
+    /**
+     * Recursively deselect all nodes
+     */
+    deselectAllNodes(nodes: AXTreeViewNode[]): void;
+    /**
+     * Recursively set selection state for all nodes
+     */
+    setAllSelection(nodes: AXTreeViewNode[], selected: boolean): void;
+    /**
+     * Recursively count selected nodes
+     */
+    countSelected(nodes: AXTreeViewNode[]): number;
+    /**
+     * Recursively collect selected nodes
+     */
+    collectSelected(nodes: AXTreeViewNode[], result: AXTreeViewNode[]): void;
+    /**
+     * Recursively remove selected nodes
+     */
+    removeSelected(nodes: AXTreeViewNode[]): void;
+    /**
+     * Recursively update all parent states in the tree (used after deletion)
+     */
+    updateAllParentStates(nodes: AXTreeViewNode[], intermediateState: boolean): void;
+    /**
+     * Recursively set expanded state (with lazy loading)
+     */
+    setExpandedState(nodes: AXTreeViewNode[], expanded: boolean, isLazyDataSource: boolean, loadNodeChildren: (node: AXTreeViewNode) => Promise<void>): Promise<void>;
+    /**
+     * Get array reference by drop list ID
+     */
+    getArrayByListId(nodes: AXTreeViewNode[], listId: string): AXTreeViewNode[] | null;
+    /**
+     * Find parent node by list ID
+     */
+    findParentByListId(nodes: AXTreeViewNode[], listId: string): AXTreeViewNode | undefined;
+    /**
+     * Generate unique list ID for each node
+     */
+    getListId(node?: AXTreeViewNode): string;
+    /**
+     * Get root list ID constant
+     */
+    getRootListId(): string;
+    /**
+     * Get node drop prefix constant
+     */
+    getNodeDropPrefix(): string;
+    /**
+     * Get list prefix constant
+     */
+    getListPrefix(): string;
+    /**
+     * Get all nodes in a flat array
+     */
+    getAllNodes(nodes: AXTreeViewNode[]): AXTreeViewNode[];
+    /**
+     * Get the path to a node (array of parent nodes from root to node)
+     */
+    getNodePath(nodes: AXTreeViewNode[], nodeId: string): AXTreeViewNode[];
+    /**
+     * Get the level/depth of a node (0 = root level)
+     */
+    getNodeLevel(nodes: AXTreeViewNode[], nodeId: string): number;
+    /**
+     * Get sibling nodes of a given node
+     */
+    getSiblings(nodes: AXTreeViewNode[], nodeId: string): AXTreeViewNode[];
+    /**
+     * Clone a node (creates a deep copy)
+     */
+    cloneNode(node: AXTreeViewNode): AXTreeViewNode;
+    /**
+     * Validate node structure (check for required fields and circular references)
+     */
+    validateNode(node: AXTreeViewNode, visitedIds?: Set<string>): {
+        valid: boolean;
+        errors: string[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXTreeViewService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXTreeViewService>;
+}
+
+export { AXTreeViewComponent, AXTreeViewModule, AXTreeViewService };
+export type { AXTreeViewBeforeDropEvent, AXTreeViewCallback, AXTreeViewChildrenSelectionState, AXTreeViewDataSource, AXTreeViewDragMode, AXTreeViewDragOperationType, AXTreeViewDropEvent, AXTreeViewFlatNode, AXTreeViewItemTemplateContext, AXTreeViewNode, AXTreeViewNodeSelectEvent, AXTreeViewNodeToggleEvent, AXTreeViewSelectMode, AXTreeViewViewLook };