@progress/kendo-angular-treelist 3.1.3-dev.202110041229

package/dist/es/treelist.module.js

@@ -0,0 +1,115 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TreeListComponent } from './treelist.component';
+import { ListComponent } from './rendering/list.component';
+import { LocalizedMessagesDirective } from './localization/localized-messages.directive';
+import { CustomMessagesComponent } from './localization/custom-messages.component';
+import { RowFilterModule } from "./filtering/cell/row-filtering.module";
+import { PagerModule } from "./pager/pager.module";
+import { HeaderModule } from "./rendering/header/header.module";
+import { BodyModule } from "./rendering/body.module";
+import { SharedModule } from './shared.module';
+import { ToolbarTemplateDirective } from "./rendering/toolbar/toolbar-template.directive";
+import { ToolbarComponent } from "./rendering/toolbar/toolbar.component";
+import { ResizeSensorModule } from '@progress/kendo-angular-common';
+import { TemplateEditingDirective } from './editing-directives/template-editing.directive';
+import { ReactiveEditingDirective } from './editing-directives/reactive-editing.directive';
+import { InCellEditingDirective } from './editing-directives/in-cell-editing.directive';
+import { FilterMenuModule } from "./filtering/menu/filter-menu.module";
+import { ColumnMenuModule } from './column-menu/column-menu.module';
+import { HierarchyBindingDirective } from './binding-directives/hierarchy-binding.directive';
+import { FlatBindingDirective } from './binding-directives/flat-binding.directive';
+import { ExpandableDirective } from './expand-state/expandable.directive';
+import { SelectableDirective } from './selection/selectable.directive';
+import { MarqueeDirective } from './selection/marquee.directive';
+import { TreeListSpacerComponent } from './rendering/common/spacer.component';
+var exportedModules = [
+    TreeListComponent,
+    ToolbarTemplateDirective,
+    ToolbarComponent,
+    TreeListSpacerComponent,
+    CustomMessagesComponent,
+    TemplateEditingDirective,
+    ReactiveEditingDirective,
+    InCellEditingDirective,
+    HierarchyBindingDirective,
+    FlatBindingDirective,
+    ExpandableDirective,
+    SelectableDirective
+].concat(SharedModule.exports(), BodyModule.exports(), HeaderModule.exports(), PagerModule.exports(), RowFilterModule.exports(), FilterMenuModule.exports(), ColumnMenuModule.exports());
+var declarations = [
+    TreeListComponent,
+    ListComponent,
+    ToolbarComponent,
+    LocalizedMessagesDirective,
+    CustomMessagesComponent,
+    ToolbarTemplateDirective,
+    TemplateEditingDirective,
+    ReactiveEditingDirective,
+    InCellEditingDirective,
+    HierarchyBindingDirective,
+    FlatBindingDirective,
+    ExpandableDirective,
+    SelectableDirective,
+    MarqueeDirective,
+    TreeListSpacerComponent
+];
+/**
+ * Represents the [NgModule]({{ site.data.urls.angular['ngmoduleapi'] }})
+ * definition for the TreeList component.
+ *
+ * @example
+ *
+ * ```ts-no-run
+ * // Import the TreeList module
+ * import { TreeListModule } from '@progress/kendo-angular-treelist';
+ *
+ * // The browser platform with a compiler
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ *
+ * import { NgModule } from '@angular/core';
+ *
+ * // Import the app component
+ * import { AppComponent } from './app.component';
+ *
+ * // Define the app module
+ * _@NgModule({
+ *     declarations: [AppComponent], // declare app component
+ *     imports:      [BrowserModule, TreeListModule], // import TreeList module
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * // Compile and launch the module
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+var TreeListModule = /** @class */ (function () {
+    function TreeListModule() {
+    }
+    TreeListModule = tslib_1.__decorate([
+        NgModule({
+            declarations: [declarations],
+            exports: [exportedModules],
+            imports: [
+                CommonModule,
+                SharedModule,
+                BodyModule,
+                HeaderModule,
+                PagerModule,
+                RowFilterModule,
+                FilterMenuModule,
+                ResizeSensorModule,
+                ColumnMenuModule
+            ]
+        })
+    ], TreeListModule);
+    return TreeListModule;
+}());
+export { TreeListModule };

package/dist/es/utils.js

