/**----------------------------------------------------------------------------------------- * Copyright © 2025 Progress Software Corporation. All rights reserved. * Licensed under commercial license. See LICENSE.md in the project root for more information *-------------------------------------------------------------------------------------------*/ import { EventEmitter, OnChanges, QueryList, SimpleChanges, Renderer2, AfterContentInit, OnDestroy, ElementRef, NgZone } from '@angular/core'; import { FormGroup } from '@angular/forms'; import { TreeListComponent, DataBoundTreeComponent, ExpandableTreeComponent, SelectionChangeEvent as TreeListSelectionChangeEvent, CellClickEvent as TreeListCellClickEvent } from '@progress/kendo-angular-treelist'; import { CompositeFilterDescriptor, SortDescriptor } from '@progress/kendo-data-query'; import { Day } from '@progress/kendo-date-math'; import { Observable } from 'rxjs'; import { GanttTimelineComponent } from './timeline/gantt-timeline.component'; import { GanttColumnBase } from './columns/columns'; import { DataStateChangeEvent, ColumnMenuSettings, RowClassFn, TaskClassFn, ColumnVisibilityChangeEvent, ColumnResizeEvent, ColumnLockedChangeEvent, ColumnReorderEvent, ColumnReorderConfig, GanttTaskModelFields, GanttDependencyModelFields, SortSettings, CellClickEvent, TaskClickEvent, DependencyAddEvent, TaskDeleteEvent } from './models/models'; import { LocalizationService } from '@progress/kendo-angular-l10n'; import { TimelineViewService } from './timeline/timeline-view.service'; import { TimelineViewType } from './models/timeline-view'; import { TimelineBaseViewService } from './timeline/timeline-base-view.service'; import { ScrollSyncService } from './scrolling/scroll-sync.service'; import { DependencyDomService } from './dependencies/dependency-dom.service'; import { MappingService } from './common/mapping.service'; import { OptionChangesService } from './common/option-changes.service'; import { EditService } from './editing/edit.service'; import { NavigationService } from './navigation/navigation.service'; import { TimelinePaneOptions, TreeListPaneOptions } from './models/splitter-pane-options.interface'; import { GanttTaskTemplateDirective } from './template-directives/task-template.directive'; import { GanttSummaryTaskTemplateDirective } from './template-directives/summary-task-template.directive'; import { GanttTaskContentTemplateDirective } from './template-directives/task-content-template.directive'; import { ToolbarTemplateDirective } from './toolbar/toolbar-template.directive'; import { ToolbarSettings } from './models/toolbar-settings'; import { ExpandEvent } from './expanded-state/expand-event'; import { ViewBase } from './timeline/view-base'; import { SelectionChangeEvent } from './selection/selection-change-event'; import { TaskEditEvent } from './models/events/task-edit-event.interface'; import { CellCloseEvent } from './models/events/cell-close-event.interface'; import { CellCloseEvent as TreeListCellCloseEvent } from '@progress/kendo-angular-treelist'; import { TaskAddEvent } from './models/events/task-add-event.interface'; import { ViewItem } from './models/view-item.interface'; import { DragScrollSettings } from './scrolling/drag-scroll-settings'; import { FilterableSettings } from './models/filterable-settings'; import { CurrentTimeMarkerService } from './timeline/current-time-marker.service'; import { CurrentTimeSettings } from './models/current-time-settings.interface'; import { GanttTaskTooltipTemplateDirective } from './template-directives/task-tooltip-template.directive'; import { TaskTooltipOptions } from './models/tooltip-options.interface'; import { IntlService } from '@progress/kendo-angular-intl'; import * as i0 from "@angular/core"; /** * Represents the Kendo UI Gantt component for Angular. * * @example * ```ts-preview * _@Component({ * selector: 'my-app', * template: ` * * * * * * * * * ` * }) * class AppComponent { * public data: Task[] = [{ * id: 7, title: 'Validation and R&D', start: new Date('2014-06-02T00:00:00.000Z'), * end: new Date('2014-06-19T00:00:00.000Z'), completionRatio: 0.45708333333333334, * subtasks: [ * { id: 18, title: 'Project Kickoff', start: new Date('2014-06-02T00:00:00.000Z'), * end: new Date('2014-06-02T00:00:00.000Z'), completionRatio: 0.23 }, * { id: 11, title: 'Research', start: new Date('2014-06-02T00:00:00.000Z'), * end: new Date('2014-06-07T00:00:00.000Z'), completionRatio: 0.5766666666666667, * subtasks: [ * { id: 19, title: 'Validation', start: new Date('2014-06-02T00:00:00.000Z'), * end: new Date('2014-06-04T00:00:00.000Z'), completionRatio: 0.25 }, * { id: 39, title: 'Specification', start: new Date('2014-06-04T00:00:00.000Z'), * end: new Date('2014-06-07T00:00:00.000Z'), completionRatio: 0.66 }] * }, { id: 13, title: 'Implementation', start: new Date('2014-06-08T00:00:00.000Z'), * end: new Date('2014-06-19T00:00:00.000Z'), completionRatio: 0.77, * subtasks: [ * { id: 24, title: 'Prototype', start: new Date('2014-06-08T00:00:00.000Z'), * end: new Date('2014-06-14T00:00:00.000Z'), completionRatio: 0.77 }, * { id: 29, title: 'UI and Interaction', start: new Date('2014-06-14T00:00:00.000Z'), * end: new Date('2014-06-19T00:00:00.000Z'), completionRatio: 0.6 }] * }, { id: 17, title: 'Release', start: new Date('2014-06-19T00:00:00.000Z'), * end: new Date('2014-06-19T00:00:00.000Z'), completionRatio: 0 }] * }]; * * public dependencies: GanttDependency[] = [ * { id: 528, fromId: 18, toId: 19, type: DependencyType.FS }, * { id: 529, fromId: 19, toId: 39, type: DependencyType.FS }, * { id: 535, fromId: 24, toId: 29, type: DependencyType.FS }, * { id: 551, fromId: 13, toId: 29, type: DependencyType.FF }, * { id: 777, fromId: 7, toId: 11, type: DependencyType.SF }, * { id: 556, fromId: 39, toId: 24, type: DependencyType.FS }, * { id: 546, fromId: 29, toId: 17, type: DependencyType.FS }, * ]; * } * ``` */ export declare class GanttComponent implements AfterContentInit, OnChanges, OnDestroy, DataBoundTreeComponent, ExpandableTreeComponent { private timelineViewService; private scrollSyncService; private renderer; private mapper; private optionChangesService; private dependencyDomService; private editService; private localizationService; hostElement: ElementRef; private zone; private navigation; private currentTimeMarkerService; private intlService; localeId: string; treeList: TreeListComponent; timeline: GanttTimelineComponent; /** * @hidden * * Queries the template for a task content template declaration. * In newer Angular versions the ngIf-ed value gets evaluated after the static query is resolved. * Therefore the `static` property needs to be set to `false`. */ taskContentTemplate: GanttTaskContentTemplateDirective; /** * @hidden * * Queries the template for a task template declaration. * In newer Angular versions the ngIf-ed value gets evaluated after the static query is resolved. * Therefore the `static` property needs to be set to `false`. */ taskTemplate: GanttTaskTemplateDirective; /** * @hidden * * Queries the template for a task tooltip template declaration. * In newer Angular versions the ngIf-ed value gets evaluated after the static query is resolved. * Therefore the `static` property needs to be set to `false`. */ taskTooltipTemplate: GanttTaskTooltipTemplateDirective; /** * @hidden * * Queries the template for a task summary template declaration. * In newer Angular versions the ngIf-ed value gets evaluated after the static query is resolved. * Therefore the `static` property needs to be set to `false`. */ summaryTaskTemplate: GanttSummaryTaskTemplateDirective; toolbarTemplateChildren: QueryList; get toolbarTemplate(): ToolbarTemplateDirective; set toolbarTemplate(customToolbarTemplate: ToolbarTemplateDirective); /** * @hidden */ roleDescription: string; get hostRoleDescriptionAttr(): string; /** * @hidden */ role: string; get hostRoleAttr(): string; hostClasses: boolean; get dir(): string; /** * A query list of all declared columns. */ set columns(columns: QueryList); get columns(): QueryList; /** * Sets the fields which will be used to extract the task data from the provided `data` array items. * The `id` field is also used as a TreeList data item unique identifier (defaults to `'id'`). * * > If no object is provided, the Gantt task data items will have to conform to the [`GanttTask`]({% slug api_gantt_gantttask %}) interface. */ set taskModelFields(fields: GanttTaskModelFields); /** * Sets the fields which will be used to extract the dependency data from the provided `dependencies` array items. * * > If no object is provided, the Gantt dependency data items will have to conform to the [`GanttDependency`]({% slug api_gantt_ganttdependency %}) interface. */ set dependencyModelFields(fields: GanttDependencyModelFields); /** * A query list of all declared views. */ views: QueryList; /** * The active timeline view. * @default 'week' */ set activeView(view: TimelineViewType); get activeView(): TimelineViewType; /** * @hidden * */ get activeViewCurrentTimeMarker(): boolean | CurrentTimeSettings; /** * Gets or sets the data of the Gantt. * * > The task data items should either conform to the [`GanttTask`]({% slug api_gantt_gantttask %}) interface, or a [`taskModelFields`]({% slug api_gantt_ganttcomponent %}#toc-taskmodelfields) object has to be provided. */ set data(data: any[]); get data(): any[]; /** * Specifies a callback that determines if the given task is selected ([see example]({% slug selection_gantt %}#toc-custom-selection)). * * > The [`selectable`]({% slug api_gantt_ganttcomponent %}#toc-selectable) prop has to be set to `true` in order for this callback to be executed. */ isSelected: (dataItem: object) => boolean; /** * Specifies a callback that determines if a new dependency is valid. * Used when evaluating if an attempt to create a new dependency will result in a valid link between the two tasks * [see example]({% slug editing_drag_create_dependencies_gantt %}#toc-validation). * * By defalut, dependencies are deemed invalid when: * - The two tasks are in a parent-child relationship. * - The two tasks are already dependent on one another. Only one dependency is allowed per pair. * - The start or end times of the two tasks are incompatible with the attempted dependency type. */ validateNewDependency: (dependency: object) => boolean; /** * Fires when the Gantt selection is changed through user interaction. * * Holds data about the affected [`items`]({% slug api_gantt_selectionchangeevent %}#toc-items) and the attempted [`action`]({% slug api_gantt_selectionchangeevent %}#toc-action): * - `select` - Triggered on `click` or `ctrl + click` on deselected items. * - `remove` - Triggered on `ctrl + click` on selected items. */ selectionChange: EventEmitter; /** * Enables or disables the Gantt selection mechanism ([see example]({% slug selection_gantt %}#toc-custom-selection)). * * > When set to `true`, the [`isSelected`]({% slug api_gantt_ganttcomponent %}#toc-isselected) callback has to be provided. * > When applied, the [`SelectableDirective`]({% slug api_gantt_selectabledirective %}) sets `selectable` to `true` internally. */ selectable: boolean; /** * The toolbar configuration. Defines the position and content of the toolbar(s). * The available properties are `position`, `addTaskTool`, and `viewSelectorTool`. * All are optional and default to `top`. * * The possible values for each option are: * - `top`—Positions the toolbar above the Gantt panes. Renders the respective tool in the top toolbar. * - `bottom`—Positions the toolbar below the Gantt panes. Renders the respective tool in the bottom toolbar. * - `both`—Displays two toolbar instances. Positions the first one above, * and the second one - below the Gantt panes. Renders the respective tool in the both toolbars. * - `none`—No toolbar is rendered when used for setting `position`. * No add task or view selector tool is rendered when used for setting `addTaskTool` or `viewSelectorTool`. */ set toolbarSettings(value: ToolbarSettings); get toolbarSettings(): ToolbarSettings; /** * Allows setting the toolbar(s) `aria-label` attribute value as necessary to comply with accessibility requirements. * Typically, toolbars need an `aria-label` when there is more than one toolbar in the application. */ toolbarAriaLabel: string; /** * Gets or sets the callback function that retrieves the child items for a particular item. */ set fetchChildren(fn: (dataItem: any) => Observable | object[]); get fetchChildren(): (dataItem: any) => Observable | object[]; /** * Gets or sets the callback function that indicates if a particular item has child items. */ set hasChildren(fn: (dataItem: any) => boolean); get hasChildren(): (dataItem: any) => boolean; /** * Defines the dependencies that will be drawn between the rendered tasks. * * > The dependency data items should either conform to the [`GanttDependency`]({% slug api_gantt_ganttdependency %}) interface, or a [`dependencyModelFields`]({% slug api_gantt_ganttcomponent %}#toc-dependencymodelfields) object has to be provided. */ dependencies: any[]; /** * Enables the sorting of the Gantt columns that have their `field` option set. */ sortable: SortSettings; /** * The descriptors by which the data will be sorted. */ sort: SortDescriptor[]; /** * Enables the filtering of the Gantt columns that have their `field` option set. * * @default false */ filterable: boolean; /** * The descriptor by which the data will be filtered. */ filter: CompositeFilterDescriptor; /** * The start time of the work day. * Accepts string values in the `HH:mm` format. */ workDayStart: string; /** * The end time of the work day. * Accepts string values in the `HH:mm` format. */ workDayEnd: string; /** * The start of the work week (index based). */ workWeekStart: Day; /** * The end of the work week (index based). */ workWeekEnd: Day; /** * If set to `true`, the user can use dedicated shortcuts to interact with the Gantt. * By default, navigation is disabled for the TreeList and Timeline parts of the component, * ([see example]({% slug keyboard_navigation_gantt %})). */ navigable: boolean; /** * The options of the timeline splitter pane. By default the pane is `collapsible`, * `resizable`, not `collapsed`, and its `size` is `'50%'`. */ set timelinePaneOptions(value: TimelinePaneOptions); get timelinePaneOptions(): TimelinePaneOptions; /** * The options of the treelist splitter pane. * By default the pane is `collapsible` and not `collapsed`. */ set treeListPaneOptions(value: TreeListPaneOptions); get treeListPaneOptions(): TreeListPaneOptions; /** * Defines a function that is executed for every task in the component. * The classes returned from the function are applied to the task wrapper element. */ set taskClass(fn: TaskClassFn); get taskClass(): TaskClassFn; /** * Defines a function that is executed for every data row in the component. */ set rowClass(fn: RowClassFn); get rowClass(): RowClassFn; /** * The name of the field which contains the unique identifier of the task data item. * Defaults to 'id'. */ get taskIdField(): any; /** * Sets the callback function that indicates if a particular item is expanded. * If no callback is set, all items will be expanded and no expand icons will be rendered. */ isExpanded: (item: object) => boolean; /** * Indicates whether the Gantt columns will be resized during initialization so that they fit their headers and row content. * Columns with autoSize set to false are excluded. * * @default false */ columnsAutoSize: boolean; /** * Specifies the Gantt current time marker settings. * The settings will be applied for all views. * If the `currentTimeMarker` is set for a view then it takes precedence. * * @default true */ currentTimeMarker: boolean | CurrentTimeSettings; /** * Specifies if the column menu of the columns will be displayed. * * @default false */ columnMenu: boolean | ColumnMenuSettings; /** * If set to true, the user can reorder columns by dragging their header cells. * * @default false */ columnsReorderable: boolean; /** * If set to true, the user can resize columns by dragging the edges (resize handles) of their header cells. * * @default false */ columnsResizable: boolean; /** * Specifies the settings for auto-scrolling during dragging * when the pointer moves outside of the container bounderies * [see example]({% slug editing_drag_create_dependencies_gantt %}#toc-auto-scrolling). */ set dragScrollSettings(settings: DragScrollSettings); get dragScrollSettings(): DragScrollSettings; /** * Allows setting the task tooltip `position`, `callout`, and `showAfter` options. * * @default { position: 'top', callout: true, showAfter: 100 } */ taskTooltipOptions: TaskTooltipOptions; /** * Fires when an item is expanded. */ rowExpand: EventEmitter; /** * Fires when a Gantt task in the timeline pane is double-clicked. The data item, associated with the clicked task, * is available in the event data. Use the event handler to open a task editing dialog as necessary. */ taskDblClick: EventEmitter; /** * Fires when the user double clicks a cell. */ cellDblClick: EventEmitter; /** * Fires when the user leaves an edited cell. */ cellClose: EventEmitter; /** * Fires when the end user clicks the `Delete` button in the task editing dialog, * the task delete icon, or presses the `Delete` key on the keyboard when a task in the timeline is focused. * Use the event handler to open a confirmation dialog when necessary. */ taskDelete: EventEmitter; /** * Fires when an item is collapsed. */ rowCollapse: EventEmitter; /** * Fires when the user confirms deleting a task. */ remove: EventEmitter; /** * Fires when the user cancels editing a task. */ cancel: EventEmitter; /** * Fires when the user saves an edited task. */ save: EventEmitter; /** * Fires when the user adds a task. */ taskAdd: EventEmitter; /** * Fires when the user adds a dependency via dragging * [see example]({% slug editing_drag_create_dependencies_gantt %}#toc-basic-concepts). */ dependencyAdd: EventEmitter; /** * Fires when the sorting of the Gantt is changed. * You have to handle the event yourself and sort the data. */ sortChange: EventEmitter; /** * Fires when the Gantt filter is modified. * You have to handle the event yourself and filter the data. */ filterChange: EventEmitter; /** * Fires when the filter or sort state of the Gantt is changed. */ dataStateChange: EventEmitter; /** * Fires when the collapsed state of the treelist pane is changed. */ treeListPaneCollapsedChange: EventEmitter; /** * Fires when the collapsed state of the timeline pane is changed. */ timelinePaneCollapsedChange: EventEmitter; /** * Fires each time the user resizes the timeline pane. */ timelinePaneSizeChange: EventEmitter; /** * Fires each time the user selects a different view type. The event data contains the type of the newly selected view. */ activeViewChange: EventEmitter; /** * Fires when the user completes the resizing of the column. */ columnResize: EventEmitter; /** * Fires when the user completes the reordering of the column. */ columnReorder: EventEmitter; /** * Fires when the user changes the visibility of the columns from the column menu or column chooser. */ columnVisibilityChange: EventEmitter; /** * @hidden * * Fires when the user changes the locked state of the columns from the column menu or by reordering the columns. */ columnLockedChange: EventEmitter; /** * Fires when a cell is clicked. */ cellClick: EventEmitter; /** * Fires when a task is clicked. */ taskClick: EventEmitter; /** * @hidden */ get renderedTreeListItems(): any[]; /** * @hidden */ get viewItems(): ViewItem[]; /** * @hidden */ get filterMenu(): FilterableSettings; /** * @hidden * * Specifies whether the dependency drag clues will be rendered. * Set internally by the dependency-drag-create directive. * * @default false */ renderDependencyDragClues: boolean; /** * @hidden */ timelineSlots: any[]; /** * @hidden */ timelineGroupSlots: any[]; /** * @hidden */ tableWidth: number; /** * @hidden */ get viewService(): TimelineBaseViewService; /** * @hidden * * Retrieves the `isSelected` callback if `selectable` is set to `true` * Otherwise returns the default callback, which always returns `false`. */ get isTaskSelected(): (dataItem: any) => boolean; /** * @hidden * * Used by the GanttExpandableDirective. */ get idGetter(): any; /** * @hidden * * Used by the views selector. */ get viewTypes(): TimelineViewType[]; /** * @hidden * * Used by the GanttExpandableDirective. */ expandStateChange: EventEmitter; /** * @hidden */ showEditingDialog: boolean; /** * @hidden */ showConfirmationDialog: boolean; /** * @hidden */ get isInEditMode(): boolean; /** * @hidden */ showLicenseWatermark: boolean; private _columns; private _data; private _dragScrollSettings; private _timelinePaneOptions; private _treeListPaneOptions; private _customToolbarTemplate; private _rowClass; private _taskClass; private _activeView; private _toolbarSettings; private _fetchChildren; private _hasChildren; private lastTreeListCellClick; private direction; private rtl; private editItem; private optionChangesSubscriptions; private editServiceSubscription; private localizationSubscription; private intlSubscription; private keydownListenerDisposers; constructor(timelineViewService: TimelineViewService, scrollSyncService: ScrollSyncService, renderer: Renderer2, mapper: MappingService, optionChangesService: OptionChangesService, dependencyDomService: DependencyDomService, editService: EditService, localizationService: LocalizationService, hostElement: ElementRef, zone: NgZone, navigation: NavigationService, currentTimeMarkerService: CurrentTimeMarkerService, intlService: IntlService, localeId: string); ngOnChanges(changes: SimpleChanges): void; ngAfterViewInit(): void; ngAfterContentInit(): void; ngOnDestroy(): void; /** * Focuses the last active cell or task in the Gantt. * If no item has previously been focused, the first cell of the TreeList part will receive focus, * ([see example]({% slug keyboard_navigation_gantt %}#toc-controlling-the-focus)). */ focus(): void; /** * Focuses the targeted cell in the TreeList part of the component, * ([see example]({% slug keyboard_navigation_gantt %}#toc-controlling-the-focus)). */ focusCell(rowIndex: number, colIndex: number): void; /** * Focuses the targeted task in the Timeline part of the component, * ([see example]({% slug keyboard_navigation_gantt %}#toc-controlling-the-focus)). */ focusTask(taskIndex: number): void; /** * Applies the minimum possible width for the specified column, * so that the whole text fits without wrapping. This method expects the Gantt * to be resizable (set `resizable` to `true`). * Makes sense to execute this method only after the Gantt is already populated with data. */ autoFitColumn(column: GanttColumnBase): void; /** * Adjusts the width of the specified columns to fit the entire content, including headers, without wrapping. * If no columns are specified, `autoFitColumns` is applied to all columns. * * This method requires the Gantt to be resizable (set `resizable` to `true`). */ autoFitColumns(columns?: Array | QueryList): void; /** * Clears the already loaded children for the dataItem so that the Gantt will fetch them again the next time it is rendered. */ reload(dataItem: any, reloadChildren?: boolean): void; /** * Changes the position of the specified column. * The reordering of columns operates only on the level * which is inferred by the source column. * For the `reorderColumn` method to work properly, * the `source` column has to be visible. * * @param {ColumnBase} source - The column whose position will be changed. * @param {number} destIndex - The new position of the column. * @param {ColumnReorderConfig} options - Additional options. */ reorderColumn(source: GanttColumnBase, destIndex: number, options?: ColumnReorderConfig): void; /** * Forces the TreeList to evaluate if some data items have changed and re-renders the rows information, if needed. * Recalculates and re-renders the Timeline period, if needed. * Redraws changed dependencies, if needed. * Executes all row-related callbacks anew. */ updateView(): void; /** * Opens the task editing dialog. */ editTask(dataItem: any, formGroup: FormGroup): void; /** * Closes the task editing dialog. */ closeTaskDialog(): void; /** * Opens the delete task confirmation dialog. */ openConfirmationDialog(): void; /** * @hidden */ handleConfirmationDialogClose(): void; /** * Opens a cell for editing. */ editCell(dataItem: any, column: number | string | any, formGroup?: FormGroup): void; /** * Closes an edited cell. */ closeCell(): void; /** * @hidden */ handleCellClose(e: TreeListCellCloseEvent): void; /** * @hidden */ onTreeListCollapsedChange(collapsed: boolean): void; /** * @hidden */ onTimelineCollapsedChange(collapsed: boolean): void; /** * @hidden */ loadTimelineData(): void; /** * @hidden */ showToolbar(position: string): boolean; /** * @hidden */ handleColumnVisibilityChange(event: ColumnVisibilityChangeEvent): void; /** * @hidden */ onTimelinePaneSizeChange(e: string): void; /** * @hidden */ handleTimelineRightClick(event: PointerEvent): void; /** * @hidden */ handleTimelineClick(event: PointerEvent): void; /** * @hidden */ handleTreeListDoubleClick(event: PointerEvent): void; /** * @hidden */ handleTreeListSelectionChange(event: TreeListSelectionChangeEvent): void; /** * @hidden */ handleTreeListCellClick(event: TreeListCellClickEvent): void; /** * @hidden */ handleDeleteConfirmation(): void; /** * @hidden */ handleTimelineMouseDown(event: MouseEvent): void; /** * @hidden */ handleTimelineDblClick(event: PointerEvent): void; /** * @hidden */ getText(token: string): string; /** * @hidden */ changeActiveView(view: TimelineViewType): void; /** * @hidden */ notifyTaskClick(event: PointerEvent | KeyboardEvent, dataItem: any, itemIndex: number): void; /** * @hidden */ notifySelectionChange(dataItem: any, action: 'select' | 'remove'): void; /** * @hidden */ notifyTaskDelete(task: any): void; /** * @hidden */ isSameSelection(action: 'select' | 'remove', dataItem: any): boolean; /** * @hidden */ getSelectionAction({ ctrlKey, metaKey }: PointerEvent | KeyboardEvent, dataItem: any): 'select' | 'remove'; private updateTreeListGroupClass; /** * Used to hide the vertical scrollbar */ private updateTreeListMargin; private get activeTimelineIndex(); private getActiveViewOptions; private getFirstSelectedItem; private defaultValidateNewDependencyCallback; private handleKeydown; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; }