@syncfusion/ej2-navigations 16.4.45 → 16.4.52-46585

package/src/treeview/treeview.d.ts

@@ -4,11 +4,10 @@ import { KeyboardEventArgs } from '@syncfusion/ej2-base';
 import { Effect } from '@syncfusion/ej2-base';
 import { DataManager, Query } from '@syncfusion/ej2-data';
 import { TapEventArgs } from '@syncfusion/ej2-base';
-import { ListBaseOptions, FieldsMapping } from '@syncfusion/ej2-lists';
 import { TreeViewModel, FieldsSettingsModel, NodeAnimationSettingsModel, ActionSettingsModel } from './treeview-model';
-export interface EJ2Instance extends HTMLElement {
-    ej2_instances: Object[];
-}
+/**
+ * Interface for NodeExpand event arguments.
+ */
 export interface NodeExpandEventArgs {
     /**
      * If you want to cancel this event then, set cancel as true. Otherwise, false.
@@ -23,13 +22,19 @@ export interface NodeExpandEventArgs {
      */
     node: HTMLLIElement;
     /**
+     *
      * Return the expanded/collapsed node as JSON object from data source.
+     *
+     *
      */
     nodeData: {
         [key: string]: Object;
     };
     event: MouseEvent | KeyboardEventArgs | TapEventArgs;
 }
+/**
+ * Interface for NodeSelect event arguments.
+ */
 export interface NodeSelectEventArgs {
     /**
      * Return the name of action like select or un-select.
@@ -49,11 +54,15 @@ export interface NodeSelectEventArgs {
     node: HTMLLIElement;
     /**
      * Return the currently selected node as JSON object from data source.
+     *
      */
     nodeData: {
         [key: string]: Object;
     };
 }
+/**
+ * Interface for NodeCheck event arguments.
+ */
 export interface NodeCheckEventArgs {
     /**
      * Return the name of action like check or un-check.
@@ -73,11 +82,15 @@ export interface NodeCheckEventArgs {
     node: HTMLLIElement;
     /**
      * Return the currently checked node as JSON object from data source.
+     *
      */
     data: {
         [key: string]: Object;
     }[];
 }