@@ -0,0 +1,135 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { InjectionToken } from '@angular/core';
+import { merge, of } from 'rxjs';
+export { isChanged, anyChanged, hasObservers } from '@progress/kendo-angular-common';
+var EMPTY_REGEX = /^\s*$/;
+/**
+ * @hidden
+ */
+export var isPresent = function (value) { return value !== null && value !== undefined; };
+/**
+ * @hidden
+ */
+export var isBlank = function (value) { return value === null || value === undefined; };
+/**
+ * @hidden
+ */
+export var isArray = function (value) { return Array.isArray(value); };
+/**
+ * @hidden
+ */
+export var isTruthy = function (value) { return !!value; };
+/**
+ * @hidden
+ */
+export var isNullOrEmptyString = function (value) { return isBlank(value) || EMPTY_REGEX.test(value); };
+/**
+ * @hidden
+ */
+export var observe = function (list) {
+    return merge(of(list), list.changes);
+};
+/**
+ * @hidden
+ */
+export var isUniversal = function () { return typeof document === 'undefined'; };
+/**
+ * @hidden
+ */
+export var isString = function (value) {
+    return typeof value === 'string';
+};
+/**
+ * @hidden
+ */
+export var isNumber = function (value) { return typeof value === "number" && !isNaN(value); };
+/**
+ * @hidden
+ */
+export var extractFormat = function (format) {
+    if (isString(format) && !isNullOrEmptyString(format) && format.startsWith('{0:')) {
+        return format.slice(3, format.length - 1);
+    }
+    return format;
+};
+/**
+ * @hidden
+ */
+export var not = function (fn) { return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return !fn.apply(null, args);
+}; };
+/**
+ * @hidden
+ */
+export var or = function () {
+    var conditions = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        conditions[_i] = arguments[_i];
+    }
+    return function (value) { return conditions.reduce(function (acc, x) { return acc || x(value); }, false); };
+};
+/**
+ * @hidden
+ */
+export var and = function () {
+    var conditions = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        conditions[_i] = arguments[_i];
+    }
+    return function (value) { return conditions.reduce(function (acc, x) { return acc && x(value); }, true); };
+};
+/**
+ * @hidden
+ */
+export var Skip = new InjectionToken("Skip"); // tslint:disable-line:variable-name
+/**
+ * @hidden
+ */
+export var createPromise = function () {
+    var resolveFn, rejectFn;
+    var promise = new Promise(function (resolve, reject) {
+        resolveFn = function (data) {
+            resolve(data);
+            return promise;
+        };
+        rejectFn = function (data) {
+            reject(data);
+            return promise;
+        };
+    });
+    promise.resolve = resolveFn;
+    promise.reject = rejectFn;
+    return promise;
+};
+/** @hidden */
+export var iterator = getIterator();
+// TODO: Move to kendo-common
+function getIterator() {
+    if (typeof Symbol === 'function' && Symbol.iterator) {
+        return Symbol.iterator;
+    }
+    var keys = Object.getOwnPropertyNames(Map.prototype);
+    var proto = Map.prototype;
+    for (var i = 0; i < keys.length; ++i) {
+        var key = keys[i];
+        if (key !== 'entries' && key !== 'size' && proto[key] === proto.entries) {
+            return key;
+        }
+    }
+}
+var FRAME_DURATION = 1000 / 60;
+var wnd = typeof window !== 'undefined' ? window : {};
+/** @hidden */
+export var requestAnimationFrame = wnd.requestAnimationFrame || wnd.msRequestAnimationFrame || (function (callback) { return setTimeout(callback, FRAME_DURATION); });
+/** @hidden */
+export var cancelAnimationFrame = wnd.cancelAnimationFrame || wnd.msCancelRequestAnimationFrame || clearTimeout;
+/** @hidden */
+export var isColumnEditable = function (column, formGroup) { return column.isEditable !== false &&
+    (column.editTemplate || (formGroup && column.field && formGroup.get(column.field))); };

package/dist/es2015/binding-directives/base-binding.directive.d.ts

