@acorex/components 20.2.48 → 20.2.50

package/tree-view/index.d.ts

@@ -64,19 +64,33 @@ interface AXTreeViewBeforeDropEvent extends AXEvent {
     currentIndex: number;
     canceled: boolean;
 }
+/**
+ * Tree view node interface.
+ *
+ * By default, nodes should have the following structure:
+ * ```typescript
+ * {
+ *   id: string;              // Unique identifier for the node
+ *   title: string;           // Display text for the node
+ *   tooltip?: string;        // Optional tooltip text
+ *   icon?: string;           // Optional icon class name
+ *   expanded?: boolean;      // Whether the node is expanded
+ *   selected?: boolean;      // Whether the node is selected
+ *   indeterminate?: boolean; // Whether the checkbox is in indeterminate state
+ *   disabled?: boolean;      // Whether the node is disabled
+ *   hidden?: boolean;        // Whether the node is hidden
+ *   children?: AXTreeViewNode[]; // Child nodes
+ *   childrenCount?: number;  // Count of children (for lazy loading)
+ *   data?: unknown;          // Optional custom data
+ * }
+ * ```
+ *
+ * However, you can use custom field names by providing field name inputs
+ * (idField, titleField, etc.) to the component. The component will then
+ * use those field names to access node properties.
+ */
 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;