+/**
+ * Interface for NodeEdit event arguments.
+ */
 export interface NodeEditEventArgs {
     /**
      * If you want to cancel this event then, set cancel as true. Otherwise, false.
@@ -93,6 +106,7 @@ export interface NodeEditEventArgs {
     node: HTMLLIElement;
     /**
      * Return the current node as JSON object from data source.
+     *
      */
     nodeData: {
         [key: string]: Object;
@@ -106,6 +120,9 @@ export interface NodeEditEventArgs {
      */
     innerHtml: string;
 }
+/**
+ * Interface for DragAndDrop event arguments.
+ */
 export interface DragAndDropEventArgs {
     /**
      * If you want to cancel this event then, set cancel as true. Otherwise, false.
@@ -125,16 +142,19 @@ export interface DragAndDropEventArgs {
     draggedNode: HTMLLIElement;
     /**
      * Return the currently dragged node as array of JSON object from data source.
+     *
      */
     draggedNodeData: {
         [key: string]: Object;
     };
     /**
      * Returns the dragged/dropped element's target index position
+     *
      */
     dropIndex: number;
     /**
      * Returns the dragged/dropped element's target level
+     *
      */
     dropLevel: number;
     /**
@@ -155,6 +175,7 @@ export interface DragAndDropEventArgs {
     droppedNode: HTMLLIElement;
     /**
      * Return the dropped node as array of JSON object from data source.
+     *
      */
     droppedNodeData: {
         [key: string]: Object;
@@ -167,7 +188,17 @@ export interface DragAndDropEventArgs {
      * Return boolean value for preventing auto-expanding of parent node.
      */
     preventTargetExpand?: boolean;
+    /**
+     * Denotes the cloned element's drop position relative to the dropped node while dragging. The available values are,
+     *   1. Inside – Denotes that the cloned element will be appended as the child node of the dropped node.
+     *   2. Before - Denotes that the cloned element will be appended before the dropped node.
+     *   3. After - Denotes that the cloned element will be appended after the dropped node.
+     */
+    position: string;
 }
+/**
+ * Interface for DrawNode event arguments.
+ */
 export interface DrawNodeEventArgs {
     /**
      * Return the current rendering node.
@@ -175,6 +206,8 @@ export interface DrawNodeEventArgs {
     node: HTMLLIElement;
     /**
      * Return the current rendering node as JSON object.
+     *
+     * @isGenericType true
      */
     nodeData: {
         [key: string]: Object;
@@ -184,6 +217,9 @@ export interface DrawNodeEventArgs {
      */
     text: string;
 }
+/**
+ * Interface for NodeClick event arguments.
+ */
 export interface NodeClickEventArgs {
     /**
      * Return the actual event.
@@ -194,6 +230,9 @@ export interface NodeClickEventArgs {
      */
     node: HTMLLIElement;
 }
+/**
+ * Interface for NodeKeyPress event arguments.
+ */
 export interface NodeKeyPressEventArgs {
     /**
      * If you want to cancel this event then, set cancel as true. Otherwise, false.
@@ -201,6 +240,7 @@ export interface NodeKeyPressEventArgs {
     cancel: boolean;
     /**
      * Return the actual event.
+     *
      */
     event: KeyboardEventArgs;
     /**
@@ -208,32 +248,85 @@ export interface NodeKeyPressEventArgs {
      */
     node: HTMLLIElement;
 }
+/**
+ * Interface for DataBound event arguments.
+ */
 export interface DataBoundEventArgs {
     /**
      * Return the TreeView data.
+     *
+     * @isGenericType true
      */
     data: {
         [key: string]: Object;
     }[];
 }
+/**
+ * Interface for DataSourceChanged event arguments.
+ */
 export interface DataSourceChangedEventArgs {
     /**
      * Return the updated TreeView data. The data source will be updated after performing some operation like
      * drag and drop, node editing, adding and removing node. If you want to get updated data source after performing operation like
      * selecting/unSelecting, checking/unChecking, expanding/collapsing the node, then you can use getTreeData method.
+     *
+     * @isGenericType true
      */
     data: {
         [key: string]: Object;
     }[];
-}
-export interface ItemCreatedArgs {
-    curData: {
+    /**
+     * Return the action which triggers the event
+     *
+     */
+    action: string;
+    /**
+     * Return the new node data of updated data source
+     *
+     */
+    nodeData: {
         [key: string]: Object;
-    };
-    item: HTMLElement;
-    options: ListBaseOptions;
+    }[];
+}
+/**
+ * Interface that holds the node details.
+ */
+export interface NodeData {
+    /**
+     * Specifies the ID field mapped in dataSource.
+     */
+    id: string;
+    /**
+     * Specifies the mapping field for text displayed as TreeView node's display text.
+     */
     text: string;
-    fields: FieldsMapping;
+    /**
+     * Specifies the parent ID field mapped in dataSource.
+     */
+    parentID: string;
+    /**
+     * Specifies the mapping field for selected state of the TreeView node.
+     */
+    selected: boolean;
+    /**
+     * Specifies the mapping field for expand state of the TreeView node.
+     */
+    expanded: boolean;
+    /**
+     * Specifies the field for checked state of the TreeView node.
+     */
+    isChecked: string;
+    /**
+     * Specifies the mapping field for hasChildren to check whether a node has child nodes or not.
+     */
+    hasChildren: boolean;
+}
+/**
+ * Interface for Failure event arguments
+ */
+export interface FailureEventArgs {
+    /** Defines the error information. */
+    error?: Error;
 }
 /**
  * Configures the fields to bind to the properties of node in the TreeView component.
@@ -245,8 +338,10 @@ export declare class FieldsSettings extends ChildProperty<FieldsSettings> {
     child: string | FieldsSettingsModel;
     /**
      * Specifies the array of JavaScript objects or instance of DataManager to populate the nodes.
+     *
      * @default []
      * @aspDatasourceNullIgnore
+     * @isGenericType true
      */
     dataSource: DataManager | {
         [key: string]: Object;
@@ -284,11 +379,17 @@ export declare class FieldsSettings extends ChildProperty<FieldsSettings> {
      */
     parentID: string;
     /**
-     * Defines the external [`Query`](http://ej2.syncfusion.com/documentation/data/api-query.html)
+     * Defines the external [`Query`](https://ej2.syncfusion.com/documentation/api/data/query/)
      * that will execute along with data processing.
+     *
      * @default null
      */
     query: Query;
+    /**
+     * Specifies whether the node can be selected by users or not
+     * When set to false, the user interaction is prevented for the corresponding node.
+     */
+    selectable: string;
     /**
      * Specifies the mapping field for selected state of the TreeView node.
      */
@@ -310,25 +411,62 @@ export declare class FieldsSettings extends ChildProperty<FieldsSettings> {
      */
     navigateUrl: string;
 }
-export declare type ExpandOnSettings = 'Auto' | 'Click' | 'DblClick' | 'None';
-export declare type SortOrder = 'None' | 'Ascending' | 'Descending';
+/**
+ * Defines the expand type of the TreeView node.
+ */
+export declare type ExpandOnSettings = 
+/**
+* The expand/collapse operation happens when you double-click on the node in desktop.
+*/
+'Auto' | 
+/**
+* The expand/collapse operation happens when you single-click on the node in desktop.
+*/
+'Click' | 
+/**
+* The expand/collapse operation happens when you double-click on the node in desktop.
+*/
+'DblClick' | 
+/**
+* The expand/collapse operation will not happen.
+*/
+'None';
+/**
+ * Defines the sorting order type for TreeView.
+ */
+export declare type SortOrder = 
+/**
+* Indicates that the nodes are sorted in the ascending order.
+*/
+'Ascending' | 
+/**
+*  Indicates that the nodes are sorted in the descending order
+*/
+'Descending' | 
+/**
+* Indicates that the nodes are not sorted.
+*/
+'None';
 /**
  * Configures animation settings for the TreeView component.
  */
 export declare class ActionSettings extends ChildProperty<ActionSettings> {
     /**
      * Specifies the type of animation.
-     * @default : 'SlideDown';
+     *
+     * @default 'SlideDown'
      */
     effect: Effect;
     /**
      * Specifies the duration to animate.
-     * @default : 400;
+     *
+     * @default 400
      */
     duration: number;
     /**
      * Specifies the animation timing function.
-     * @default : 'linear';
+     *
+     * @default 'linear'
      */
     easing: string;
 }
@@ -338,11 +476,13 @@ export declare class ActionSettings extends ChildProperty<ActionSettings> {
 export declare class NodeAnimationSettings extends ChildProperty<NodeAnimationSettings> {
     /**
      * Specifies the animation that applies on collapsing the nodes.
+     *
      * @default { effect: 'SlideUp', duration: 400, easing: 'linear' }
      */
     collapse: ActionSettingsModel;
     /**
      * Specifies the animation that applies on expanding the nodes.
+     *
      * @default { effect: 'SlideDown', duration: 400, easing: 'linear' }
      */
     expand: ActionSettingsModel;
@@ -351,11 +491,11 @@ export declare class NodeAnimationSettings extends ChildProperty<NodeAnimationSe
  * The TreeView component is used to represent hierarchical data in a tree like structure with advanced
  * functions to perform edit, drag and drop, selection with check-box, and more.
  * ```html
- *  <div id="tree"></div>
+ * <div id="tree"></div>
  * ```
  * ```typescript
- *  let treeObj: TreeView = new TreeView();
- *  treeObj.appendTo('#tree');
+ * let treeObj: TreeView = new TreeView();
+ * treeObj.appendTo('#tree');
  * ```
  */
 export declare class TreeView extends Component<HTMLElement> implements INotifyPropertyChanged {
@@ -397,6 +537,9 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private touchClass;
     private editData;
     private editFields;
+    private refreshData;
+    private refreshFields;
+    private isRefreshed;
     private keyConfigs;
     private isInitalExpand;
     private index;
@@ -407,12 +550,28 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private ele;
     private disableNode;
     private onLoaded;
+    private parentNodeCheck;
+    private parentCheckData;
+    private validArr;
+    private validNodes;
+    private expandChildren;
+    private isFieldChange;
+    private changeDataSource;
+    private isOffline;
+    private firstTap;
+    private hasTemplate;
+    private isFirstRender;
+    private isNodeDropped;
+    private isInteracted;
+    private isRightClick;
+    private mouseDownStatus;
     /**
      * Indicates whether the TreeView allows drag and drop of nodes. To drag and drop a node in
      * desktop, hold the mouse on the node, drag it to the target node and drop the node by releasing
      * the mouse. For touch devices, drag and drop operation is performed by touch, touch move
      * and touch end. For more information on drag and drop nodes concept, refer to
-     * [Drag and Drop](../treeview/drag-and-drop/).
+     * [Drag and Drop](../../treeview/drag-and-drop/).
+     *
      * @default false
      */
     allowDragAndDrop: boolean;
@@ -420,73 +579,178 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * Enables or disables editing of the text in the TreeView node. When `allowEditing` property is set
      * to true, the TreeView allows you to edit the node by double clicking the node or by navigating to
      * the node and pressing **F2** key. For more information on node editing, refer
-     * to [Node Editing](../treeview/node-editing/).
+     * to [Node Editing](../../treeview/node-editing/).
+     *
      * @default false
      */
     allowEditing: boolean;
     /**
      * Enables or disables multi-selection of nodes. To select multiple nodes:
-     * * Select the nodes by holding down the CTRL key while clicking on the nodes.
-     * * Select consecutive nodes by clicking the first node to select and hold down the **SHIFT** key
+     * * Select the nodes by holding down the **Ctrl** key while clicking on the nodes.
+     * * Select consecutive nodes by clicking the first node to select and hold down the **Shift** key
      * and click the last node to select.
      *
      * For more information on multi-selection, refer to
-     * [Multi-Selection](../treeview/multiple-selection/).
+     * [Multi-Selection](../../treeview/multiple-selection/).
+     *
      * @default false
      */
     allowMultiSelection: boolean;
+    /**
+     * Enables or disables text wrapping when text exceeds the bounds in the TreeView node.
+     * When the allowTextWrap property is set to true, the TreeView node text content will wrap to the next line
+     * when it exceeds the width of the TreeView node.
+     * The TreeView node height will be adjusted automatically based on the TreeView node content.
+     *
+     * @default false
+     */
+    allowTextWrap: boolean;
     /**
      * Specifies the type of animation applied on expanding and collapsing the nodes along with duration.
+     *
      * @default {expand: { effect: 'SlideDown', duration: 400, easing: 'linear' },
      * collapse: { effect: 'SlideUp', duration: 400, easing: 'linear' }}
      */
     animation: NodeAnimationSettingsModel;
     /**
-     * The `checkedNodes` property is used to set the nodes that need to be checked or
-     * get the ID of nodes that are currently checked in the TreeView component.
+     * The `checkedNodes` property is used to set the nodes that need to be checked.
+     * This property returns the checked nodes ID in the TreeView component.
      * The `checkedNodes` property depends upon the value of `showCheckBox` property.
      * For more information on checkedNodes, refer to
-     * [checkedNodes](../treeview/check-box#checked-nodes).
+     * [checkedNodes](../../treeview/check-box#checked-nodes).
+     * ```html
+     * <div id="tree"></div>
+     * ```
+     * ```typescript
+     * let treeObj: TreeView = new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * showCheckBox: true,
+     * checkedNodes: ['01-01','02']
+     * });
+     * treeObj.appendTo('#tree');
+     * ```
      * @default []
      */
     checkedNodes: string[];
     /**
-     * Specifies the CSS classes to be added with root element of the TreeView to help customize the appearance of the component.
+     * Specifies one or more than one CSS classes to be added with root element of the TreeView to help customize the appearance of the component.
+     * ```html
+     * <div id="tree"></div>
+     * ```
+     * ```typescript
+     * let treeObj: TreeView = new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * cssClass: 'e-custom e-tree'
+     * });
+     * treeObj.appendTo('#tree');
+     * ```
+     * ```css
+     * .e-custom .e-tree {
+     * max-width: 600px;
+     * }
+     * .e-custom .e-list-item {
+     * padding: 10px 0;
+     * }
+     * ```
      * @default ''
      */
     cssClass: string;
+    /**
+     * Specifies a value that indicates whether the TreeView component is disabled or not.
+     * When set to true, user interaction will not be occurred in TreeView.
+     *
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * Specifies the target in which the draggable element can be moved and dropped.
+     * By default, the draggable element movement occurs in the page.
+     * ```html
+     * <div id="tree"></div>
+     * ```
+     * ```typescript
+     * let treeObj: TreeView = new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * dragArea: '.control_wrapper'
+     * });
+     * treeObj.appendTo('#tree');
+     * ```
+     * ```css
+     * .control_wrapper {
+     * width: 500px;
+     * margin-left: 100px;
+     * }
+     * ```
+     * @default null
+     */
+    dragArea: HTMLElement | string;
+    /**
+     * Specifies whether to allow rendering of untrusted HTML values in the TreeView component.
+     * While enable this property, it sanitize suspected untrusted strings and script, and update in the TreeView component.
+     * ```html
+     * <div id="tree"></div>
+     * ```
+     * ```typescript
+     * let treeObj: TreeView = new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * enableHtmlSanitizer: true
+     * });
+     * treeObj.appendTo('#tree');
+     * ```
+     * @default false
+     */
+    enableHtmlSanitizer: boolean;
     /**
      * Enables or disables persisting TreeView state between page reloads. If enabled, following APIs will persist.
      * 1. `selectedNodes` - Represents the nodes that are selected in the TreeView component.
      * 2. `checkedNodes`  - Represents the nodes that are checked in the TreeView component.
      * 3. `expandedNodes` - Represents the nodes that are expanded in the TreeView component.
+     *
      * @default false
      */
     enablePersistence: boolean;
-    /**
-     * Enables or disables RTL mode on the component that displays the content in the right to left direction.
-     * @default false
-     */
-    enableRtl: boolean;
     /**
      * Represents the expanded nodes in the TreeView component. We can set the nodes that need to be
      * expanded or get the ID of the nodes that are currently expanded by using this property.
+     * ```html
+     * <div id='tree'></div>
+     * ```
+     * ```typescript
+     * <script>
+     * var treeObj =  new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * expandedNodes: ['01','01-01','02']
+     * });
+     * treeObj.appendTo('#tree');
+     * </script>
+     * ```
      * @default []
      */
     expandedNodes: string[];
     /**
-     * Specifies the action on which the node expands or collapses. The available actions are,
-     * * `Auto` - In desktop, the expand/collapse operation happens when you double-click the node, and in mobile devices it
-     * happens on single-click.
-     * * `Click` - The expand/collapse operation happens when you single-click the node in both desktop and mobile devices.
-     * * `DblClick` - The expand/collapse operation happens when you double-click the node in both desktop and mobile devices.
-     * * `None` - The expand/collapse operation will not happen when you single-click or double-click the node in both desktop
-     *  and mobile devices.
+     * Specifies the action on which the node expands or collapses.
+     * The available actions :
+     * `Click` - The expand/collapse operation happens when you single-click on the node in desktop.
+     * `DblClick` - The expand/collapse operation happens when you double-click on the node in desktop.
+     * `None` - The expand/collapse operation will not happen.
+     * In mobile devices, the node expand/collapse action happens on single tap.
+     * Here ExpandOn attribute is set to single click property also can use double click and none property.
+     * ```html
+     * <div id="tree"></div>
+     * ```
+     * ```typescript
+     * let treeObj: TreeView = new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * expandOn: 'Click'
+     * });
+     * treeObj.appendTo('#tree');
+     * ```
      * @default 'Auto'
      */
     expandOn: ExpandOnSettings;
     /**
      * Specifies the data source and mapping fields to render TreeView nodes.
+     *
      * @default {id: 'id', text: 'text', dataSource: [], child: 'child', parentID: 'parentID', hasChildren: 'hasChildren',
      *  expanded: 'expanded', htmlAttributes: 'htmlAttributes', iconCss: 'iconCss', imageUrl: 'imageUrl', isChecked: 'isChecked',
      *  query: null, selected: 'selected', tableName: null, tooltip: 'tooltip', navigateUrl: 'navigateUrl'}
@@ -496,22 +760,31 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * On enabling this property, the entire row of the TreeView node gets selected by clicking a node.
      * When disabled only the corresponding node's text gets selected.
      * For more information on Fields concept, refer to
-     * [Fields](../treeview/data-binding#local-data).
+     * [Fields](../../treeview/data-binding#local-data).
+     *
      * @default true
      */
     fullRowSelect: boolean;
     /**
      * By default, the load on demand (Lazy load) is set to true. By disabling this property, all the tree nodes are rendered at the
      * beginning itself.
+     *
      * @default true
      */
     loadOnDemand: boolean;
+    /**
+     * Overrides the global culture and localization value for this component. Default global culture is 'en-US'.
+     *
+     * @private
+     */
+    locale: string;
     /**
      * Specifies a template to render customized content for all the nodes. If the `nodeTemplate` property
      * is set, the template content overrides the displayed node text. The property accepts template string
-     * [template string](http://ej2.syncfusion.com/documentation/base/template-engine.html)
+     * [template string](https://ej2.syncfusion.com/documentation/common/template-engine/)
      * or HTML element ID holding the content. For more information on template concept, refer to
-     * [Template](../treeview/template/).
+     * [Template](../../treeview/template/).
+     *
      * @default null
      */
     nodeTemplate: string;
@@ -521,7 +794,18 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * On enabling `allowMultiSelection` property we can select multiple nodes and on disabling
      * it we can select only a single node.
      * For more information on selectedNodes, refer to
-     * [selectedNodes](../treeview/multiple-selection#selected-nodes).
+     * [selectedNodes](../../treeview/multiple-selection#selected-nodes).
+     * ```html
+     * <div id="tree"></div>
+     * ```
+     * ```typescript
+     * let treeObj: TreeView = new TreeView({
+     * fields: { dataSource: hierarchicalData, id: 'id', text: 'name', child: 'subChild' },
+     * allowMultiSelection: true,
+     * selectedNodes: ['01','02']
+     * });
+     * treeObj.appendTo('#tree');
+     * ```
      * @default []
      */
     selectedNodes: string[];
@@ -531,150 +815,194 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * * `None` - The nodes are not sorted.
      * * `Ascending` - The nodes are sorted in the ascending order.
      * * `Descending` - The nodes are sorted in the ascending order.
+     *
      * @default 'None'
      */
     sortOrder: SortOrder;
     /**
      * Indicates that the nodes will display CheckBoxes in the TreeView.
      * The CheckBox will be displayed next to the expand/collapse icon of the node. For more information on CheckBoxes, refer to
-     * [CheckBox](../treeview/check-box/).
+     * [CheckBox](../../treeview/check-box/).
+     *
      * @default false
      */
     showCheckBox: boolean;
     /**
      * Allow us to specify the parent and child nodes to get auto check while we check or uncheck a node.
+     *
      * @default true
      */
     autoCheck: boolean;
     /**
-     * Triggers when the TreeView control is created successfully.
+     * If this property is set to true, then the entire TreeView node will be navigate-able instead of text element.
+     *
+     * @default false
+     */
+    fullRowNavigable: boolean;
+    /**
+     * Event callback that is raised while any TreeView action failed to fetch the desired results.
+     *
+     * @event
+     */
+    actionFailure: EmitType<FailureEventArgs>;
+    /**
+     * Event callback that is raised when the TreeView component is created successfully.
+     *
      * @event
      */
     created: EmitType<Object>;
     /**
-     * Triggers when data source is populated in the TreeView.
+     * Event callback that is raised when data source is populated in the TreeView.
+     *
      * @event
      */
     dataBound: EmitType<DataBoundEventArgs>;
     /**
-     * Triggers when data source is changed in the TreeView. The data source will be changed after performing some operation like
+     * Event callback that is raised when data source is changed in the TreeView. The data source will be changed after performing some operation like
      * drag and drop, node editing, adding and removing node.
+     *
      * @event
      */
     dataSourceChanged: EmitType<DataSourceChangedEventArgs>;
     /**
-     * Triggers before the TreeView node is appended to the TreeView element. It helps to customize specific nodes.
+     * Event callback that is raised before the TreeView node is appended to the TreeView element. It helps to customize specific nodes.
+     *
      * @event
      */
     drawNode: EmitType<DrawNodeEventArgs>;
     /**
-     * Triggers when the TreeView control is destroyed successfully.
+     * Event callback that is raised when the TreeView control is destroyed successfully.
+     *
      * @event
      */
     destroyed: EmitType<Object>;
     /**
-     * Triggers when key press is successful. It helps to customize the operations at key press.
+     * Event callback that is raised when key press is successful. It helps to customize the operations at key press.
+     *
      * @event
      */
     keyPress: EmitType<NodeKeyPressEventArgs>;
     /**
-     * Triggers when the TreeView node is checked/unchecked successfully.
+     * Event callback that is raised when the TreeView node is checked/unchecked successfully.
+     *
      * @event
      */
     nodeChecked: EmitType<NodeCheckEventArgs>;
     /**
-     * Triggers before the TreeView node is to be checked/unchecked.
+     * Event callback that is raised before the TreeView node is to be checked/unchecked.
+     *
      * @event
      */
     nodeChecking: EmitType<NodeCheckEventArgs>;
     /**
-     * Triggers when the TreeView node is clicked successfully.
+     * Event callback that is raised when the TreeView node is clicked successfully.
+     *
      * @event
      */
     nodeClicked: EmitType<NodeClickEventArgs>;
     /**
-     * Triggers when the TreeView node collapses successfully.
+     * Event callback that is raised when the TreeView node collapses successfully.
+     *
      * @event
      */
     nodeCollapsed: EmitType<NodeExpandEventArgs>;
     /**
-     * Triggers before the TreeView node collapses.
+     * Event callback that is raised before the TreeView node collapses.
+     *
      * @event
      */
     nodeCollapsing: EmitType<NodeExpandEventArgs>;
     /**
-     * Triggers when the TreeView node is dragged (moved) continuously.
+     * Event callback that is raised when the TreeView node is dragged (moved) continuously.
+     *
+     * @deprecated
      * @event
      */
     nodeDragging: EmitType<DragAndDropEventArgs>;
     /**
-     * Triggers when the TreeView node drag (move) starts.
+     * Event callback that is raised when the TreeView node drag (move) starts.
+     *
      * @event
      */
     nodeDragStart: EmitType<DragAndDropEventArgs>;
     /**
-     * Triggers when the TreeView node drag (move) is stopped.
+     * Event callback that is raised when the TreeView node drag (move) is stopped.
+     *
      * @event
      */
     nodeDragStop: EmitType<DragAndDropEventArgs>;
     /**
-     * Triggers when the TreeView node is dropped on target element successfully.
+     * Event callback that is raised when the TreeView node is dropped on target element successfully.
+     *
      * @event
      */
     nodeDropped: EmitType<DragAndDropEventArgs>;
     /**
-     * Triggers when the TreeView node is renamed successfully.
+     * Event callback that is raised when the TreeView node is renamed successfully.
+     *
      * @event
      */
     nodeEdited: EmitType<NodeEditEventArgs>;
     /**
-     * Triggers before the TreeView node is renamed.
+     * Event callback that is raised before the TreeView node is renamed.
+     *
      * @event
      */
     nodeEditing: EmitType<NodeEditEventArgs>;
     /**
-     * Triggers when the TreeView node expands successfully.
+     * Event callback that is raised when the TreeView node expands successfully.
+     *
      * @event
      */
     nodeExpanded: EmitType<NodeExpandEventArgs>;
     /**
-     * Triggers before the TreeView node is to be expanded.
+     * Event callback that is raised before the TreeView node is to be expanded.
+     *
      * @event
      */
     nodeExpanding: EmitType<NodeExpandEventArgs>;
     /**
-     * Triggers when the TreeView node is selected/unselected successfully.
+     * Event callback that is raised when the TreeView node is selected/unselected successfully.
+     *
      * @event
      */
     nodeSelected: EmitType<NodeSelectEventArgs>;
     /**
-     * Triggers before the TreeView node is selected/unselected.
+     * Event callback that is raised before the TreeView node is selected/unselected.
+     *
      * @event
      */
     nodeSelecting: EmitType<NodeSelectEventArgs>;
     constructor(options?: TreeViewModel, element?: string | HTMLElement);
     /**
      * Get component name.
-     * @returns string
+     *
+     * @returns {string} - returns module name.
      * @private
      */
     getModuleName(): string;
     /**
      * Initialize the event handler
+     *
+     * @returns {void}
      */
     protected preRender(): void;
     /**
      * Get the properties to be maintained in the persisted state.
-     * @returns string
+     *
+     * @returns {string} - returns the persisted data
      * @hidden
      */
     getPersistData(): string;
     /**
      * To Initialize the control rendering
+     *
      * @private
+     * @returns {void}
      */
     protected render(): void;
     private initialize;
+    private setDisabledMode;
     private setEnableRtl;
     private setRipple;
     private setFullRow;
@@ -685,6 +1013,26 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private getType;
     private setRootData;
     private renderItems;
+    /**
+     * Update the checkedNodes from datasource at initial rendering
+     */
+    private updateCheckedStateFromDS;
+    /**
+     * To check whether the list data has sub child and to change the parent check state accordingly
+     */
+    private getCheckedNodeDetails;
+    /**
+     * Update the checkedNodes and parent state when all the child Nodes are in checkedstate at initial rendering
+     */
+    private updateParentCheckState;
+    /**
+     * Change the parent to indeterminate state whenever the child is in checked state which is not rendered in DOM
+     */
+    private checkIndeterminateState;
+    /**
+     * Update the checkedNodes for child and subchild from datasource (hierarchical datasource) at initial rendering
+     */
+    private updateChildCheckState;
     private beforeNodeCreate;
     private frameMouseHandler;
     private addActionClass;
@@ -697,11 +1045,28 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private ensureParentCheckState;
     private ensureChildCheckState;
     private doCheckBoxAction;
+    private updateFieldChecked;
+    /**
+     * Changes the parent and child  check state while changing the checkedNodes via setmodel
+     */
+    private dynamicCheckState;
+    /**
+     * updates the parent and child  check state while changing the checkedNodes via setmodel for listData
+     */
+    private updateIndeterminate;
+    /**
+     * updates the parent and child  check state while changing the checkedNodes via setmodel for hierarchical data
+     */
+    private updateChildIndeterminate;
     private changeState;
+    private nodeCheckAction;
     private addCheck;
     private removeCheck;
     private getCheckEvent;
     private finalize;
+    private setTextWrap;
+    private updateWrap;
+    private calculateWrap;
     private doExpandAction;
     private expandGivenNodes;
     private expandCallback;
@@ -709,13 +1074,13 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private doSelectionAction;
     private selectGivenNodes;
     private clickHandler;
-    private nodeCheckingEvent;
     private nodeCheckedEvent;
     private triggerClickEvent;
     private expandNode;
     private expandedNode;
     private addExpand;
     private collapseNode;
+    private nodeCollapseAction;
     private collapsedNode;
     private removeExpand;
     private disableExpandAttr;
@@ -724,6 +1089,10 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private renderChildNodes;
     private loadChild;
     private disableTreeNodes;
+    /**
+     * Sets the child Item in selectedState while rendering the child node
+     */
+    private setSelectionForChildNodes;
     private ensureCheckNode;
     private getFields;
     private getChildFields;
@@ -734,7 +1103,9 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private toggleSelect;
     private isActive;
     private selectNode;
+    private nodeSelectAction;
     private unselectNode;
+    private nodeUnselectAction;
     private setFocusElement;
     private addSelect;
     private removeSelect;
@@ -744,6 +1115,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private expandHandler;
     private expandCollapseAction;
     private expandAction;
+    private nodeExpandAction;
     private keyActionHandler;
     private navigateToFocus;
     private isVisibleInViewport;
@@ -751,6 +1123,16 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private shiftKeySelect;
     private checkNode;
     private validateCheckNode;
+    private nodeCheckingAction;
+    /**
+     * Update checkedNodes when UI interaction happens before the child node renders in DOM
+     */
+    private ensureStateChange;
+    private getChildItems;
+    /**
+     * Update checkedNodes when UI interaction happens before the child node renders in DOM for hierarchical DS
+     */
+    private childStateChange;
     private allCheckNode;
     private openNode;
     private navigateNode;
@@ -772,13 +1154,17 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private getNodeData;
     private getText;
     private getExpandEvent;
+    private renderNodeTemplate;
+    private destroyTemplate;
     private reRenderNodes;
     private setCssClass;
     private editingHandler;
     private createTextbox;
+    private renderTextBox;
     private updateOldText;
     private inputFocusOut;
     private appendNewText;
+    private updateText;
     private getElement;
     private getId;
     private getEditEvent;
@@ -786,7 +1172,9 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private getChildNodeObject;
     private setDragAndDrop;
     private initializeDrag;
+    private dragCancelAction;
     private dragAction;
+    private appendIndicator;
     private dropAction;
     private appendNode;
     private dropAsSiblingNode;
@@ -823,6 +1211,9 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private addChildData;
     private doDisableAction;
     private doEnableAction;
+    private nodeType;
+    private checkValidId;
+    private filterNestedChild;
     private setTouchClass;
     private updatePersistProp;
     private removeField;
@@ -834,16 +1225,35 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private wireEditingEvents;
     private wireClickEvent;
     private wireExpandOnEvent;
-    private mouseDownStatus;
     private mouseDownHandler;
     private preventContextMenu;
     private wireEvents;
     private unWireEvents;
     private parents;
+    private isDoubleTapped;
     private isDescendant;
     protected showSpinner(element: HTMLElement): void;
     protected hideSpinner(element: HTMLElement): void;
     private setCheckedNodes;
+    /**
+     * Checks whether the checkedNodes entered are valid and sets the valid checkedNodes while changing via setmodel
+     */
+    private setValidCheckedNode;
+    /**
+     * Checks whether the checkedNodes entered are valid and sets the valid checkedNodes while changing via setmodel(for hierarchical DS)
+     */
+    private setChildCheckState;
+    private setIndeterminate;
+    private updatePosition;
+    private updateChildPosition;
+    private dynamicState;
+    private crudOperation;
+    private deleteSuccess;
+    private editSucess;
+    private addSuccess;
+    private dmFailure;
+    private updatePreviousText;
+    private getHierarchicalParentId;
     /**
      * Called internally if any of the property value changed.
      * @param  {TreeView} newProp
@@ -868,8 +1278,8 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
         [key: string]: Object;
     }[], target?: string | Element, index?: number, preventTargetExpand?: boolean): void;
     /**
-     * Instead of clicking on the TreeView node for editing, we can enable it by using
-     * `beginEdit` property. On passing the node ID or element through this property, the edit textBox
+     * Editing can also be enabled by using the `beginEdit` property, instead of clicking on the
+     * TreeView node. On passing the node ID or element through this property, the edit textBox
      * will be created for the particular node thus allowing us to edit it.
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView node.
      */
@@ -920,7 +1330,11 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      */
     getAllCheckedNodes(): string[];
     /**
-     * Get the node's data such as id, text, parentID, selected, isChecked, and expanded by passing the node element or it's ID.
+    * Gets all the disabled nodes including child, whether it is loaded or not.
+    */
+    getDisabledNodes(): string[];
+    /**
+     * Gets the node's data such as id, text, parentID, selected, isChecked, and expanded by passing the node element or it's ID.
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView node.
      */
     getNode(node: string | Element): {
@@ -933,6 +1347,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * of the corresponding node otherwise it will return the entire updated data source of TreeView.
      * * The updated data source also contains custom attributes if you specified in data source.
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView node.
+     * @isGenericType true
      */
     getTreeData(node?: string | Element): {
         [key: string]: Object;
@@ -945,6 +1360,14 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * @param { boolean } preventTargetExpand - If set to true, the target parent node will be prevented from auto expanding.
      */
     moveNodes(sourceNodes: string[] | Element[], target: string | Element, index: number, preventTargetExpand?: boolean): void;
+    /**
+     * Refreshes a particular node of the TreeView.
+     * @param  {string | Element} target - Specifies the ID of TreeView node or TreeView node as target element.
+     * @param  {{ [key: string]: Object }[]} newData - Specifies the new data of TreeView node.
+     */
+    refreshNode(target: string | Element, newData: {
+        [key: string]: Object;
+    }[]): void;
     /**
      * Removes the collection of TreeView nodes by passing the array of node details as argument to this method.
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView node.