@@ -0,0 +1,61 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { SimpleChange, OnInit, OnDestroy, OnChanges, DoCheck } from '@angular/core';
+import { State, CompositeFilterDescriptor, SortDescriptor } from '@progress/kendo-data-query';
+import { DataBoundTreeComponent } from './data-bound-tree-component';
+import { DataStateChangeEvent } from '../data/change-event-args.interface';
+export declare abstract class BaseBindingDirective implements OnInit, OnDestroy, OnChanges, DoCheck {
+    protected component: DataBoundTreeComponent;
+    /**
+     * Defines the descriptors by which the data will be sorted.
+     */
+    sort: SortDescriptor[];
+    /**
+     * Defines the descriptor by which the data will be filtered.
+     */
+    filter: CompositeFilterDescriptor;
+    /**
+     * Defines the descriptor by which the data will be aggregated.
+     */
+    aggregate: any;
+    protected state: State;
+    protected abstract data: any;
+    protected dataChanged: boolean;
+    protected cache: any;
+    protected originalData: any[];
+    protected _aggregate: any;
+    private subscriptions;
+    constructor(component: DataBoundTreeComponent);
+    /**
+     * @hidden
+     */
+    ngOnInit(): void;
+    /**
+     * @hidden
+     */
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    /**
+     * @hidden
+     */
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    /**
+     * @hidden
+     */
+    onStateChange(state: DataStateChangeEvent): void;
+    /**
+     * Clears the directive cache and reloads the component data.
+     */
+    rebind(): void;
+    protected abstract getChildren(item?: any): any;
+    protected abstract itemKey(item: any): any;
+    protected applyState({ sort, filter }: State): void;
+    protected fetchChildren(item?: any): any;
+    protected hasChildren(item: any): boolean;
+    protected filterItems(items: any): any[];
+    protected calculateAggregates(items: any): any;
+}

package/dist/es2015/binding-directives/base-binding.directive.js

@@ -0,0 +1,160 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Input } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { process, aggregateBy } from '@progress/kendo-data-query';
+import { anyChanged } from '../utils';
+export class BaseBindingDirective {
+    constructor(component) {
+        this.component = component;
+        this.state = {};
+        this.cache = new Map();
+        this.originalData = [];
+        this.subscriptions = new Subscription();
+        this.component.fetchChildren = this.fetchChildren.bind(this);
+        this.component.hasChildren = this.hasChildren.bind(this);
+    }
+    /**
+     * Defines the descriptors by which the data will be sorted.
+     */
+    set sort(value) {
+        this.component.sort = this.state.sort = value;
+    }
+    /**
+     * Defines the descriptor by which the data will be filtered.
+     */
+    set filter(value) {
+        this.component.filter = this.state.filter = value;
+    }
+    /**
+     * Defines the descriptor by which the data will be aggregated.
+     */
+    set aggregate(value) {
+        this._aggregate = value;
+    }
+    /**
+     * @hidden
+     */
+    ngOnInit() {
+        this.applyState(this.state);
+        this.subscriptions.add(this.component.dataStateChange
+            .subscribe(this.onStateChange.bind(this)));
+    }
+    /**
+     * @hidden
+     */
+    ngOnDestroy() {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+    }
+    ngDoCheck() {
+        if (this.dataChanged) {
+            this.dataChanged = false;
+            this.rebind();
+        }
+    }
+    /**
+     * @hidden
+     */
+    ngOnChanges(changes) {
+        if (anyChanged(['sort', 'filter', 'aggregate'], changes)) {
+            this.rebind();
+        }
+    }
+    /**
+     * @hidden
+     */
+    onStateChange(state) {
+        this.applyState(state);
+        this.rebind();
+    }
+    /**
+     * Clears the directive cache and reloads the component data.
+     */
+    rebind() {
+        this.cache.clear();
+        this.component.data = this.fetchChildren();
+    }
+    applyState({ sort, filter }) {
+        this.sort = sort;
+        this.filter = filter;
+    }
+    fetchChildren(item) {
+        const key = this.itemKey(item);
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const children = this.getChildren(item);
+        let items = this.filterItems(children);
+        let aggregates;
+        if (items.length) {
+            if (this.state.sort) {
+                items = process(items, { sort: this.state.sort }).data;
+            }
+            if (this._aggregate) {
+                aggregates = this.calculateAggregates(items);
+            }
+        }
+        const result = {
+            data: items,
+            aggregates: aggregates
+        };
+        this.cache.set(key, result);
+        return result;
+    }
+    hasChildren(item) {
+        const items = this.fetchChildren(item).data;
+        return items && items.length > 0;
+    }
+    filterItems(items) {
+        if (this.state.filter) {
+            const filter = {
+                logic: 'or',
+                filters: [this.state.filter, {
+                        operator: (item) => {
+                            const children = this.fetchChildren(item);
+                            return Boolean(children.data && children.data.length);
+                        }
+                    }]
+            };
+            return process(items, {
+                filter: filter
+            }).data;
+        }
+        return items;
+    }
+    calculateAggregates(items) {
+        const list = [];
+        const toAdd = items.slice(0);
+        while (toAdd.length) {
+            const current = toAdd.shift();
+            list.push(current);
+            if (this.hasChildren(current)) {
+                toAdd.push.apply(toAdd, this.fetchChildren(current).data);
+            }
+        }
+        // can accumulate from children aggregates except for average
+        // for average we need the children count that have numeric value
+        // maybe move the aggregates implementation here ???
+        return aggregateBy(list, this._aggregate);
+    }
+}
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Array),
+    tslib_1.__metadata("design:paramtypes", [Array])
+], BaseBindingDirective.prototype, "sort", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], BaseBindingDirective.prototype, "filter", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], BaseBindingDirective.prototype, "aggregate", null);

