@acorex/components 21.0.0-next.38 → 21.0.0-next.39

package/number-box/index.d.ts

@@ -29,7 +29,7 @@ declare class AXNumberBoxComponent extends AXNumberBoxComponent_base {
     protected mode: _angular_core.WritableSignal<"digits" | "thousandsSeparator" | "decimal">;
     private input;
     protected stringValue: _angular_core.WritableSignal<string>;
-    protected internalValueChanged(value: number): void;
+    protected internalValueChanged(value: number | undefined): void;
     private plusValue;
     private minusValue;
     protected handleOnKeydownEvent(e: KeyboardEvent): void;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@acorex/components",
-  "version": "21.0.0-next.38",
+  "version": "21.0.0-next.39",
   "peerDependencies": {
-    "@acorex/core": "21.0.0-next.38",
-    "@acorex/cdk": "21.0.0-next.38",
+    "@acorex/core": "21.0.0-next.39",
+    "@acorex/cdk": "21.0.0-next.39",
     "@angular/common": "^20.0.0",
     "@angular/core": "^20.0.0",
     "@angular/cdk": "^20.0.0",

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;
@@ -102,7 +119,37 @@ interface AXTreeViewItemTemplateContext {
 type AXTreeViewViewLook = 'default' | 'card' | 'with-line';
 type AXTreeViewDragMode = 'none' | 'handler' | 'item';
 type AXTreeViewDragOperationType = 'order-only' | 'move' | 'both';
-type AXTreeViewSelectMode = 'single' | 'multiple';
+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
  */
@@ -138,10 +185,8 @@ declare class AXTreeViewComponent {
     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>;
+    /** 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) */
+    readonly selectionBehavior: _angular_core.InputSignal<AXTreeViewSelectionBehavior>;
     /** 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) */
@@ -158,18 +203,42 @@ declare class AXTreeViewComponent {
     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>>;
+    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 +260,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 +382,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 +534,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
      */
@@ -271,6 +567,10 @@ declare class AXTreeViewComponent {
      * Get ARIA selected state for a node
      */
     getNodeAriaSelected(node: AXTreeViewNode): string | null;
+    /**
+     * Emit selection change event with all selected nodes
+     */
+    private emitSelectionChange;
     /**
      * Handle node click - for single selection mode or multiple mode with checkOnClick enabled
      */
@@ -397,7 +697,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; }; "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; }; "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 {
@@ -417,16 +717,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
      */
@@ -434,67 +734,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
      */
@@ -507,9 +807,36 @@ 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): 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, 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;
+    /**
+     * 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, AXTreeViewDragMode, AXTreeViewDragOperationType, AXTreeViewDropEvent, AXTreeViewFlatNode, AXTreeViewItemTemplateContext, AXTreeViewNode, AXTreeViewNodeSelectEvent, AXTreeViewNodeToggleEvent, AXTreeViewSelectMode, AXTreeViewSelectionBehavior, AXTreeViewSelectionChangeEvent, AXTreeViewViewLook };