@acorex/components 20.2.49 → 20.2.51

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": "20.2.49",
+  "version": "20.2.51",
   "peerDependencies": {
-    "@acorex/core": "20.2.49",
-    "@acorex/cdk": "20.2.49",
+    "@acorex/core": "20.2.51",
+    "@acorex/cdk": "20.2.51",
     "@angular/common": "^20.0.0",
     "@angular/core": "^20.0.0",
     "@angular/cdk": "^20.0.0",
@@ -148,14 +148,14 @@
       "types": "./command/index.d.ts",
       "default": "./fesm2022/acorex-components-command.mjs"
     },
-    "./comment": {
-      "types": "./comment/index.d.ts",
-      "default": "./fesm2022/acorex-components-comment.mjs"
-    },
     "./conversation": {
       "types": "./conversation/index.d.ts",
       "default": "./fesm2022/acorex-components-conversation.mjs"
     },
+    "./comment": {
+      "types": "./comment/index.d.ts",
+      "default": "./fesm2022/acorex-components-comment.mjs"
+    },
     "./conversation2": {
       "types": "./conversation2/index.d.ts",
       "default": "./fesm2022/acorex-components-conversation2.mjs"
@@ -228,14 +228,14 @@
       "types": "./form/index.d.ts",
       "default": "./fesm2022/acorex-components-form.mjs"
     },
-    "./grid-layout-builder": {
-      "types": "./grid-layout-builder/index.d.ts",
-      "default": "./fesm2022/acorex-components-grid-layout-builder.mjs"
-    },
     "./image": {
       "types": "./image/index.d.ts",
       "default": "./fesm2022/acorex-components-image.mjs"
     },
+    "./grid-layout-builder": {
+      "types": "./grid-layout-builder/index.d.ts",
+      "default": "./fesm2022/acorex-components-grid-layout-builder.mjs"
+    },
     "./image-editor": {
       "types": "./image-editor/index.d.ts",
       "default": "./fesm2022/acorex-components-image-editor.mjs"
@@ -272,14 +272,14 @@
       "types": "./map/index.d.ts",
       "default": "./fesm2022/acorex-components-map.mjs"
     },
-    "./media-viewer": {
-      "types": "./media-viewer/index.d.ts",
-      "default": "./fesm2022/acorex-components-media-viewer.mjs"
-    },
     "./menu": {
       "types": "./menu/index.d.ts",
       "default": "./fesm2022/acorex-components-menu.mjs"
     },
+    "./media-viewer": {
+      "types": "./media-viewer/index.d.ts",
+      "default": "./fesm2022/acorex-components-media-viewer.mjs"
+    },
     "./modal": {
       "types": "./modal/index.d.ts",
       "default": "./fesm2022/acorex-components-modal.mjs"

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,86 @@ 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>;
+    /** Computed: Returns true when drag handle should be shown */
+    protected readonly shouldShowDragHandle: _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,10 @@ 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
@@ -383,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
      */
@@ -404,7 +568,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;
     /**
@@ -462,7 +630,7 @@ declare class AXTreeViewComponent {
      */
     private handleSingleSelection;
     /**
-     * Handle multiple selection mode with checkOnClick
+     * Handle multiple selection mode when showCheckbox is false (click to toggle)
      */
     private handleMultipleSelection;
     /**
@@ -474,11 +642,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;
     /**
@@ -510,10 +678,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;
     /**
@@ -529,7 +701,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 {
@@ -549,16 +721,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
      */
@@ -566,67 +738,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
      */
@@ -642,27 +814,81 @@ declare class AXTreeViewService {
     /**
      * Get all nodes in a flat array
      */
-    getAllNodes(nodes: AXTreeViewNode[]): AXTreeViewNode[];
+    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[];
+    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): number;
+    getNodeLevel(nodes: AXTreeViewNode[], nodeId: string, idField?: string, childrenField?: string): number;
     /**
      * Get sibling nodes of a given node
      */
-    getSiblings(nodes: AXTreeViewNode[], nodeId: string): AXTreeViewNode[];
+    getSiblings(nodes: AXTreeViewNode[], nodeId: string, idField?: string, childrenField?: string): AXTreeViewNode[];
     /**
      * Clone a node (creates a deep copy)
      */
-    cloneNode(node: AXTreeViewNode): AXTreeViewNode;
+    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>): {
+    validateNode(node: AXTreeViewNode, visitedIds?: Set<string>, idField?: string, titleField?: string, childrenField?: string, childrenCountField?: string): {
         valid: boolean;
         errors: string[];
     };
@@ -671,4 +897,4 @@ declare class 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 };

package/wysiwyg/index.d.ts

@@ -33,8 +33,8 @@ declare class AXWysiwygContainerComponent extends AXWysiwygContainerComponent_ba
     private container;
     private toolbar;
     private platformId;
-    /** @ignore */
-    protected changeHandler(): Promise<void>;
+    private changeHandlerTimer;
+    protected changeHandler(): void;
     /** @ignore */
     ngOnDestroy(): void;
     /**