package/dist/es2015/binding-directives/data-bound-tree-component.d.ts

@@ -0,0 +1,47 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { EventEmitter } from '@angular/core';
+import { CompositeFilterDescriptor, SortDescriptor } from '@progress/kendo-data-query';
+import { Observable } from 'rxjs';
+import { LocalEditService } from '../editing-directives/local-edit.service';
+/**
+ * @hidden
+ *
+ * An injection token used by the data binding directives to interface with the TreeList or the Gantt.
+ */
+export declare abstract class DataBoundTreeComponent {
+    /**
+     * The array of data which will be used to populate the component.
+     */
+    abstract data: any[];
+    /**
+     * Gets or sets the callback function that indicates if a particular item has child items.
+     */
+    abstract hasChildren: (dataItem: any) => boolean;
+    /**
+     * Gets or sets the callback function that retrieves the child items for a particular item.
+     */
+    abstract fetchChildren: (dataItem: any) => Observable<any[]>;
+    /**
+     * Defines the descriptors by which the data will be sorted.
+     */
+    abstract sort: SortDescriptor[];
+    /**
+     * Defines the descriptor by which the data will be filtered.
+     */
+    abstract filter: CompositeFilterDescriptor;
+    /**
+     * Defines the descriptor by which the data will be aggregated.
+     */
+    abstract aggregates?: any;
+    /**
+     * Fires when the data state of the component is changed.
+     */
+    abstract dataStateChange: EventEmitter<any>;
+    /**
+     * Holds the local edit service implementation, configured by the data-binding directives and accessed by the editing ones.
+     */
+    abstract localEditService?: LocalEditService;
+}

package/dist/es2015/binding-directives/data-bound-tree-component.js

@@ -0,0 +1,17 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+/**
+ * @hidden
+ *
+ * An injection token used by the data binding directives to interface with the TreeList or the Gantt.
+ */
+let DataBoundTreeComponent = class DataBoundTreeComponent {
+};
+DataBoundTreeComponent = tslib_1.__decorate([
+    Injectable()
+], DataBoundTreeComponent);
+export { DataBoundTreeComponent };

package/dist/es2015/binding-directives/flat-binding.directive.d.ts

@@ -0,0 +1,36 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { BaseBindingDirective } from './base-binding.directive';
+import { DataBoundTreeComponent } from './data-bound-tree-component';
+/**
+ * A directive which binds the TreeList to an array of objects by using
+ * an ID and parentID field to define the hierarchy.
+ *
+ * The directive encapsulates the in-memory handling of data operations such as
+ * [sorting]({% slug sorting_treelist %}), [aggregation]({% slug treelist_with_aggregates %})
+ * and [filtering]({% slug filtering_treelist %}) ([more information and examples]({% slug databinding_treelist %})).
+ */
+export declare class FlatBindingDirective extends BaseBindingDirective {
+    protected component: DataBoundTreeComponent;
+    /**
+     * The name of the field which contains the identifier of the parent node.
+     */
+    parentIdField: string;
+    /**
+     * The name of the field which contains the unique identifier of the node.
+     */
+    idField: string;
+    /**
+     * The array of data which will be used to populate the TreeList.
+     */
+    data: any[];
+    idGetter: any;
+    idSetter: any;
+    parentIdGetter: any;
+    parentIdSetter: any;
+    constructor(component: DataBoundTreeComponent);
+    protected getChildren(item?: any): any;
+    protected itemKey(item: any): void;
+}