+    [key: string]: unknown;
 }
 interface AXTreeViewNodeToggleEvent extends AXHtmlEvent {
     node: AXTreeViewNode;
@@ -84,6 +98,9 @@ interface AXTreeViewNodeToggleEvent extends AXHtmlEvent {
 interface AXTreeViewNodeSelectEvent extends AXHtmlEvent {
     node: AXTreeViewNode;
 }
+interface AXTreeViewSelectionChangeEvent extends AXEvent {
+    selectedNodes: AXTreeViewNode[];
+}
 interface AXTreeViewDropEvent extends AXEvent {
     node: AXTreeViewNode;
     previousParent?: AXTreeViewNode;
@@ -100,9 +117,39 @@ interface AXTreeViewItemTemplateContext {
     loading: boolean;
 }
 type AXTreeViewViewLook = 'default' | 'card' | 'with-line';
-type AXTreeViewDragMode = 'none' | 'handler' | 'item';
-type AXTreeViewDragOperationType = 'order-only' | 'move' | 'both';
-type AXTreeViewSelectMode = 'single' | 'multiple';
+type AXTreeViewDragArea = 'handler' | 'item';
+type AXTreeViewDragBehavior = 'none' | 'order-only' | 'move' | 'both';
+type AXTreeViewSelectMode = 'none' | 'single' | 'multiple';
+/**
+ * Selection behavior mode for tree nodes.
+ *
+ * Controls how node selection behaves in the tree:
+ * - **'all'**: No restrictions or special behavior. Any node can be selected independently.
+ * - **'intermediate'**: When children are selected, parent nodes show indeterminate state.
+ *   If all children are selected, parent becomes selected; if some are selected, parent shows indeterminate.
+ * - **'leaf'**: Only leaf nodes (nodes with no children) can be selected. Parent nodes cannot be selected.
+ * - **'nested'**: Selecting a parent node automatically selects all its children (cascading selection).
+ * - **'intermediate-nested'**: Combines both behaviors - selecting parent selects children AND children selection affects parent state.
+ *
+ * @example
+ * ```typescript
+ * // Allow any node to be selected
+ * <ax-tree-view [selectionBehavior]="'all'" />
+ *
+ * // Only leaf nodes can be selected
+ * <ax-tree-view [selectionBehavior]="'leaf'" />
+ *
+ * // Parent shows indeterminate when children are selected
+ * <ax-tree-view [selectionBehavior]="'intermediate'" />
+ *
+ * // Selecting parent selects all children
+ * <ax-tree-view [selectionBehavior]="'nested'" />
+ *
+ * // Both: selecting parent selects children AND children affect parent state
+ * <ax-tree-view [selectionBehavior]="'intermediate-nested'" />
+ * ```
+ */
+type AXTreeViewSelectionBehavior = 'all' | 'intermediate' | 'leaf' | 'nested' | 'intermediate-nested';
 /**
  * Function type for lazy loading tree nodes
  */
@@ -134,42 +181,62 @@ declare class AXTreeViewComponent {
     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) */
+    /** Selection mode: 'single' (click to select) or 'multiple' (checkbox selection). Default: `'single'` */
     readonly selectMode: _angular_core.InputSignal<AXTreeViewSelectMode>;
-    /** Whether to show checkboxes for selection (only applies to multiple mode) */
+    /** Whether to show checkboxes for selection (only applies to multiple mode). Default: `false`. When false and selectMode is not 'none', clicking on a node toggles its selection. */
     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 */
+    /** Selection behavior: 'all' (select anything, no special behavior), 'intermediate' (parent indeterminate state when children selected), 'leaf' (only leaf nodes selectable), 'nested' (selecting parent selects all children). Default: `'intermediate'` */
+    readonly selectionBehavior: _angular_core.InputSignal<AXTreeViewSelectionBehavior>;
+    /** Drag area: 'handler' (drag handle), 'item' (entire item). Default: `'handler'` */
+    readonly dragArea: _angular_core.InputSignal<AXTreeViewDragArea>;
+    /** Drag behavior: 'none' (disabled), 'order-only' (reorder only), 'move' (move between parents), 'both' (allow both). Default: `'none'` */
+    readonly dragBehavior: _angular_core.InputSignal<AXTreeViewDragBehavior>;
+    /** Whether to show icons. Default: `true` */
     readonly showIcons: _angular_core.InputSignal<boolean>;
-    /** Whether to show children count badge */
+    /** Whether to show children count badge. Default: `true` */
     readonly showChildrenBadge: _angular_core.InputSignal<boolean>;
-    /** Custom icon for expanded nodes */
+    /** Custom icon for expanded nodes. Default: `'fa-solid fa-chevron-down'` */
     readonly expandedIcon: _angular_core.InputSignal<string>;
-    /** Custom icon for collapsed nodes */
+    /** Custom icon for collapsed nodes. Default: `'fa-solid fa-chevron-right'` */
     readonly collapsedIcon: _angular_core.InputSignal<string>;
-    /** Indent size in pixels for each level */
+    /** Indent size in pixels for each level. Default: `16` */
     readonly indentSize: _angular_core.InputSignal<number>;
-    /** Node height in pixels */
-    readonly nodeHeight: _angular_core.InputSignal<"compact" | "normal" | "comfortable">;
-    /** Visual style variant */
+    /** Visual style variant. Default: `'default'` */
     readonly look: _angular_core.InputSignal<AXTreeViewViewLook>;
-    /** Custom template for tree items */
-    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<AXTreeViewItemTemplateContext>>;
+    /** Custom template for tree items. Default: `undefined` */
+    readonly nodeTemplate: _angular_core.InputSignal<TemplateRef<AXTreeViewItemTemplateContext>>;
+    /** Field name for node ID. Default: `'id'` */
+    readonly idField: _angular_core.InputSignal<string>;
+    /** Field name for node title. Default: `'title'` */
+    readonly titleField: _angular_core.InputSignal<string>;
+    /** Field name for node tooltip. Default: `'tooltip'` */
+    readonly tooltipField: _angular_core.InputSignal<string>;
+    /** Field name for node icon. Default: `'icon'` */
+    readonly iconField: _angular_core.InputSignal<string>;
+    /** Field name for expanded state. Default: `'expanded'` */
+    readonly expandedField: _angular_core.InputSignal<string>;
+    /** Field name for selected state. Default: `'selected'` */
+    readonly selectedField: _angular_core.InputSignal<string>;
+    /** Field name for indeterminate state. Default: `'indeterminate'` */
+    readonly indeterminateField: _angular_core.InputSignal<string>;
+    /** Field name for disabled state. Default: `'disabled'` */
+    readonly disabledField: _angular_core.InputSignal<string>;
+    /** Field name for hidden state. Default: `'hidden'` */
+    readonly hiddenField: _angular_core.InputSignal<string>;
+    /** Field name for children array. Default: `'children'` */
+    readonly childrenField: _angular_core.InputSignal<string>;
+    /** Field name for children count. Default: `'childrenCount'` */
+    readonly childrenCountField: _angular_core.InputSignal<string>;
+    /** Field name for custom data. Default: `'data'` */
+    readonly dataField: _angular_core.InputSignal<string>;
     /** 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 selection changes - returns all currently selected nodes */
+    readonly onSelectionChange: _angular_core.OutputEmitterRef<AXTreeViewSelectionChangeEvent>;
     /** 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 */
@@ -191,6 +258,84 @@ declare class AXTreeViewComponent {
     private isUpdatingFromDatasource;
     /** Computed to check if datasource is a function */
     private readonly isLazyDataSource;
+    /** Computed: Returns true when selection is restricted to leaf nodes only */
+    protected readonly isLeafOnlyMode: _angular_core.Signal<boolean>;
+    /** Computed: Returns true when selecting a parent automatically selects all its children */
+    protected readonly cascadesToChildren: _angular_core.Signal<boolean>;
+    /** Computed: Returns true when parent nodes show indeterminate state based on children selection */
+    protected readonly hasIntermediateState: _angular_core.Signal<boolean>;
+    /**
+     * Get a property value from a node using the configured field name
+     */
+    protected getNodeProp<T = unknown>(node: AXTreeViewNode, fieldName: string, defaultValue?: T): T;
+    /**
+     * Set a property value on a node using the configured field name
+     */
+    protected setNodeProp(node: AXTreeViewNode, fieldName: string, value: unknown): void;
+    /**
+     * Get node ID
+     */
+    protected getNodeId(node: AXTreeViewNode): string;
+    /**
+     * Get node title
+     */
+    protected getNodeTitle(node: AXTreeViewNode): string;
+    /**
+     * Get node tooltip
+     */
+    protected getNodeTooltip(node: AXTreeViewNode): string | undefined;
+    /**
+     * Get node icon
+     */
+    protected getNodeIcon(node: AXTreeViewNode): string | undefined;
+    /**
+     * Get node expanded state
+     */
+    protected getNodeExpanded(node: AXTreeViewNode): boolean;
+    /**
+     * Set node expanded state
+     */
+    protected setNodeExpanded(node: AXTreeViewNode, value: boolean): void;
+    /**
+     * Get node selected state
+     */
+    protected getNodeSelected(node: AXTreeViewNode): boolean;
+    /**
+     * Set node selected state
+     */
+    protected setNodeSelected(node: AXTreeViewNode, value: boolean): void;
+    /**
+     * Get node indeterminate state
+     */
+    protected getNodeIndeterminate(node: AXTreeViewNode): boolean;
+    /**
+     * Set node indeterminate state
+     */
+    protected setNodeIndeterminate(node: AXTreeViewNode, value: boolean): void;
+    /**
+     * Get node disabled state
+     */
+    protected getNodeDisabled(node: AXTreeViewNode): boolean;
+    /**
+     * Get node hidden state
+     */
+    protected getNodeHidden(node: AXTreeViewNode): boolean;
+    /**
+     * Get node children array
+     */
+    protected getNodeChildren(node: AXTreeViewNode): AXTreeViewNode[] | undefined;
+    /**
+     * Set node children array
+     */
+    protected setNodeChildren(node: AXTreeViewNode, value: AXTreeViewNode[] | undefined): void;
+    /**
+     * Get node children count
+     */
+    protected getNodeChildrenCount(node: AXTreeViewNode): number | undefined;
+    /**
+     * Set node children count
+     */
+    protected setNodeChildrenCount(node: AXTreeViewNode, value: number | undefined): void;
     /**
      * Expand all nodes in the tree (with lazy loading support)
      */
@@ -235,6 +380,142 @@ declare class AXTreeViewComponent {
      * Check if a node is currently loading
      */
     isNodeLoading(nodeId: string): boolean;
+    /**
+     * Get loading state for a node (internal state)
+     */
+    getNodeLoading(node: AXTreeViewNode): 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
      */
@@ -251,6 +532,19 @@ declare class AXTreeViewComponent {
      * Check if checkboxes should be shown (only for multiple mode)
      */
     shouldShowCheckbox(): boolean;
+    /**
+     * Check if a node is a leaf (has no children)
+     * A node is a leaf if it has no loaded children AND no childrenCount (or childrenCount is 0)
+     */
+    isLeafNode(node: AXTreeViewNode): boolean;
+    /**
+     * Check if a node can be selected (considering selectMode and isLeafOnlyMode)
+     */
+    canSelectNode(node: AXTreeViewNode): boolean;
+    /**
+     * Check if checkbox should be shown for a specific node
+     */
+    shouldShowCheckboxForNode(node: AXTreeViewNode): boolean;
     /**
      * Generate unique list ID for each node
      */
@@ -272,7 +566,11 @@ declare class AXTreeViewComponent {
      */
     getNodeAriaSelected(node: AXTreeViewNode): string | null;
     /**
-     * Handle node click - for single selection mode or multiple mode with checkOnClick enabled
+     * Emit selection change event with all selected nodes
+     */
+    private emitSelectionChange;
+    /**
+     * Handle node click - for single selection mode or multiple mode when showCheckbox is false
      */
     onNodeClick(node: AXTreeViewNode, event: Event): void;
     /**
@@ -317,14 +615,20 @@ declare class AXTreeViewComponent {
     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
+     * Handle multiple selection mode when showCheckbox is false (click to toggle)
      */
     private handleMultipleSelection;
     /**
@@ -336,11 +640,11 @@ declare class AXTreeViewComponent {
      */
     private findParentByListId;
     /**
-     * Check if move operation is allowed based on dragOperationType
+     * Check if move operation is allowed based on dragBehavior
      */
     private canMoveToParent;
     /**
-     * Check if reorder operation is allowed based on dragOperationType
+     * Check if reorder operation is allowed based on dragBehavior
      */
     private canReorder;
     /**
@@ -372,10 +676,14 @@ declare class AXTreeViewComponent {
     private handleNavigationKey;
     /**
      * Handle Space key selection
+     * In single mode: replaces selection (deselects all, selects this node)
+     * In multiple mode: toggles selection
      */
     private handleSpaceKeySelection;
     /**
      * Handle Enter key selection
+     * In single mode: replaces selection (deselects all, selects this node)
+     * In multiple mode: replaces selection (deselects all, selects this node and respects selectionBehavior)
      */
     private handleEnterKeySelection;
     /**
@@ -391,7 +699,7 @@ declare class AXTreeViewComponent {
      */
     private handleError;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXTreeViewComponent, 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>;
+    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; }; "selectionBehavior": { "alias": "selectionBehavior"; "required": false; "isSignal": true; }; "dragArea": { "alias": "dragArea"; "required": false; "isSignal": true; }; "dragBehavior": { "alias": "dragBehavior"; "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; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; "isSignal": true; }; "idField": { "alias": "idField"; "required": false; "isSignal": true; }; "titleField": { "alias": "titleField"; "required": false; "isSignal": true; }; "tooltipField": { "alias": "tooltipField"; "required": false; "isSignal": true; }; "iconField": { "alias": "iconField"; "required": false; "isSignal": true; }; "expandedField": { "alias": "expandedField"; "required": false; "isSignal": true; }; "selectedField": { "alias": "selectedField"; "required": false; "isSignal": true; }; "indeterminateField": { "alias": "indeterminateField"; "required": false; "isSignal": true; }; "disabledField": { "alias": "disabledField"; "required": false; "isSignal": true; }; "hiddenField": { "alias": "hiddenField"; "required": false; "isSignal": true; }; "childrenField": { "alias": "childrenField"; "required": false; "isSignal": true; }; "childrenCountField": { "alias": "childrenCountField"; "required": false; "isSignal": true; }; "dataField": { "alias": "dataField"; "required": false; "isSignal": true; }; }, { "datasource": "datasourceChange"; "onBeforeDrop": "onBeforeDrop"; "onNodeToggle": "onNodeToggle"; "onNodeSelect": "onNodeSelect"; "onSelectionChange": "onSelectionChange"; "onOrderChange": "onOrderChange"; "onMoveChange": "onMoveChange"; "onItemsChange": "onItemsChange"; }, never, never, true, never>;
 }
 
 declare class AXTreeViewModule {
@@ -411,16 +719,16 @@ declare class AXTreeViewService {
     /**
      * Find a node by ID in the tree
      */
-    findNodeById(nodes: AXTreeViewNode[], id: string): AXTreeViewNode | null;
+    findNodeById(nodes: AXTreeViewNode[], id: string, idField?: string): AXTreeViewNode | null;
     /**
      * Find parent node of a given node
      */
-    findParentNode(nodes: AXTreeViewNode[], targetNode: AXTreeViewNode): AXTreeViewNode | undefined;
+    findParentNode(nodes: AXTreeViewNode[], targetNode: AXTreeViewNode, idField?: string, childrenField?: string): 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;
+    isValidDropTarget(movedNode: AXTreeViewNode, targetNode: AXTreeViewNode, idField?: string, childrenField?: string): boolean;
     /**
      * Check if targetNode is a descendant of ancestorNode
      */
@@ -428,67 +736,67 @@ declare class AXTreeViewService {
     /**
      * Build a flat list of all visible focusable nodes
      */
-    buildFlatNodeList(nodes: AXTreeViewNode[]): AXTreeViewFlatNode[];
+    buildFlatNodeList(nodes: AXTreeViewNode[], hiddenField?: string, disabledField?: string, expandedField?: string, childrenField?: string): AXTreeViewFlatNode[];
     /**
      * Check if node has children
      */
-    hasChildren(node: AXTreeViewNode): boolean;
+    hasChildren(node: AXTreeViewNode, childrenField?: string): boolean;
     /**
      * Check if node can be lazy loaded
      */
-    canLazyLoad(node: AXTreeViewNode, isLazyDataSource: boolean): boolean;
+    canLazyLoad(node: AXTreeViewNode, isLazyDataSource: boolean, childrenCountField?: string, childrenField?: string): boolean;
     /**
      * Recursively select/deselect all children
      */
-    selectAllChildren(children: AXTreeViewNode[], selected: boolean): void;
+    selectAllChildren(children: AXTreeViewNode[], selected: boolean, selectedField?: string, indeterminateField?: string, childrenField?: string): void;
     /**
      * Get selection state of children
      */
-    getChildrenSelectionState(children: AXTreeViewNode[]): AXTreeViewChildrenSelectionState;
+    getChildrenSelectionState(children: AXTreeViewNode[], selectedField?: string, indeterminateField?: string): AXTreeViewChildrenSelectionState;
     /**
      * Update parent node states based on children selection (with intermediate state support)
      */
-    updateParentStates(nodes: AXTreeViewNode[], changedNode: AXTreeViewNode, intermediateState: boolean): void;
+    updateParentStates(nodes: AXTreeViewNode[], changedNode: AXTreeViewNode, intermediateState: boolean, idField?: string, childrenField?: string, selectedField?: string, indeterminateField?: string): void;
     /**
      * Recursively deselect all nodes
      */
-    deselectAllNodes(nodes: AXTreeViewNode[]): void;
+    deselectAllNodes(nodes: AXTreeViewNode[], selectedField?: string, indeterminateField?: string, childrenField?: string): void;
     /**
      * Recursively set selection state for all nodes
      */
-    setAllSelection(nodes: AXTreeViewNode[], selected: boolean): void;
+    setAllSelection(nodes: AXTreeViewNode[], selected: boolean, selectedField?: string, indeterminateField?: string, childrenField?: string): void;
     /**
      * Recursively count selected nodes
      */
-    countSelected(nodes: AXTreeViewNode[]): number;
+    countSelected(nodes: AXTreeViewNode[], selectedField?: string, childrenField?: string): number;
     /**
      * Recursively collect selected nodes
      */
-    collectSelected(nodes: AXTreeViewNode[], result: AXTreeViewNode[]): void;
+    collectSelected(nodes: AXTreeViewNode[], result: AXTreeViewNode[], selectedField?: string, childrenField?: string): void;
     /**
      * Recursively remove selected nodes
      */
-    removeSelected(nodes: AXTreeViewNode[]): void;
+    removeSelected(nodes: AXTreeViewNode[], selectedField?: string, indeterminateField?: string, childrenField?: string): void;
     /**
      * Recursively update all parent states in the tree (used after deletion)
      */
-    updateAllParentStates(nodes: AXTreeViewNode[], intermediateState: boolean): void;
+    updateAllParentStates(nodes: AXTreeViewNode[], intermediateState: boolean, childrenField?: string, selectedField?: string, indeterminateField?: string): void;
     /**
      * Recursively set expanded state (with lazy loading)
      */
-    setExpandedState(nodes: AXTreeViewNode[], expanded: boolean, isLazyDataSource: boolean, loadNodeChildren: (node: AXTreeViewNode) => Promise<void>): Promise<void>;
+    setExpandedState(nodes: AXTreeViewNode[], expanded: boolean, isLazyDataSource: boolean, loadNodeChildren: (node: AXTreeViewNode) => Promise<void>, expandedField?: string, childrenField?: string, childrenCountField?: string): Promise<void>;
     /**
      * Get array reference by drop list ID
      */
-    getArrayByListId(nodes: AXTreeViewNode[], listId: string): AXTreeViewNode[] | null;
+    getArrayByListId(nodes: AXTreeViewNode[], listId: string, idField?: string, childrenField?: string): AXTreeViewNode[] | null;
     /**
      * Find parent node by list ID
      */
-    findParentByListId(nodes: AXTreeViewNode[], listId: string): AXTreeViewNode | undefined;
+    findParentByListId(nodes: AXTreeViewNode[], listId: string, idField?: string): AXTreeViewNode | undefined;
     /**
      * Generate unique list ID for each node
      */
-    getListId(node?: AXTreeViewNode): string;
+    getListId(node: AXTreeViewNode | undefined, idField?: string): string;
     /**
      * Get root list ID constant
      */
@@ -501,9 +809,90 @@ declare class AXTreeViewService {
      * Get list prefix constant
      */
     getListPrefix(): string;
+    /**
+     * Get all nodes in a flat array
+     */
+    getAllNodes(nodes: AXTreeViewNode[], childrenField?: string): AXTreeViewNode[];
+    /**
+     * Get the path to a node (array of parent nodes from root to node)
+     */
+    getNodePath(nodes: AXTreeViewNode[], nodeId: string, idField?: string, childrenField?: string): AXTreeViewNode[];
+    /**
+     * Get the level/depth of a node (0 = root level)
+     */
+    getNodeLevel(nodes: AXTreeViewNode[], nodeId: string, idField?: string, childrenField?: string): number;
+    /**
+     * Get sibling nodes of a given node
+     */
+    getSiblings(nodes: AXTreeViewNode[], nodeId: string, idField?: string, childrenField?: string): AXTreeViewNode[];
+    /**
+     * Clone a node (creates a deep copy)
+     */
+    cloneNode(node: AXTreeViewNode, idField?: string, titleField?: string, tooltipField?: string, iconField?: string, expandedField?: string, selectedField?: string, indeterminateField?: string, disabledField?: string, hiddenField?: string, childrenCountField?: string, dataField?: string, childrenField?: string): AXTreeViewNode;
+    /**
+     * Move a node to a new parent in the tree
+     * @param nodes - Root nodes array
+     * @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)
+     * @param idField - Field name for node ID
+     * @param childrenField - Field name for children array
+     * @param childrenCountField - Field name for children count
+     * @param expandedField - Field name for expanded state
+     * @returns Object with success status, moved node, previous parent, new parent, and indices
+     */
+    moveNode(nodes: AXTreeViewNode[], nodeId: string, newParentId: string | undefined, index: number | undefined, idField?: string, childrenField?: string, childrenCountField?: string, expandedField?: string): {
+        success: boolean;
+        movedNode?: AXTreeViewNode;
+        previousParent?: AXTreeViewNode;
+        newParent?: AXTreeViewNode;
+        previousIndex: number;
+        currentIndex: number;
+    };
+    /**
+     * Edit/update a node's properties
+     * @param nodes - Root nodes array
+     * @param nodeId - The ID of the node to edit
+     * @param updates - Partial node object with properties to update
+     * @param idField - Field name for node ID
+     * @param childrenField - Field name for children array
+     * @param childrenCountField - Field name for children count
+     * @returns The updated node if found, null otherwise
+     */
+    editNode(nodes: AXTreeViewNode[], nodeId: string, updates: Partial<AXTreeViewNode>, idField?: string, childrenField?: string, childrenCountField?: string): AXTreeViewNode | null;
+    /**
+     * Add a child node to a parent node
+     * @param nodes - Root nodes array
+     * @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)
+     * @param idField - Field name for node ID
+     * @param childrenField - Field name for children array
+     * @param childrenCountField - Field name for children count
+     * @param expandedField - Field name for expanded state
+     * @returns The parent node if found and child was added, null otherwise
+     */
+    addChild(nodes: AXTreeViewNode[], parentId: string, childNode: AXTreeViewNode, index: number | undefined, idField?: string, childrenField?: string, childrenCountField?: string, expandedField?: string): AXTreeViewNode | null;
+    /**
+     * Remove a node from the tree
+     * @param nodes - Root nodes array
+     * @param nodeId - The ID of the node to remove
+     * @param idField - Field name for node ID
+     * @param childrenField - Field name for children array
+     * @param childrenCountField - Field name for children count
+     * @returns The removed node if found, null otherwise
+     */
+    removeNode(nodes: AXTreeViewNode[], nodeId: string, idField?: string, childrenField?: string, childrenCountField?: string): AXTreeViewNode | null;
+    /**
+     * Validate node structure (check for required fields and circular references)
+     */
+    validateNode(node: AXTreeViewNode, visitedIds?: Set<string>, idField?: string, titleField?: string, childrenField?: string, childrenCountField?: 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 };
+export type { AXTreeViewBeforeDropEvent, AXTreeViewCallback, AXTreeViewChildrenSelectionState, AXTreeViewDataSource, AXTreeViewDragArea, AXTreeViewDragBehavior, AXTreeViewDropEvent, AXTreeViewFlatNode, AXTreeViewItemTemplateContext, AXTreeViewNode, AXTreeViewNodeSelectEvent, AXTreeViewNodeToggleEvent, AXTreeViewSelectMode, AXTreeViewSelectionBehavior, AXTreeViewSelectionChangeEvent, AXTreeViewViewLook };