package/dist/es2015/binding-directives/flat-binding.directive.js

@@ -0,0 +1,85 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Directive, Input } from '@angular/core';
+import { getter, setter } from '@progress/kendo-common';
+import { BaseBindingDirective } from './base-binding.directive';
+import { FlatEditService } from '../editing-directives/flat-edit.service';
+import { DataBoundTreeComponent } from './data-bound-tree-component';
+import { isPresent } from '../utils';
+const ROOT_ID = null;
+/**
+ * A directive which binds the TreeList to an array of objects by using
+ * an ID and parentID field to define the hierarchy.
+ *
+ * The directive encapsulates the in-memory handling of data operations such as
+ * [sorting]({% slug sorting_treelist %}), [aggregation]({% slug treelist_with_aggregates %})
+ * and [filtering]({% slug filtering_treelist %}) ([more information and examples]({% slug databinding_treelist %})).
+ */
+let FlatBindingDirective = class FlatBindingDirective extends BaseBindingDirective {
+    constructor(component) {
+        super(component);
+        this.component = component;
+        this.idGetter = getter('id');
+        this.idSetter = setter('id');
+        this.parentIdGetter = getter('parentId');
+        this.parentIdSetter = setter('parentId');
+        component.localEditService = new FlatEditService(this);
+    }
+    /**
+     * The name of the field which contains the identifier of the parent node.
+     */
+    set parentIdField(value) {
+        this.parentIdGetter = getter(value);
+        this.parentIdSetter = setter(value);
+    }
+    /**
+     * The name of the field which contains the unique identifier of the node.
+     */
+    set idField(value) {
+        this.idGetter = getter(value);
+        this.idSetter = setter(value);
+    }
+    /**
+     * The array of data which will be used to populate the TreeList.
+     */
+    set data(value) {
+        this.originalData = value || [];
+        this.dataChanged = true;
+    }
+    getChildren(item) {
+        const id = this.itemKey(item);
+        const children = id === ROOT_ID ?
+            this.originalData.filter(o => !isPresent(this.parentIdGetter(o))) :
+            this.originalData.filter(o => this.parentIdGetter(o) === id);
+        return children;
+    }
+    itemKey(item) {
+        return item ? this.idGetter(item) : ROOT_ID;
+    }
+};
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", String),
+    tslib_1.__metadata("design:paramtypes", [String])
+], FlatBindingDirective.prototype, "parentIdField", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", String),
+    tslib_1.__metadata("design:paramtypes", [String])
+], FlatBindingDirective.prototype, "idField", null);
+tslib_1.__decorate([
+    Input("kendoTreeListFlatBinding"),
+    tslib_1.__metadata("design:type", Array),
+    tslib_1.__metadata("design:paramtypes", [Array])
+], FlatBindingDirective.prototype, "data", null);
+FlatBindingDirective = tslib_1.__decorate([
+    Directive({
+        exportAs: 'kendoTreeListFlatBinding',
+        selector: '[kendoTreeListFlatBinding]'
+    }),
+    tslib_1.__metadata("design:paramtypes", [DataBoundTreeComponent])
+], FlatBindingDirective);
+export { FlatBindingDirective };

package/dist/es2015/binding-directives/hierarchy-binding.directive.d.ts

@@ -0,0 +1,29 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { BaseBindingDirective } from './base-binding.directive';
+import { DataBoundTreeComponent } from './data-bound-tree-component';
+/**
+ * A directive which binds the TreeList to a tree of objects.
+ *
+ * The directive encapsulates the in-memory handling of data operations such as
+ * [sorting]({% slug sorting_treelist %}), [aggregation]({% slug treelist_with_aggregates %})
+ * and [filtering]({% slug filtering_treelist %}) ([more information and examples]({% slug databinding_treelist %})).
+ */
+export declare class HierarchyBindingDirective extends BaseBindingDirective {
+    protected component: DataBoundTreeComponent;
+    /**
+     *  The name of the field which holds the child data items of the node.
+     */
+    childrenField: string;
+    /**
+     * The array of data which will be used to populate the TreeList.
+     */
+    data: any[];
+    childrenGetter: any;
+    childrenSetter: any;
+    constructor(component: DataBoundTreeComponent);
+    protected getChildren(item?: any): any[];
+    protected itemKey(item: any): void;
+}