@progress/kendo-angular-gantt 24.2.2 → 25.0.0-develop.2

package/index.d.ts

@@ -2,44 +2,3879 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { GanttComponent } from './gantt.component';
-export { GanttModule } from './gantt.module';
-export { GanttTimelineComponent } from './timeline/gantt-timeline.component';
-export { TimelineDayViewComponent } from './timeline/timeline-day-view.component';
-export { TimelineWeekViewComponent } from './timeline/timeline-week-view.component';
-export { TimelineMonthViewComponent } from './timeline/timeline-month-view.component';
-export { TimelineYearViewComponent } from './timeline/timeline-year-view.component';
-export { TaskFieldsComponent } from './editing/task-fields.component';
-export { DependenciesTableComponent } from './editing/dependencies-table.component';
-export { GanttAddTaskComponent } from './editing/add-task.component';
-export { EditDialogComponent } from './editing/edit-dialog.component';
-export { DragValidationTooltipComponent } from './dragging/drag-validation-tooltip.component';
-export { ToolbarComponent } from './toolbar/toolbar.component';
-export { ViewSelectorComponent } from './toolbar/view-selector.component';
-export { GanttTaskComponent } from './rendering/gantt-task.component';
-export { GanttMilestoneTaskComponent } from './rendering/gantt-milestone-task.component';
-export { GanttSummaryTaskComponent } from './rendering/gantt-summary-task.component';
-export { GanttHeaderTableBodyComponent } from './rendering/gantt-header-table-body.component';
-export { GanttTasksTableBodyComponent } from './rendering/gantt-tasks-table-body.component';
-export { GanttHierarchyBindingDirective } from './binding-directives/hierarchy-binding.directive';
-export { GanttFlatBindingDirective } from './binding-directives/flat-binding.directive';
-export { GanttExpandableDirective } from './expanded-state/expandable.directive';
-export { DependencyDragCreateDirective } from './dragging/dependency-drag-create.directive';
-export { TimelineScrollableDirective } from './scrolling/timeline-scroll.directive';
-export { GanttDependencyDirective } from './dependencies/gantt-dependency.directive';
-export { GanttTaskTemplateDirective } from './template-directives/task-template.directive';
-export { GanttTaskContentTemplateDirective } from './template-directives/task-content-template.directive';
-export { GanttSummaryTaskTemplateDirective } from './template-directives/summary-task-template.directive';
-export { ToolbarTemplateDirective } from './toolbar/toolbar-template.directive';
-export { SelectableDirective } from './selection/selectable.directive';
-export { SelectionChangeEvent } from './selection/selection-change-event';
-export { TreeListPaneOptions, TimelinePaneOptions } from './models/splitter-pane-options.interface';
-export { LocalizedMessagesDirective } from './localization/localized-messages.directive';
-export { CustomMessagesComponent } from './localization/custom-messages.component';
-export { CurrentTimeSettings } from './models/current-time-settings.interface';
-export { TaskDragDirective } from './dragging/task-drag.directive';
-export { GanttTaskTooltipTemplateDirective } from './template-directives/task-tooltip-template.directive';
-export { GanttTaskDragTooltipTemplateDirective } from './template-directives/task-drag-tooltip-template.directive';
-export * from './models/models';
-export * from './columns/columns';
-export * from './directives';
+import * as i0 from '@angular/core';
+import { OnDestroy, NgZone, EventEmitter, TemplateRef, QueryList, ElementRef, Renderer2, ChangeDetectorRef, Injector, OnInit, OnChanges, SimpleChanges, AfterViewInit, ViewContainerRef, AfterContentInit } from '@angular/core';
+import { FormGroup, FormArray, FormControl } from '@angular/forms';
+import { ColumnReorderConfig as ColumnReorderConfig$1, ExpandableColumnMenuItem, DataStateChangeEvent as DataStateChangeEvent$1, ColumnBase, ColumnComponent, ColumnGroupComponent, SpanColumnComponent, ColumnReorderEvent as ColumnReorderEvent$1, ColumnResizeArgs, TreeListComponent, FilterableSettings as FilterableSettings$1, DataBoundTreeComponent, ExpandableTreeComponent, CellCloseEvent as CellCloseEvent$1, SelectionChangeEvent as SelectionChangeEvent$1, CellClickEvent as CellClickEvent$1, FlatBindingDirective, HierarchyBindingDirective, ExpandableDirective } from '@progress/kendo-angular-treelist';
+import { SortDescriptor, CompositeFilterDescriptor } from '@progress/kendo-data-query';
+import { Day } from '@progress/kendo-date-math';
+import { Subject, Observable } from 'rxjs';
+import { LicenseMessage } from '@progress/kendo-licensing';
+import * as i1 from '@progress/kendo-angular-utils';
+import { DragTargetDragEvent, DragTargetDragEndEvent, DragTargetDragStartEvent, DragTargetContainerDirective } from '@progress/kendo-angular-utils';
+import { IntlService, DateFormatOptions as DateFormatOptions$1 } from '@progress/kendo-angular-intl';
+import { DateFormatOptions } from '@progress/kendo-intl';
+import { Position } from '@progress/kendo-angular-tooltip';
+import { LocalizationService, ComponentMessages } from '@progress/kendo-angular-l10n';
+import { PreventableEvent } from '@progress/kendo-angular-common';
+import { SegmentedItemSettings } from '@progress/kendo-angular-buttons';
+import { PopupService } from '@progress/kendo-angular-popup';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+
+type ScrollSyncEvent = {
+    scrollLeft?: number;
+    scrollTop?: number;
+    sourceType: string;
+};
+type SourceType = 'treelist' | 'header' | 'timeline';
+/**
+ * @hidden
+ */
+declare class ScrollSyncService implements OnDestroy {
+    private ngZone;
+    changes: Subject<ScrollSyncEvent>;
+    private elements;
+    private subscriptions;
+    private syncingTimeline;
+    private syncingTreeList;
+    constructor(ngZone: NgZone);
+    registerElement(el: any, sourceType: SourceType): void;
+    ngOnDestroy(): void;
+    syncScrollTop(sourceType: SourceType, targetType: SourceType): void;
+    resetTimelineScrollLeft(): void;
+    private scroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSyncService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollSyncService>;
+}
+
+/**
+ * Represents the model fields for creating `GanttDependency` instances.
+ *
+ * All dependency fields can point to nested property values, for example, `category.id`.
+ *
+ */
+interface GanttDependencyModelFields {
+    /**
+     * Specifies the name of the model field for the source task ID.
+     * @default "fromId"
+     */
+    fromId?: string;
+    /**
+     * Specifies the name of the model field for the dependency item ID.
+     * @default "id"
+     */
+    id?: string;
+    /**
+     * Specifies the name of the model field for the target task ID.
+     * @default "toId"
+     */
+    toId?: string;
+    /**
+     * Specifies the name of the model field for the dependency type.
+     * @default "type"
+     */
+    type?: string;
+}
+
+/**
+ * Defines the model fields for creating `GanttTask` instances.
+ *
+ * > You can set all task fields to use nested property values, for example, `category.id`.
+ */
+interface GanttTaskModelFields {
+    /**
+     * Specifies the name of the end date model field.
+     * Use this property to map the end date from your data model.
+     * @default "end"
+     */
+    end?: string;
+    /**
+     * Specifies the name of the `ID` model field.
+     * Use this property to map the unique identifier from your data model.
+     * @default "id"
+     */
+    id?: string;
+    /**
+     * Specifies the name of the percent complete model field.
+     * Use this property to map the completion ratio from your data model.
+     * @default "completionRatio"
+     */
+    completionRatio?: string;
+    /**
+     * Specifies the name of the start date model field.
+     * Use this property to map the start date from your data model.
+     * @default "start"
+     */
+    start?: string;
+    /**
+     * Specifies the name of the title model field.
+     * This property is used as text in the task content area.
+     * @default "title"
+     */
+    title?: string;
+    /**
+     * Specifies the name of the children model field.
+     * Use this property to map child tasks from your data model.
+     * @default "children"
+     */
+    children?: string;
+}
+
+/**
+ * @hidden
+ */
+declare class MappingService {
+    /**
+     * Gets or sets the model fields for the task data items.
+     * Uses the default values for fields which are not specified.
+     */
+    set taskFields(fields: GanttTaskModelFields);
+    get taskFields(): GanttTaskModelFields;
+    /**
+     * Gets or sets the model fields for the depenency data items.
+     * Uses the default values for fields which are not specified.
+     */
+    set dependencyFields(fields: GanttDependencyModelFields);
+    get dependencyFields(): GanttDependencyModelFields;
+    private _taskFields;
+    private _dependencyFields;
+    /**
+     * Retrieves the value for the specified task field.
+     * Supports nested fields as well (e.g. 'manager.id').
+     */
+    extractFromTask(dataItem: any, field: keyof GanttTaskModelFields): any;
+    /**
+     * Retrieves the value for the specified dependency field.
+     * Supports nested fields as well (e.g. 'manager.id').
+     */
+    extractFromDependency(dataItem: any, field: keyof GanttDependencyModelFields): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MappingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MappingService>;
+}
+
+/**
+ * @hidden
+ *
+ * The arguments emitted by the DependencyDomService `taskChanges` observable.
+ */
+interface DependencyDomArgs {
+    /**
+     * Maps each rendered task to its HTML element.
+     * Uses the task ID field value as key.
+     */
+    tasks: Map<any, HTMLElement>;
+    /**
+     * Used to retrieve the offset of the task elements relative to the parent container.
+     */
+    contentContainer: HTMLElement;
+    /**
+     * Used to store the timeline row element for calculating the timeline row height when needed.
+     */
+    timelineRow: HTMLElement;
+}
+
+/**
+ * @hidden
+ */
+declare class DependencyDomService {
+    private mapper;
+    /**
+     * Emits each time some of the tasks or the view have changed.
+     * Fires also on the first change of the table rows and the parent container.
+     */
+    get taskChanges(): Observable<DependencyDomArgs>;
+    get dependencyDomArgs(): DependencyDomArgs;
+    private notifier;
+    /**
+     * The row element in the Timeline part of the Gantt.
+     */
+    private timelineRow;
+    /**
+     * Used to get retrieve the offset of the task elements relative to the parent container.
+     */
+    private contentContainer;
+    /**
+     * Maps each rendered task to its HTML element.
+     * Uses the task ID field value as key.
+     */
+    private tasks;
+    constructor(mapper: MappingService);
+    ngOnDestroy(): void;
+    registerTimelineRow(timelineRow: HTMLElement): void;
+    registerContentContainer(contentContainer: HTMLElement): void;
+    registerTask(task: any, element: HTMLElement): void;
+    unregisterTask(task: any): void;
+    /**
+     * Notifies all dependency directives that a change in one of the elements has occured.
+     */
+    notifyChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DependencyDomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DependencyDomService>;
+}
+
+/**
+ * @hidden
+ *
+ * Represents the item interface used by the treelist to map all rendered items.
+ */
+interface ViewItem {
+    /**
+     * The original data item held by this entry.
+     */
+    data: any;
+    /**
+     * The id field value of the current data item.
+     */
+    id: any;
+    /**
+     * The item index as rendered in the TreeList.
+     */
+    rowIndex: number;
+    /**
+     * The hierarchical level of the current data item.
+     */
+    level: number;
+    /**
+     * Species whether the current data item has children.
+     */
+    hasChildren: boolean;
+    /**
+     * The ViewItem of the current data item parent.
+     */
+    parent: ViewItem;
+}
+
+/**
+ * Represents the dependency type when you connect two tasks.
+ *
+ * The supported values are:
+ * * `FF`&mdash;from 'finish' to 'finish'
+ * * `FS`&mdash;from 'finish' to 'start'
+ * * `SS`&mdash;from 'start' to 'start'
+ * * `SF`&mdash;from 'start' to 'finish'
+ */
+declare enum DependencyType {
+    /**
+     * Specifies that task B can't finish before task A finishes.
+     */
+    FF = 0,
+    /**
+     * Specifies that task B can't start before task A finishes.
+     */
+    FS = 1,
+    /**
+     * Specifies that task A can't finish before task B starts.
+     */
+    SF = 2,
+    /**
+     * Specifies that task B can't start before task A starts.
+     */
+    SS = 3
+}
+
+/**
+ * Represents a Gantt dependency.
+ *
+ * Use this interface to describe a dependency between two tasks in the Gantt chart.
+ *
+ */
+interface GanttDependency {
+    /**
+     * Sets the `id` of the origin task for this dependency.
+     */
+    fromId: string | number;
+    /**
+     * Sets the unique identifier of the dependency.
+     */
+    id: string | number;
+    /**
+     * Sets the `id` of the destination task for this dependency.
+     */
+    toId: string | number;
+    /**
+     * Sets the type of the dependency.
+     */
+    type: DependencyType;
+}
+
+/**
+ * Represents a Gantt task.
+ */
+interface GanttTask {
+    /**
+     * Sets the date when the Gantt task ends.
+     * Provide a valid `Date` object.
+     */
+    end: Date;
+    /**
+     * Sets the unique identifier for the task.
+     */
+    id: string | number;
+    /**
+     * Sets the completion ratio for the task.
+     * Use a value between `0` and `1` to show the completed part of the task.
+     * @default 0
+     */
+    completionRatio?: number;
+    /**
+     * Sets the date when the Gantt task starts.
+     * Provide a valid `Date` object.
+     */
+    start: Date;
+    /**
+     * Sets the title of the task that the Gantt component displays.
+     * @default ""
+     */
+    title?: string;
+}
+
+/**
+ * @hidden
+ *
+ * Represents the range of the Gantt timeline.
+ */
+interface DateRange {
+    /**
+     * The beginning of the range.
+     */
+    start: Date;
+    /**
+     * The end of the range.
+     */
+    end: Date;
+}
+
+/**
+ * @hidden
+ *
+ * Represents the slot base properties.
+ */
+interface Slot {
+    /**
+     * The beginning of the slot.
+     */
+    start: Date;
+    /**
+     * The end of the slot.
+     */
+    end: Date;
+    /**
+     * Formatted text to be displayed in the cell.
+     */
+    text: string;
+    /**
+     * The number of columns the slot should span.
+     */
+    span: number;
+    /**
+     * Indicates if the slot is a working hour/day.
+     */
+    isWorking?: boolean;
+    /**
+     * The configured slot width.
+     *
+     * @default 100
+     */
+    slotWidth?: number;
+}
+
+/**
+ * Represents the callback that is used by the [`rowClass`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#rowclass) property.
+ *
+ * @example
+ * ```typescript
+ * public rowCallback({ dataItem, index }: any): any {
+ *   const isEven = index % 2 == 0;
+ *   return {
+ *     even: isEven,
+ *     odd: !isEven
+ *   };
+ * }
+ * ```
+ *
+ */
+type RowClassFn = (args: {
+    dataItem: any;
+    index: number;
+}) => string | string[] | Set<string> | {
+    [key: string]: any;
+};
+/**
+ * Represents the callback that is used by the [`taskClass`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#taskclass) property.
+ *
+ * @example
+ * ```typescript
+ * public taskCallback(dataItem: any): any {
+ *   const moreThanHalfCompleted = dataItem.completionRatio > 0.5;
+ *   return {
+ *     'more-than-half': moreThanHalfCompleted,
+ *     'less-than-half': !moreThanHalfCompleted
+ *   };
+ * }
+ * ```
+ *
+ */
+type TaskClassFn = (dataItem: any) => string | string[] | Set<string> | {
+    [key: string]: any;
+};
+
+/**
+ * Defines the cell content type.
+ * Use this type to specify which filter component appears for a column,
+ * or which built-in editor displays when a row enters edit mode.
+ *
+ */
+type CellContentType = 'text' | 'numeric' | 'boolean' | 'date';
+
+/**
+ * Extends the configuration for the `reorderColumn` method.
+ *
+ * Use this interface to provide additional options when you reorder columns.
+ *
+ */
+interface ColumnReorderConfig extends ColumnReorderConfig$1 {
+}
+
+/**
+ * Configures the column menu settings in the Gantt component.
+ */
+interface ColumnMenuSettings {
+    /**
+     * Lets you sort columns in the column menu.
+     * If you enable [sorting](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#sortable), this option defaults to `true`.
+     */
+    sort?: boolean;
+    /**
+     * Enables filtering columns in the column menu.
+     * If you enable [filtering](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#filterable), this option defaults to `true`.
+     * Enables sorting columns in the column menu.
+     */
+    filter?: boolean | ExpandableColumnMenuItem;
+    /**
+     * Shows the column selection item in the column menu.
+     * @default true
+     */
+    columnChooser?: boolean | ExpandableColumnMenuItem;
+}
+
+/**
+ * Lists all possible `TimelineViewType` values.
+ */
+type TimelineViewType = 'day' | 'week' | 'month' | 'year';
+
+/**
+ * Defines the settings for sorting a Gantt column.
+ */
+type ColumnSortSettings = boolean | {
+    /**
+     * Enables removing the column sorting.
+     */
+    allowUnsort?: boolean;
+    /**
+     * Sets the initial sort direction from the unsorted to the sorted state.
+     *
+     * The available values are:
+     * - `asc` (default)
+     * - `desc`
+     */
+    initialDirection?: 'asc' | 'desc';
+};
+/**
+ * Defines the settings for sorting the Gantt.
+ */
+type SortSettings = boolean | ColumnSortSettings & {
+    /**
+     * Sets the sort mode of the Gantt.
+     *
+     * The available values are:
+     * - `single`
+     * - `multiple`
+     */
+    mode?: 'single' | 'multiple';
+    /**
+     * Enables the sort-sequence indicators for sorting multiple columns.
+     */
+    showIndexes?: boolean;
+};
+
+/**
+ * @hidden
+ *
+ * Arguments for the `remove` event.
+ */
+interface ClickEvent {
+    /**
+     * The event type.
+     */
+    dataItem: any;
+    /**
+     * The row index for the operation.
+     */
+    rowIndex: number;
+    /**
+     * The original DOM event.
+     */
+    originalEvent: any;
+}
+
+/**
+ * @hidden
+ *
+ * Called every time the active view is changed.
+ */
+interface SelectedViewChangeEvent {
+    /**
+     * The selected view.
+     */
+    value: string;
+    /**
+     * The original DOM event.
+     */
+    originalEvent: any;
+}
+
+/**
+ * Provides the arguments for the `dataStateChange` event.
+ */
+interface DataStateChangeEvent extends DataStateChangeEvent$1 {
+}
+
+/**
+ * Serves as the base class for Gantt column components.
+ *
+ */
+declare class GanttColumnBase extends ColumnBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttColumnBase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttColumnBase, "kendo-gantt-column-base", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class OptionChangesService {
+    readonly viewChanges: EventEmitter<any>;
+    readonly columnChanges: EventEmitter<any>;
+    readonly dateFormatChanges: EventEmitter<any>;
+    notifyColumnChanges(): void;
+    notifyViewChanges(): void;
+    notifyDateFormatChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionChangesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OptionChangesService>;
+}
+
+/**
+ * Customizes the content of Gantt column cells. Place an `<ng-template>` tag
+ * with the `kendoGanttCellTemplate` directive inside a `<kendo-gantt-column>` tag to define the cell template.
+ *
+ * The template context provides these fields:
+ * - `dataItem`&mdash;The current data item. Represents the default context that will be assigned to any template variable using the `let-x` syntax, for example, `let-dataItem`.
+ * - `columnIndex`&mdash;The current column index. Use it as a template variable with the `let-columnIndex="columnIndex"` syntax.
+ * - `column`&mdash;The current column instance. Use it as a template variable with the `let-column="column"` syntax.
+ * - `cellContext`&mdash;An object for passing context information to built-in directives.
+ * - `hasChildren`&mdash;Indicates if the item has children.
+ * - `isExpanded`&mdash;Indicates if the item is expanded.
+ * - `level`&mdash;The hierarchy level of the item.
+ * - `loading`&mdash;Indicates if the item children are loading.
+ * - `rowIndex`&mdash;The current row index. Use it as a template variable with the `let-rowIndex="rowIndex"` syntax.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column field="title">
+ *   <ng-template kendoGanttCellTemplate let-dataItem>
+ *     <strong>{{ dataItem.title }}</strong>
+ *   </ng-template>
+ * </kendo-gantt-column>
+ * ```
+ */
+declare class CellTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CellTemplateDirective, "[kendoGanttCellTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Customizes the column menu content in the Gantt. Place an `<ng-template>` tag with the
+ * `kendoGanttColumnMenuTemplate` directive inside a `<kendo-gantt-column>` component to define the template.
+ *
+ * The template context provides the following fields:
+ * - `service`&mdash;The `ColumnMenuService` instance.
+ * - `column`&mdash;The Gantt column instance.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column>
+ *   <ng-template kendoGanttColumnMenuTemplate let-service="service" let-column="column">
+ *     <button (click)="service.close()">Close Menu</button>
+ *   </ng-template>
+ * </kendo-gantt-column>
+ * ```
+ */
+declare class ColumnMenuTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnMenuTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnMenuTemplateDirective, "[kendoGanttColumnMenuTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ * Represents the filter-cell template.
+ *
+ * The template context is set to the filter descriptor and the following additional fields are passed:
+ * - `column`&mdash;The current column instance. Use it as an alias for a template variable by utilizing the `let-column="column"` syntax.
+ * - `filter`&mdash;The filter descriptor.
+ * - `cellContext`&mdash;An object used to pass context information to built-in directives.
+ */
+declare class FilterCellTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCellTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterCellTemplateDirective, "[kendoGanttFilterCellTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the filter-menu template for the Gantt column.
+ *
+ * Use this directive to customize the filter menu for a column.
+ * The template context provides:
+ * - `column`&mdash;The current column instance. Use as an alias for a template variable with the `let-column="column"` syntax.
+ * - `filter`&mdash;The filter descriptor.
+ * - `cellContext`&mdash;An object for passing context information to built-in directives.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column>
+ *   <ng-template kendoGanttFilterMenuTemplate let-column let-filter="filter">
+ *     Custom filter for {{ column.field }}
+ *   </ng-template>
+ * </kendo-gantt-column>
+ * ```
+ */
+declare class FilterMenuTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterMenuTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterMenuTemplateDirective, "[kendoGanttFilterMenuTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the footer cell template of the Gantt columns.
+ *
+ * Use this directive to customize the table footer cell for a column.
+ * To define a footer template, nest an `<ng-template>` tag with the
+ * [`kendoGanttFooterTemplate`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/footertemplatedirective) directive inside the `<kendo-gantt-column>` tag.
+ *
+ * The template context provides:
+ * * `column`&mdash;The current [`ColumnComponent`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcolumncomponent).
+ * * `columnIndex`&mdash;The current column index.
+ * * `field`&mdash;The name of the column field, if set.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column>
+ *   <ng-template kendoGanttFooterTemplate let-column let-columnIndex="columnIndex" let-field="field">
+ *     Footer for {{ field }}
+ *   </ng-template>
+ * </kendo-gantt-column>
+ * ```
+ */
+declare class FooterTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FooterTemplateDirective, "[kendoGanttFooterTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the header cell template of the Gantt columns.
+ *
+ * Use this directive to customize the table header cell for a column.
+ * To define a header template, nest an `<ng-template>` tag with the
+ * [`kendoGanttHeaderTemplate`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/headertemplatedirective) directive inside the `<kendo-gantt-column>` tag.
+ *
+ * The template context provides:
+ * * `column`&mdash;The current [`ColumnComponent`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcolumncomponent).
+ * * `columnIndex`&mdash;The current column index.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column>
+ *   <ng-template kendoGanttHeaderTemplate let-column let-columnIndex="columnIndex">
+ *     Custom Header for {{ column.field }} ({{ columnIndex }})
+ *   </ng-template>
+ * </kendo-gantt-column>
+ * ```
+ */
+declare class HeaderTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderTemplateDirective, "[kendoGanttHeaderTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the column template for edited cells in the Gantt.
+ *
+ * Use this directive to customize the content of edited cells. To define the cell template, nest an `<ng-template>`
+ * tag with the `kendoGanttEditTemplate` directive inside a `<kendo-gantt-column>` tag.
+ *
+ * The template context provides the following fields:
+ * - `column`&mdash;The current column instance.
+ * - `dataItem`&mdash;The current data item.
+ * - `cellContext`&mdash;An object for passing context information to built-in directives.
+ * - `formGroup`&mdash;The current [`FormGroup`](link:site.data.urls.angular['formgroupapi']). If you use the Gantt inside [Template-Driven Forms](link:site.data.urls.angular['forms']), it is `undefined`.
+ * - `isNew`&mdash;The state of the current item.
+ * - `rowIndex`&mdash;The current row index. If inside a new item row, `rowIndex` is `-1`.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column>
+ *   <ng-template kendoGanttEditTemplate let-dataItem="dataItem" let-formGroup="formGroup">
+ *     <input [formControl]="formGroup.get('field')" />
+ *   </ng-template>
+ * </kendo-gantt-column>
+ * ```
+ */
+declare class EditTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EditTemplateDirective, "[kendoGanttEditTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a column in the Gantt. Use this component to define columns and customize their behavior and appearance.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column field="title" title="Task"></kendo-gantt-column>
+ * ```
+ */
+declare class GanttColumnComponent extends ColumnComponent {
+    private options;
+    headerTemplates: QueryList<HeaderTemplateDirective>;
+    footerTemplate: FooterTemplateDirective;
+    columnMenuTemplates: QueryList<ColumnMenuTemplateDirective>;
+    template: CellTemplateDirective;
+    editTemplate: EditTemplateDirective;
+    filterCellTemplate: FilterCellTemplateDirective;
+    filterMenuTemplate: FilterMenuTemplateDirective;
+    /**
+     * Sets the filter type for the filter row. The default value is `text`.
+     * @default 'text'
+     */
+    filter: CellContentType;
+    /**
+     * Shows or hides the filter UI for this column. The default value is `true`.
+     * @default true
+     */
+    filterable: boolean;
+    /**
+     * @hidden
+     *
+     * Defines the editor type.
+     * Used when the column enters the edit mode. The default value is `text`.
+     */
+    editor: CellContentType;
+    /**
+     * @hidden
+     *
+     * Defines whether the column is editable. The default value is `true`.
+     */
+    editable: boolean;
+    constructor(options: OptionChangesService, parent?: GanttColumnBase);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttColumnComponent, [null, { optional: true; host: true; skipSelf: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttColumnComponent, "kendo-gantt-column", never, { "filter": { "alias": "filter"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "editor": { "alias": "editor"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, {}, ["footerTemplate", "template", "editTemplate", "filterCellTemplate", "filterMenuTemplate", "headerTemplates", "columnMenuTemplates"], never, true, never>;
+}
+
+/**
+ * Represents a group of columns in the Gantt. Use this component to organize columns under a common header.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-column-group title="Details">
+ *   <kendo-gantt-column field="start"></kendo-gantt-column>
+ *   <kendo-gantt-column field="end"></kendo-gantt-column>
+ * </kendo-gantt-column-group>
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link GanttColumnComponent}, {@link GanttSpanColumnComponent}.
+ */
+declare class GanttColumnGroupComponent extends ColumnGroupComponent {
+    private options;
+    /**
+     * @hidden
+     */
+    children: QueryList<GanttColumnBase>;
+    /**
+     * @hidden
+     */
+    headerTemplates: QueryList<HeaderTemplateDirective>;
+    constructor(options: OptionChangesService, parent?: GanttColumnBase);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttColumnGroupComponent, [null, { optional: true; host: true; skipSelf: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttColumnGroupComponent, "kendo-gantt-column-group", never, {}, {}, ["children", "headerTemplates"], never, true, never>;
+}
+
+/**
+ * Represents the Gantt span column.
+ *
+ * Use this component to span row content over multiple column cells.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-span-column>
+ *   <kendo-gantt-column field="id"></kendo-gantt-column>
+ *   <kendo-gantt-column field="name"></kendo-gantt-column>
+ * </kendo-gantt-span-column>
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link GanttColumnComponent}.
+ */
+declare class GanttSpanColumnComponent extends SpanColumnComponent {
+    private options;
+    /**
+     * @hidden
+     */
+    childColumns: QueryList<GanttColumnComponent>;
+    template: QueryList<CellTemplateDirective>;
+    editTemplate: QueryList<EditTemplateDirective>;
+    constructor(options: OptionChangesService, parent?: GanttColumnBase);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttSpanColumnComponent, [null, { optional: true; host: true; skipSelf: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttSpanColumnComponent, "kendo-gantt-span-column", never, {}, {}, ["childColumns", "template", "editTemplate"], never, true, never>;
+}
+
+/**
+ * Represents the arguments for the `cellClick` event of the Gantt.
+ */
+interface CellClickEvent {
+    /**
+     * Contains the column component associated with the clicked cell.
+     */
+    column: GanttColumnComponent | GanttSpanColumnComponent;
+    /**
+     * Holds the column index of the clicked cell.
+     */
+    columnIndex: number;
+    /**
+     * Contains the data item for the clicked cell.
+     */
+    dataItem: any;
+    /**
+     * Indicates if the cell is in edit mode.
+     */
+    isEdited: boolean;
+    /**
+     * Contains the DOM event that triggered the `cellClick` event.
+     */
+    originalEvent: PointerEvent;
+    /**
+     * Holds the row index for the clicked cell.
+     */
+    rowIndex: number;
+    /**
+     * Contains the Gantt component instance.
+     */
+    sender: GanttComponent;
+    /**
+     * Specifies the type of event that triggered the `cellClick` event.
+     */
+    type: 'click' | 'contextmenu' | 'dblclick';
+}
+
+/**
+ * Contains the event data for task editing events.
+ */
+interface TaskEditEvent {
+    /**
+     * Holds the `TaskEditItem` for the edited task.
+     * Access the parent item through the `parent` property to update all ancestors.
+     */
+    item: TaskEditItem;
+    /**
+     * Holds the `FormGroup` instance for the edited task.
+     */
+    taskFormGroup?: FormGroup;
+    /**
+     * Holds the dependencies for the edited task.
+     */
+    dependencies: EditEventDependencies;
+    /**
+     * Holds the `GanttComponent` instance.
+     */
+    sender: GanttComponent;
+}
+/**
+ * Represents the `TaskEditItem` associated with the edited task.
+ * Access the parent item through the `parent` property to update all ancestors.
+ */
+interface TaskEditItem {
+    /**
+     * Holds the original data item for this entry.
+     */
+    dataItem: any;
+    /**
+     * Holds the parent data item and its parent data.
+     * If the current data item is at root level, this property is `null`.
+     */
+    parent?: TaskEditItem;
+}
+/**
+ * Provides the `EditEventDependencies` object associated with the edited task.
+ * You can access the created, updated, and deleted items through the respective properties.
+ */
+interface EditEventDependencies {
+    /**
+     * Lists the newly created dependencies.
+     */
+    createdItems: any[];
+    /**
+     * Lists the updated dependencies.
+     */
+    updatedItems: any[];
+    /**
+     * Lists the deleted dependencies.
+     */
+    deletedItems: any[];
+}
+/**
+ * @hidden
+ */
+type EditResultType = 'save' | 'remove' | 'cancel';
+/**
+ * @hidden
+ */
+interface EditEvent {
+    taskFormGroup: FormGroup;
+    dataItem: any;
+    dependencies: EditEventDependencies;
+    editResultType: EditResultType;
+}
+
+/**
+ * Represents the arguments for the `cellClose` event of the Gantt.
+ */
+declare class CellCloseEvent extends PreventableEvent {
+    /**
+     * Holds the data item.
+     */
+    dataItem: any;
+    /**
+     * Indicates if the data item is new or existing.
+     */
+    isNew: boolean;
+    /**
+     * Contains the Gantt column associated with the closed cell.
+     */
+    column: any;
+    /**
+     * Contains the [`FormGroup`](link:site.data.urls.angular['formgroupapi']) used to edit the cell that will be closed.
+     */
+    formGroup: any;
+    /**
+     * Contains the DOM event that triggered the `cellClose` event.
+     * This property may be missing if `cellClose` is triggered by an API call.
+     */
+    originalEvent: any;
+    /**
+     * Holds the `GanttComponent` instance.
+     */
+    sender: GanttComponent;
+    /**
+     * Contains the `TaskEditItem` for the edited task.
+     * Access the parent item through the `parent` property to traverse all ancestors that need updates.
+     */
+    item: TaskEditItem;
+    constructor(options: any);
+}
+
+/**
+ * Provides the arguments for the `taskClick` event of the Gantt.
+ */
+interface TaskClickEvent {
+    /**
+     * Holds the DOM event that triggered the `taskClick` event.
+     */
+    originalEvent: PointerEvent | KeyboardEvent;
+    /**
+     * Holds the data item for the clicked task.
+     */
+    dataItem: any;
+    /**
+     * Holds the Gantt component instance.
+     */
+    sender: GanttComponent;
+    /**
+     * Holds the order index of the clicked task, based on the number of rendered tasks in the Timeline.
+     */
+    index: number;
+    /**
+     * Holds the type of event that triggered the `taskClick` event.
+     */
+    type: 'click' | 'contextmenu' | 'dblclick';
+}
+
+/**
+ * Contains the event data for the [`taskAdd`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#taskadd) event.
+ */
+interface TaskAddEvent {
+    /**
+     * Holds the currently selected Gantt task.
+     */
+    selectedItem: TaskEditItem | null;
+    /**
+     * Holds the type of add action. The built-in types are `addTask`, `addChild`, `addAbove`, and `addBelow`.
+     */
+    actionType: string;
+}
+/**
+ * Describes the AddTask DropDownButton options.
+ */
+interface GanttAddTaskActionItem {
+    /**
+     * Holds the text for the DropDownButton option.
+     */
+    text: string;
+    /**
+     * Holds the type of action for the DropDownButton option.
+     */
+    type: string;
+}
+
+/**
+ * Provides the event data for the [`dependencyAdd`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#dependencyadd) event.
+ */
+interface DependencyAddEvent {
+    /**
+     * Represents the task where the dependency starts (predecessor).
+     */
+    fromTask: any;
+    /**
+     * Represents the task where the dependency ends (successor).
+     */
+    toTask: any;
+    /**
+     * Specifies the dependency type for the linked tasks.
+     */
+    type: DependencyType;
+    /**
+     * Indicates if the dependency creation is a valid link between the two tasks.
+     */
+    isValid: boolean;
+}
+
+/**
+ * Contains the event data for the [`taskDelete`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#taskdelete) event.
+ */
+interface TaskDeleteEvent {
+    /**
+     * Holds the item for the delete request.
+     * You can access the parent item through the `parent` property to update all ancestors.
+     */
+    item: TaskEditItem;
+    /**
+     * Holds the `GanttComponent` instance.
+     */
+    sender: GanttComponent;
+}
+
+/**
+ * @hidden
+ *
+ * Arguments for the `columnLockedChange` event.
+ */
+interface ColumnLockedChangeEvent {
+    /**
+     * The columns whose locked state is changed.
+     */
+    columns: GanttColumnBase[];
+}
+
+/**
+ * Provides the arguments for the `columnReorder` event.
+ */
+interface ColumnReorderEvent extends ColumnReorderEvent$1 {
+}
+
+/**
+ * Provides the arguments for the `columnResize` event.
+ */
+interface ColumnResizeEvent extends ColumnResizeArgs {
+}
+
+/**
+ * Provides the arguments for the `columnVisibilityChange` event.
+ */
+interface ColumnVisibilityChangeEvent {
+    /**
+     * Contains the columns whose visibility changes.
+     */
+    columns: GanttColumnBase[];
+}
+
+/**
+ * Contains the event data for the Gantt `TaskDragEvent`. This event triggers when the user resizes or moves a task.
+ */
+interface TaskDragEvent {
+    /**
+     * Holds the new start date for the task.
+     */
+    start: Date;
+    /**
+     * Holds the new end date for the task.
+     */
+    end: Date;
+    /**
+     * Holds the new completion ratio.
+     */
+    completionRatio: number;
+    /**
+     * Holds the drag event triggered by the user's action.
+     */
+    dragEvent: DragTargetDragEvent | DragTargetDragEndEvent;
+    /**
+     * Holds the item object for the dragged event. Contains the original data item and its parent. Use this to update all affected ancestor tasks in the data hierarchy.
+     */
+    item: TaskEditItem;
+}
+/**
+ * @hidden
+ * The internal task drag event required for all necessary calculations and DOM updates
+ */
+interface InternalTaskDragEvent {
+    /**
+     * Holds the new start date for the task.
+     */
+    start: Date;
+    /**
+     * Holds the new end date for the task.
+     */
+    end: Date;
+    /**
+     * Holds the new completion ratio.
+     */
+    completionRatio: number;
+    /**
+     * Holds the offset of the task DOM element, relative to the view start.
+     */
+    offset: number;
+    /**
+     * Holds the new width of the task DOM element in pixels.
+     */
+    width: number;
+    /**
+     * Holds the drag event triggered by the user's action.
+     */
+    dragEvent: DragTargetDragEvent | DragTargetDragEndEvent;
+    /**
+     * Holds the item object for the dragged event. Contains the original data item and its parent. Use this to update all affected ancestor tasks in the data hierarchy.
+     */
+    item: any;
+}
+
+/**
+ * Defines the possible positions where the Gantt toolbar or its tools render.
+ */
+type ToolbarPosition = 'top' | 'bottom' | 'both' | 'none';
+/**
+ * Configures the toolbar's position and content.
+ */
+interface ToolbarSettings {
+    /**
+     * Sets the position of the toolbar(s).
+     * @default 'top'
+     */
+    position?: ToolbarPosition;
+    /**
+     * Sets the position of the toolbar(s) where the [`AddTaskComponent`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttaddtaskcomponent) renders.
+     * @default 'none'
+     */
+    addTaskTool?: ToolbarPosition;
+    /**
+     * Sets the position of the toolbar(s) where the [`ViewSelectorComponent`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/viewselectorcomponent) renders.
+     * @default 'top'
+     */
+    viewSelectorTool?: ToolbarPosition;
+}
+
+/**
+ * Represents the options for formatting the group headers and column headers in each Timeline Header.
+ *
+ */
+interface TimelineHeaderDateFormat {
+    /**
+     * Sets the date format for the group header in the Timeline Header.
+     */
+    groupHeaderDateFormat?: string | DateFormatOptions;
+    /**
+     * Sets the date format for the column header in the Timeline Header.
+     */
+    columnHeaderDateFormat?: string | DateFormatOptions;
+}
+
+/**
+ * Specifies the settings for auto-scrolling during drag editing operations.
+ */
+interface DragScrollSettings {
+    /**
+     * Enables or disables auto-scrolling during drag editing operations.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Sets the scrolling step in pixels.
+     *
+     * @default 3
+     */
+    step?: number;
+    /**
+     * Sets the scrolling interval in milliseconds.
+     *
+     * @default 1
+     */
+    interval?: number;
+    /**
+     * Sets the threshold in pixels at each end of the scrollable container. When the pointer reaches this threshold, scrolling starts.
+     *
+     * @default 10
+     */
+    threshold?: number;
+}
+
+/**
+ * Configures the options for the tooltip that appears when you hover over a task.
+ */
+interface TaskTooltipOptions {
+    /**
+     * Sets the `position` of the Tooltip or Popover relative to the anchor element.
+     *
+     * @default 'left'
+     */
+    position: Position;
+    /**
+     * Shows a callout arrow on the Tooltip when set to `true`.
+     *
+     * @default true
+     */
+    callout: boolean;
+    /**
+     * Sets the delay in milliseconds before the Tooltip appears.
+     *
+     * @default 100
+     */
+    showAfter: number;
+}
+
+/**
+ * Represents the settings for the current time marker in the Gantt component.
+ *
+ */
+interface CurrentTimeSettings {
+    /**
+     * Sets the update interval in milliseconds for the current time marker.
+     * Use this property to control how often the marker updates.
+     * @default 60000
+     */
+    updateInterval?: number;
+    /**
+     * Shows or hides the current time marker.
+     * Set to `true` to display the marker.
+     * @default true
+     */
+    enabled?: boolean;
+}
+
+/**
+ * @hidden
+ */
+declare class CurrentTimeMarkerService implements OnDestroy {
+    private renderer;
+    private cdr;
+    container: ElementRef<HTMLElement>;
+    slots: any[];
+    rows: any[];
+    currentTimeMarker: boolean | CurrentTimeSettings;
+    rowHeight: number;
+    rtl: boolean;
+    activeView: TimelineViewType;
+    private get deltaOffset();
+    private get slotWidth();
+    get slotIndex(): number;
+    private get height();
+    private get interval();
+    private now;
+    private currentTimeTimeout;
+    private timeMarkerDiv;
+    constructor(renderer: Renderer2, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    removeTimeMarker(): void;
+    createTimeMarker: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentTimeMarkerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CurrentTimeMarkerService>;
+}
+
+/**
+ * @hidden
+ */
+interface NavigationMetadata {
+    treeList: TreeListComponent;
+    host: HTMLElement;
+    treeListElement: HTMLElement;
+    timelineElement: HTMLElement;
+    columns: QueryList<GanttColumnBase>;
+    data: any[];
+}
+/**
+ * @hidden
+ */
+interface TaskActivityStatus {
+    /**
+     * Represents the timeline task index of the task element which should have tabindex="0".
+     */
+    activeIndex: number;
+    /**
+     * Specifies if the active task should be focused.
+     */
+    isFocused: boolean;
+}
+
+/**
+ * @hidden
+ */
+declare class NavigationService implements OnDestroy {
+    private zone;
+    private renderer;
+    private scrollSyncService;
+    /**
+     * Notifies when the tasks' focused and interactive (tabindex) state has changed.
+     *
+     * All tasks are rendered with tabindex="-1".
+     * When one is clicked, or when some navigation key keyboard key is pressed, it should be focused, assigned the focus class, and its tabindex updated to 0.
+     * All other tasks should get -1 tabindex and have the focus class removed from them.
+     */
+    readonly taskStatusChanges: Subject<TaskActivityStatus>;
+    /**
+     * Specifies whether navigation is enabled.
+     */
+    get enabled(): boolean;
+    /**
+     * Used to retrieve read-only data about the currently active task.
+     */
+    get activeTask(): TaskActivityStatus;
+    /**
+     * Persists the expected Timeline focused task index.
+     * When the cells in the TreeList are navigated through, the expected Timeline focus target should also change,
+     * in order to allow tabbing from the TreeList to the same row in the Timeline.
+     */
+    set activeTimelineIndex(index: number);
+    get activeTimelineIndex(): number;
+    /**
+     * Persists the expected TreeList focused cell coords.
+     * When the tasks in the Timeline are navigated through, the expected TreeList focus target should also change,
+     * in order to allow back-tabbing from the Timeline to the same row in the TreeList.
+     */
+    private set activeTreeListCell(value);
+    private get activeTreeListCell();
+    /**
+     * Keeps track of whether the Timeline part is focused.
+     * Used when the index of the task elements change (tasks are changed, pushed to, spliced from, etc.)
+     * and their status should be updated accordingly.
+     */
+    private isTimelineFocused;
+    /**
+     * The TreeList row index takes into account the header and filter rows.
+     * Used when translating Timeline task indices to TreeList row indices.
+     */
+    private get treeListHeaderRowsCount();
+    /**
+     * Keeps track of which part has last been focused.
+     * Used when calling `gantt.focus()` to determine which part of the component should receive focus.
+     */
+    private treeListLastActive;
+    /**
+     * Keeps track of which part has last been focused.
+     * Used when calling `gantt.focus()` to determine which part of the component should receive focus.
+     */
+    private timelineLastActive;
+    private metadata;
+    private bar;
+    private _enabled;
+    private _activeTimelineIndex;
+    private _activeTreeListCell;
+    private eventListenerDisposers;
+    constructor(zone: NgZone, renderer: Renderer2, scrollSyncService: ScrollSyncService);
+    initialize(metadata: NavigationMetadata): void;
+    ngOnDestroy(): void;
+    /**
+     * Focuses either the last active TreeList cell, or the last active Timeline task,
+     * dependening on which of the two last held focus.
+     *
+     * Focuses the first TreeList cell by default.
+     */
+    focusLastActiveItem(): void;
+    /**
+     * Focuses the targeted TreeList cell regardless of the last peresisted target.
+     */
+    focusCell(rowIndex: number, colIndex: number): void;
+    /**
+     * Focuses the targeted Timeline task regardless of the last peresisted target.
+     */
+    focusTask(index: number): void;
+    /**
+     * Updates the focus target flags and notifies the active task to update its focused state.
+     */
+    handleTimelineFocusIn({ target }: FocusEvent): void;
+    /**
+     * Updates the timeline focus state flag and notifies the active task to update its focused state.
+     * Restore bar to tab order when focus leaves Timeline.
+     */
+    handleTimelineFocusOut({ relatedTarget }: FocusEvent): void;
+    /**
+     * Updates the focus target flags and corrects the TreeList focus target if needed.
+     * As the TreeList will keep its last focused cell with tabindex="0",
+     * this methods forcefully focuses the correct cell,
+     * when navigating in the Timeline has updated the expected TreeList focus target.
+     */
+    handleTreeListFocusIn(event: FocusEvent): void;
+    /**
+     * Handle focus leaving TreeList.
+     * Restore bar to tab order and demote the cell when focus leaves TreeList.
+     */
+    handleTreeListFocusOut(event: FocusEvent): void;
+    updateActiveTimeLineIndex(index: number): void;
+    updateActiveTreeListCell(): void;
+    /**
+     * Fires the `taskStatusChanges` event with active and focused status retrieved from
+     * `this.activeTimelineIndex` and `this.isTimelineFocused`.
+     */
+    notifyTaskStatusChange(): void;
+    /**
+     * Scrolls horizontally to the beginning of the target task if the beginning of its content is not in the viewport.
+     */
+    scrollHorizontallyToTask(): void;
+    /**
+     * Filters for task mousedown in the Timeline.
+     */
+    private handleTimelineMousedown;
+    /**
+     * Focus the TreeList on TreeList mousedown.
+     * A nasty hack to trick `handleTreeListFocusIn` into regarding the previous focus target as again the TreeList.
+     * Otherwise cell clicks are wrongly overwritten in `handleTreeListFocusIn` and the click focus target is not respected.
+     */
+    private focusTreeList;
+    /**
+     * Intercept Tab key on splitter bar to focus the TreeList.
+     * Since TreeList first cell has tabindex="-1", Tab from bar won't naturally focus it.
+     * This handler manually focuses the cell and prevents default Tab to avoid jumping to Timeline.
+     */
+    private handleSplitterBarKeydown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+/**
+ * @hidden
+ *
+ * Represents an instance of a Gantt timeline options.
+ *
+ * @hidden
+ */
+interface TimelineOptions {
+    /**
+     * The width of the time slot headers. Values are treated as pixels.
+     *
+     * @default 100
+     */
+    slotWidth?: number;
+    /**
+     * The view type.
+     */
+    type?: TimelineViewType;
+    /**
+     * The start of the work day.
+     */
+    workDayStart?: string;
+    /**
+     * The end of the work day.
+     */
+    workDayEnd?: string;
+    /**
+     * The start of the work week (index based).
+     */
+    workWeekStart?: Day;
+    /**
+     * The end of the work week (index based).
+     */
+    workWeekEnd?: Day;
+    /**
+     * The options for formatting the Group Headers and Column Headers in each individual Timeline Header.
+     */
+    timelineHeadersDateFormat?: TimelineHeaderDateFormat;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class TimelineBaseViewService {
+    protected intlService: IntlService;
+    protected mapper: MappingService;
+    options: TimelineOptions;
+    protected _viewStart: number;
+    constructor(intlService: IntlService, mapper: MappingService);
+    get viewStart(): number;
+    /**
+     *
+     * @param tasks - The tasks which are going to be rendered in the table
+     * @returns {number}
+     */
+    abstract getSlots(tasks: any[]): Array<Slot[]>;
+    /**
+     *
+     * @param tasks - The tasks which are going to be rendered in the table
+     * @returns {Array<Object>} - A collection containing the day and hours slots
+     * Used to render the number of columns and the header
+     */
+    abstract getTableWidth(tasks: any[]): number;
+    /**
+     * Gets the date which will be used for the first slot.
+     * The first slot should not be the range start - it might not leave space for dependency connections drawn on the left.
+     */
+    abstract getStartOffset(rangeStart: Date): Date;
+    /**
+     * Gets the date which will be used for the last slot.
+     * The last slot should not be the range end - it might not leave space for dependency connections drawn on the right.
+     */
+    abstract getEndOffset(rangeEnd: Date): Date;
+    /**
+     *
+     * @param tasks - The tasks which are going to be rendered in the table
+     * @returns {Object} - An object containing the range start and end dates
+     */
+    protected getRange(tasks: any): DateRange;
+    /**
+     *
+     * @param start - The tasks' range start date
+     * @param end - The tasks' range end date
+     * @returns {Array<Object>} - A collection containing the hour slots
+     */
+    protected getHours(start: any, end: any, customDateFormat?: string | DateFormatOptions$1): Array<Slot>;
+    /**
+     *
+     * @param start - The tasks' range start date
+     * @param end - The tasks' range end date
+     * @returns {Array<Object>} - A collection containing the day slots
+     */
+    protected getDays(start: any, end: any, customDateFormat?: string | DateFormatOptions$1): Array<Slot>;
+    protected getWeeks(start: any, end: any, customDateFormat?: string | DateFormatOptions$1): Array<Slot>;
+    protected getMonths(start: any, end: any, isMainViewType?: boolean, customDateFormat?: string | DateFormatOptions$1): Array<Slot>;
+    protected getYears(start: any, end: any, customDateFormat?: any): Array<Slot>;
+}
+
+/**
+ * @hidden
+ */
+declare class TimelineViewService {
+    private injector;
+    viewChange: EventEmitter<any>;
+    constructor(injector: Injector);
+    service(view: TimelineViewType): TimelineBaseViewService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineViewService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimelineViewService>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class GanttTaskBase implements OnInit, OnChanges, OnDestroy {
+    mapper: MappingService;
+    private timelineViewService;
+    private dependencyDomService;
+    private optionChangesService;
+    private cdr;
+    private navigationService;
+    wrapperClass: boolean;
+    get taskIndexAttribute(): number;
+    /**
+     * Points to the `.k-task` element of the template (present in all three task types).
+     */
+    taskElement: ElementRef<HTMLElement>;
+    dataItem: any;
+    index: number;
+    level: number;
+    renderDependencyDragClues: boolean;
+    selectable: boolean;
+    isSelected: (dataItem: object) => boolean;
+    activeView: TimelineViewType;
+    taskClass: TaskClassFn;
+    get ariaSelected(): string;
+    get slotUnitDuration(): number;
+    get viewService(): TimelineBaseViewService;
+    get slotWidth(): number;
+    get taskWidth(): number;
+    /**
+     * The `left` style prop has to be applied to the host element (.k-task-wrap), as the drag clue elements are displayed on .k-task-wrap hover.
+     * Applying the `left` offset to the inner .k-task element leaves the .k-task-wrap element rendered with an offset of 0 somewhere on the left
+     * and hovering just the .k-task element doesn't expose the drag clues.
+     * Additionally, positioning the entire container takes care of positioning the hints as well.
+     */
+    get taskOffset(): number;
+    get completionOverlayWidth(): number;
+    draggedCompletionWidth: number;
+    protected taskDragService: TaskDragService;
+    protected completionDragResult: number;
+    private subscriptions;
+    constructor(mapper: MappingService, // left public to be available for usage in the templates
+    timelineViewService: TimelineViewService, dependencyDomService: DependencyDomService, optionChangesService: OptionChangesService, cdr: ChangeDetectorRef, navigationService: NavigationService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private updateActiveState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTaskBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttTaskBase, "kendo-gantt-task-base", never, { "dataItem": { "alias": "dataItem"; "required": false; }; "index": { "alias": "index"; "required": false; }; "level": { "alias": "level"; "required": false; }; "renderDependencyDragClues": { "alias": "renderDependencyDragClues"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "taskClass": { "alias": "taskClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class TaskDragService {
+    private mapper;
+    private zone;
+    taskDraggable: boolean;
+    drag: Subject<InternalTaskDragEvent>;
+    dragEnd: Subject<InternalTaskDragEvent>;
+    dragStart: Subject<DragTargetDragStartEvent>;
+    tasksContainer: HTMLElement;
+    tasksContainerRect: DOMRect;
+    scrollableContainer: HTMLElement;
+    currentDragTask: GanttTaskBase;
+    currentDragTaskRect: DOMRect;
+    leftDragHandle: boolean;
+    rightDragHandle: boolean;
+    completionRatioHandle: boolean;
+    private tasks;
+    private editedProp;
+    private prevX;
+    private prevWidth;
+    private prevLeft;
+    private prevScrollLeft;
+    private newRange;
+    private offsetX;
+    private maxWidth;
+    private newCompletionRatio;
+    constructor(mapper: MappingService, zone: NgZone);
+    registerTask(task: GanttTaskBase): void;
+    onDragStart(args: DragTargetDragStartEvent): void;
+    onDrag(args: DragTargetDragEvent): void;
+    onDragEnd(args: DragTargetDragEndEvent): void;
+    private calculateMarquee;
+    private calculateStartEnd;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskDragService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskDragService>;
+}
+
+/**
+ * Defines a template for the entire Task tooltip.
+ * Place an `<ng-template>` tag with the `kendoGanttTaskTooltipTemplate` directive inside the `<kendo-gantt>` tag to set the template.
+ *
+ * The template context uses the related data item.
+ *
+ * @example
+ * ```ts-preview
+ * _@Component({
+ *      selector: 'my-app',
+ *      template: `
+ *          <kendo-gantt [kendoGanttHierarchyBinding]="data">
+ *              <ng-template kendoGanttTaskTooltipTemplate let-dataItem>
+ *                  <div [style]="'color: white; font-size: 8px;'">
+ *                      {{ dataItem.title }} - {{ dataItem.completionRatio * 100 }}% complete;
+ *                  </div>
+ *              </ng-template>
+ *          </kendo-gantt>
+ *      `
+ * })
+ * class AppComponent {
+ *     public data: any[] = sampleTasks;
+ * }
+ * ```
+ */
+declare class GanttTaskTooltipTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTaskTooltipTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttTaskTooltipTemplateDirective, "[kendoGanttTaskTooltipTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ *
+ * Needed to keep the Gantt's LocalizationService reference and be able to use it component's inside the TabStrip
+ */
+declare class GanttLocalizationService {
+    private localizationService;
+    constructor(localizationService: LocalizationService);
+    get(token: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttLocalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GanttLocalizationService>;
+}
+
+/**
+ * Customizes the content of the tooltip that appears when you drag or resize a Gantt task.
+ * Place the `kendoGanttTaskDragTooltipTemplate` directive on an `<ng-template>` tag inside the `<kendo-gantt>` component.
+ *
+ * The template context provides an object with the following properties:
+ * * `start`&mdash;The updated start date during the drag operation.
+ * * `end`&mdash;The updated end date during the drag operation.
+ * * `completionRatio`&mdash;The completion ratio of the task as a decimal value between 0 and 1.
+ * * `task`&mdash;The original data item of the task being dragged. Contains the properties of the [`GanttTask`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/gantttask) interface.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt
+ *    [kendoGanttHierarchyBinding]="data"
+ *    kendoGanttTaskDrag
+ *    (taskDragEnd)="onDragEnd($event)">
+ *    <ng-template kendoGanttTaskDragTooltipTemplate let-dragData>
+ *        <div> {{ dragData.task.title }} </div>
+ *        <div> Start: {{ dragData.start | date: 'h:mm a' }} </div>
+ *        <div> End: {{ dragData.end | date: 'h:mm a' }} </div>
+ *    </ng-template>
+ * </kendo-gantt>
+ * ```
+ */
+declare class GanttTaskDragTooltipTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTaskDragTooltipTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttTaskDragTooltipTemplateDirective, "[kendoGanttTaskDragTooltipTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttTimelineComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private scrollSyncService;
+    private dependencyDomService;
+    private renderer;
+    private zone;
+    private currentTimeMarkerService;
+    private localization;
+    private taskDragService;
+    /**
+     * Represents the scrollable container of the timeline content.
+     * Used externally by the DependencyDragCreateDirective.
+     */
+    timelineContent: ElementRef<HTMLElement>;
+    timelineColumns: ElementRef<HTMLElement>;
+    timelineHeaderWrap: ElementRef<HTMLElement>;
+    tasksContainer: ElementRef<HTMLElement>;
+    private tooltip;
+    /**
+     * Represents the view container ref used for rendering the dependency drag popop.
+     * Used externally by the DependencyDragCreateDirective.
+     */
+    dragPopupContainer: ViewContainerRef;
+    /**
+     * Represents the polyline element used for rendering the dependency drag editing interaction.
+     * Used externally by the DependencyDragCreateDirective.
+     */
+    dependencyDragCreatePolyline: ElementRef<SVGPolylineElement>;
+    rows: ViewItem[];
+    slots: any[];
+    groupSlots: any[];
+    tableWidth: number;
+    activeView: TimelineViewType;
+    taskContentTemplate: TemplateRef<any>;
+    taskTemplate: TemplateRef<any>;
+    summaryTaskTemplate: TemplateRef<any>;
+    taskClass: TaskClassFn;
+    renderDependencyDragClues: boolean;
+    dragScrollSettings: DragScrollSettings;
+    currentTimeMarker: boolean | CurrentTimeSettings;
+    customTooltipTemplate: GanttTaskTooltipTemplateDirective;
+    customDragTooltipTemplate: GanttTaskDragTooltipTemplateDirective;
+    tooltipOptions: TaskTooltipOptions;
+    selectable: boolean;
+    isTaskSelected: (item: object) => boolean;
+    isExpanded: (item: object) => boolean;
+    dependencies: any[];
+    timelineContainerPress: EventEmitter<any>;
+    timelineContainerDrag: EventEmitter<any>;
+    timelineContainerRelease: EventEmitter<any>;
+    /**
+     * Specifies whether the draggable will attach or detach its pointer event listeners.
+     */
+    get draggableEnabled(): boolean;
+    task: GanttTask;
+    dragResult: {
+        start: Date;
+        end: Date;
+        completionRatio: number;
+        task: any;
+    };
+    dragging: boolean;
+    completion: boolean;
+    marquee: {
+        show: boolean;
+        left: number;
+        width: number;
+    };
+    dragOffset: number;
+    private subscriptions;
+    private popupRef;
+    constructor(scrollSyncService: ScrollSyncService, dependencyDomService: DependencyDomService, renderer: Renderer2, zone: NgZone, currentTimeMarkerService: CurrentTimeMarkerService, localization: GanttLocalizationService, taskDragService: TaskDragService);
+    ngOnChanges(changes: SimpleChanges): void;
+    trackBySlotIndex(index: number, item: any): string;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    isNonWorking(item: any): boolean;
+    messageFor(token: string): string;
+    private createTimeMarker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTimelineComponent, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttTimelineComponent, "kendo-gantt-timeline", never, { "rows": { "alias": "rows"; "required": false; }; "slots": { "alias": "slots"; "required": false; }; "groupSlots": { "alias": "groupSlots"; "required": false; }; "tableWidth": { "alias": "tableWidth"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "taskContentTemplate": { "alias": "taskContentTemplate"; "required": false; }; "taskTemplate": { "alias": "taskTemplate"; "required": false; }; "summaryTaskTemplate": { "alias": "summaryTaskTemplate"; "required": false; }; "taskClass": { "alias": "taskClass"; "required": false; }; "renderDependencyDragClues": { "alias": "renderDependencyDragClues"; "required": false; }; "dragScrollSettings": { "alias": "dragScrollSettings"; "required": false; }; "currentTimeMarker": { "alias": "currentTimeMarker"; "required": false; }; "customTooltipTemplate": { "alias": "customTooltipTemplate"; "required": false; }; "customDragTooltipTemplate": { "alias": "customDragTooltipTemplate"; "required": false; }; "tooltipOptions": { "alias": "tooltipOptions"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "isTaskSelected": { "alias": "isTaskSelected"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "dependencies": { "alias": "dependencies"; "required": false; }; }, { "timelineContainerPress": "timelineContainerPress"; "timelineContainerDrag": "timelineContainerDrag"; "timelineContainerRelease": "timelineContainerRelease"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class EditService {
+    private mapper;
+    showEditingDialog: Subject<boolean>;
+    taskDelete: Subject<object>;
+    editEvent: Subject<EditEvent>;
+    addEvent: Subject<TaskAddEvent>;
+    taskFormGroup: FormGroup;
+    dataItem: any;
+    getSelectedItem: () => any;
+    hasChildren: (node: any) => boolean;
+    fetchChildren: (node: any) => Observable<any[]> | any[];
+    set dependencies(items: any[]);
+    get dependencies(): any[];
+    predecessors: GanttDependency[];
+    successors: GanttDependency[];
+    updatedItems: any[];
+    deletedItems: any[];
+    constructor(mapper: MappingService);
+    createEditDialog(dataItem: any, taskFormGroup: FormGroup, dependencies: any[]): void;
+    closeEditDialog(): void;
+    triggerEditEvent(editResultType: EditResultType): void;
+    updateDependencies(item: GanttDependency): void;
+    getCreatedDependencies(): any[];
+    deleteDependency(item: GanttDependency): void;
+    loadTasks(initialValues: any[], isInitializer?: boolean): Observable<any[]>;
+    private getElementById;
+    private itemIndex;
+    private isNew;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EditService>;
+}
+
+/**
+ * Represents the options for the pane that contains the treelist section.
+ */
+interface TreeListPaneOptions {
+    /**
+     * Specifies if the user can hide the pane.
+     */
+    collapsible?: boolean;
+    /**
+     * Specifies if the pane is collapsed initially.
+     */
+    collapsed?: boolean;
+}
+/**
+ * Represents the options for the pane that contains the timeline section.
+ */
+interface TimelinePaneOptions extends TreeListPaneOptions {
+    /**
+     * Sets the initial size of the pane. The value must be between the `min` and `max` properties.
+     */
+    size?: string;
+    /**
+     * Sets the minimum size of the pane.
+     */
+    min?: string;
+    /**
+     * Sets the maximum size of the pane.
+     */
+    max?: string;
+    /**
+     * Specifies if the user can resize the pane.
+     */
+    resizable?: boolean;
+}
+
+/**
+ * Defines a template for the entire task component.
+ * Place an `<ng-template>` tag with the `kendoGanttTaskTemplate` directive inside the `<kendo-gantt>` tag to set the template.
+ *
+ * The template context uses the current data item. The following field is also available:
+ * - `elementWidth`&mdash;The calculated width in pixels of the current task wrapper element, based on its start and end date.
+ * Use `let-elementWidth="elementWidth"` to access it in the template.
+ * This helps you render custom elements for task progress.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt [kendoGanttHierarchyBinding]="data">
+ *   <ng-template kendoGanttTaskTemplate let-dataItem let-elementWidth="elementWidth">
+ *     {{ dataItem.title }} - {{ dataItem.completionRatio * 100 }}% complete
+ *   </ng-template>
+ * </kendo-gantt>
+ * ```
+ */
+declare class GanttTaskTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTaskTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttTaskTemplateDirective, "[kendoGanttTaskTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defines a template for the entire summary task component.
+ * Place an `<ng-template>` tag with the `kendoGanttSummaryTaskTemplate` directive inside the `<kendo-gantt>` tag to set the template.
+ *
+ * The template context uses the current data item. The following field is also available:
+ * - `elementWidth`&mdash;The calculated width in pixels of the current summary task wrapper element, based on its start and end date.
+ * Use `let-elementWidth="elementWidth"` to access it in the template.
+ * This helps you render custom elements for summary task progress.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt [kendoGanttHierarchyBinding]="data">
+ *    <ng-template kendoGanttSummaryTaskTemplate let-dataItem let-elementWidth="elementWidth">
+ *      <div [style]="'color: white; font-size: 8px;'">
+ *          {{ dataItem.title }} - {{ dataItem.completionRatio * 100 }}% complete; width: {{ elementWidth }}
+ *      </div>
+ *    </ng-template>
+ * </kendo-gantt>
+ * ```
+ */
+declare class GanttSummaryTaskTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttSummaryTaskTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttSummaryTaskTemplateDirective, "[kendoGanttSummaryTaskTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defines a template for the text content section of the task component.
+ * Place an `<ng-template>` tag with the `kendoGanttTaskContentTemplate` directive inside the `<kendo-gantt>` tag to set the template.
+ *
+ * The template context uses the current data item.
+ *
+ * @example
+ * ```ts-preview
+ * _@Component({
+ *    selector: 'my-app',
+ *    template: `
+ *        <kendo-gantt [kendoGanttHierarchyBinding]="data">
+ *            <ng-template kendoGanttTaskContentTemplate let-dataItem>
+ *                {{ dataItem.title }} - {{ dataItem.completionRatio * 100 }}% complete
+ *            </ng-template>
+ *        </kendo-gantt>
+ *    `
+ * })
+ * class AppComponent {
+ *    public data: any[] = sampleTasks;
+ * }
+ * ```
+ */
+declare class GanttTaskContentTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTaskContentTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttTaskContentTemplateDirective, "[kendoGanttTaskContentTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the toolbar template of the Gantt.
+ *
+ * The template context includes:
+ * - `position`&mdash;The position where the toolbar template renders. Possible values are `'top'` and `'bottom'`.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt [kendoGanttHierarchyBinding]="data" [style.height.px]="400">
+ *  <ng-template kendoGanttToolbarTemplate [position]="position" let-position="position">
+ *    <button kendoButton (click)="onClick()">Custom action</button>
+ *  </ng-template>
+ * </kendo-gantt>
+ * ```
+ */
+declare class ToolbarTemplateDirective {
+    templateRef: TemplateRef<any>;
+    _position: ToolbarPosition;
+    /**
+     * Sets the Gantt Toolbar that uses this template.
+     *
+     * Possible values:
+     * - `top`&mdash;Renders the template in the top toolbar (if present) only.
+     * - `bottom`&mdash;Renders the template in the bottom toolbar (if present) only.
+     * - `both`&mdash;Renders the template in both toolbars (if present).
+     */
+    set position(position: ToolbarPosition);
+    get position(): ToolbarPosition;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarTemplateDirective, "[kendoGanttToolbarTemplate]", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the arguments for the Gantt `expand` and `collapse` events.
+ *
+ */
+declare class ExpandEvent {
+    /** @hidden */
+    constructor();
+    /**
+     * The expanded or collapsed data item.
+     */
+    dataItem: any;
+}
+
+/**
+ * Serves as the base class for the timeline view components of the Gantt.
+ *
+ * @example
+ * ```typescript
+ * export class CustomTimelineViewComponent extends ViewBase {
+ *   public readonly type: TimelineViewType = 'custom';
+ * }
+ * ```
+ */
+declare abstract class ViewBase implements OnChanges {
+    private optionChangesService;
+    private dependencyDomService;
+    /**
+     * Sets the width of the time slot headers in pixels.
+     *
+     * @default 100
+     */
+    slotWidth: number;
+    /**
+     * Sets the date format for the Grouped and Column headers.
+     */
+    timelineHeadersDateFormat: TimelineHeaderDateFormat;
+    /**
+     * Specifies the current time marker settings.
+     * If you do not set a value, the component uses the value from the Gantt component
+     * [`currentTimeMarker`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#currentTimeMarker) property.
+     */
+    currentTimeMarker: boolean | CurrentTimeSettings;
+    /**
+     * Specifies the type for the view (`day`, `week`, `month`, or `year`).
+     */
+    abstract type: TimelineViewType;
+    /**
+     *
+     * @hidden
+     */
+    constructor(optionChangesService: OptionChangesService, dependencyDomService: DependencyDomService);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewBase, "kendo-gantt-view-base", never, { "slotWidth": { "alias": "slotWidth"; "required": false; }; "timelineHeadersDateFormat": { "alias": "timelineHeadersDateFormat"; "required": false; }; "currentTimeMarker": { "alias": "currentTimeMarker"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provides the arguments for the Gantt [`selectionChange`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#selectionchange) event.
+ */
+interface SelectionChangeEvent {
+    /**
+     * Describes how the selection was changed.
+     * - `select`&mdash;Selects all specified `items` and removes all other persisted ones.
+     * - `remove`&mdash;Removes only the specified `items` and leaves all others unchanged.
+     */
+    action: 'select' | 'remove';
+    /**
+     * Lists the items that change.
+     */
+    items: any[];
+    /**
+     * The Gantt component that triggers the event.
+     */
+    sender: GanttComponent;
+}
+
+/**
+ * Represents the options for the `filterable` setting of the Gantt.
+ * @hidden
+ */
+type FilterableSettings = FilterableSettings$1;
+
+/**
+ * Represents the [Kendo UI Gantt component for Angular](https://www.telerik.com/kendo-angular-ui/components/gantt).
+ *
+ * Use the Gantt component to display and manage project tasks and dependencies in a timeline view.
+ *
+ * @example
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { GanttComponent, DependencyType } from '@progress/kendo-angular-gantt';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-gantt
+ *       [style.height.px]="500"
+ *       [kendoGanttHierarchyBinding]="data"
+ *       childrenField="subtasks"
+ *       [dependencies]="dependencies">
+ *       <kendo-gantt-column field="title" title="Task" [width]="200" [expandable]="true"></kendo-gantt-column>
+ *       <kendo-gantt-column field="start" title="Start" format="dd-MMM-yyyy" [width]="120"></kendo-gantt-column>
+ *       <kendo-gantt-column field="end" title="End" format="dd-MMM-yyyy" [width]="120"></kendo-gantt-column>
+ *       <kendo-gantt-timeline-day-view></kendo-gantt-timeline-day-view>
+ *       <kendo-gantt-timeline-week-view></kendo-gantt-timeline-week-view>
+ *       <kendo-gantt-timeline-month-view></kendo-gantt-timeline-month-view>
+ *     </kendo-gantt>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public data: Task[] = [
+ *     {
+ *       id: 1,
+ *       title: 'Planning',
+ *       start: new Date('2024-01-01'),
+ *       end: new Date('2024-01-05'),
+ *       subtasks: []
+ *     }
+ *   ];
+ *   public dependencies = [
+ *     { id: 1, fromId: 1, toId: 2, type: DependencyType.FS }
+ *   ];
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are:
+ * {@link GanttColumnComponent},
+ * {@link GanttSpanColumnComponent},
+ * {@link GanttColumnGroupComponent},
+ * {@link TimelineDayViewComponent},
+ * {@link TimelineWeekViewComponent},
+ * {@link TimelineMonthViewComponent},
+ * {@link TimelineYearViewComponent},
+ * {@link CustomMessagesComponent}.
+ */
+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<HTMLElement>;
+    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 drag 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`.
+     */
+    taskDragTooltipTemplate: GanttTaskDragTooltipTemplateDirective;
+    /**
+     * @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<ToolbarTemplateDirective>;
+    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<GanttColumnBase>);
+    get columns(): QueryList<GanttColumnBase>;
+    /**
+     * Sets the fields used to extract task data from the `data` array items.
+     * The `id` field is also used as a unique identifier for TreeList data items.
+     * If not set, task data items must match the [`GanttTask`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/gantttask) interface.
+     */
+    set taskModelFields(fields: GanttTaskModelFields);
+    /**
+     * Sets the fields used to extract dependency data from the `dependencies` array items.
+     * If not set, dependency data items must match the [`GanttDependency`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttdependency) interface.
+     */
+    set dependencyModelFields(fields: GanttDependencyModelFields);
+    /**
+     * A query list of all declared views.
+     */
+    views: QueryList<ViewBase>;
+    /**
+     * Sets the active timeline view.
+     * @default 'week'
+     */
+    set activeView(view: TimelineViewType);
+    get activeView(): TimelineViewType;
+    /**
+     * @hidden
+     *
+     */
+    get activeViewCurrentTimeMarker(): boolean | CurrentTimeSettings;
+    /**
+     * Gets or sets the Gantt data.
+     * The task data items must match the [`GanttTask`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/gantttask) interface or use [`taskModelFields`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#taskmodelfields).
+     */
+    set data(data: any[]);
+    get data(): any[];
+    /**
+     * Specifies a callback to determine if a task is selected ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/selection#custom-selection)).
+     * Set [`selectable`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#selectable) to `true` to use this callback.
+     */
+    isSelected: (dataItem: object) => boolean;
+    /**
+     * Specifies a callback to validate new dependencies.
+     * Use this callback to control the valid dependencies that users can create ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/editing/dependencies-drag-create#validation)).
+     */
+    validateNewDependency: (dependency: object) => boolean;
+    /**
+     * Fires when the Gantt selection changes through user interaction.
+     * The event data contains the affected items and the action type.
+     */
+    selectionChange: EventEmitter<SelectionChangeEvent>;
+    /**
+     * Enables or disables selection in the Gantt ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/selection#custom-selection)).
+     * Set to `true` to allow selection.
+     * > When set to `true`, the [`isSelected`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#isselected) callback has to be provided.
+     * > When applied, the [`SelectableDirective`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/selectabledirective) sets `selectable` to `true` internally.
+     * @default false
+     */
+    selectable: boolean;
+    /**
+     * Configures the toolbar position and content.
+     * Set `position`, `addTaskTool`, and `viewSelectorTool` as needed.
+     */
+    set toolbarSettings(value: ToolbarSettings);
+    get toolbarSettings(): ToolbarSettings;
+    /**
+     * Sets the `aria-label` attribute value for the toolbar.
+     * Use this to improve accessibility.
+     * @default "Toolbar"
+     *
+     * @remarks
+     * This property is related to accessibility.
+     */
+    toolbarAriaLabel: string;
+    /**
+     * Sets the callback function to retrieve child items for a data item.
+     */
+    set fetchChildren(fn: (dataItem: any) => Observable<object[]> | object[]);
+    get fetchChildren(): (dataItem: any) => Observable<object[]> | object[];
+    /**
+     * Sets the callback function to indicate if a data item has child items.
+     */
+    set hasChildren(fn: (dataItem: any) => boolean);
+    get hasChildren(): (dataItem: any) => boolean;
+    /**
+     * Sets the dependencies to display between tasks.
+     * Dependency data items must match the [`GanttDependency`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttdependency) interface or use [`dependencyModelFields`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#dependencymodelfields).
+     */
+    dependencies: any[];
+    /**
+     * Enables sorting for columns with a `field` option.
+     */
+    sortable: SortSettings;
+    /**
+     * Sets the descriptors for sorting the data.
+     */
+    sort: SortDescriptor[];
+    /**
+     * Enables filtering for columns with a `field` option.
+     * @default false
+     */
+    filterable: boolean;
+    /**
+     * Sets the descriptor for filtering the data.
+     */
+    filter: CompositeFilterDescriptor;
+    /**
+     * Sets the start time of the work day in `HH:mm` format.
+     * @default "08:00"
+     */
+    workDayStart: string;
+    /**
+     * Sets the end time of the work day in `HH:mm` format.
+     * @default "17:00"
+     */
+    workDayEnd: string;
+    /**
+     * Sets the start day of the work week (index based).
+     * @default 1
+     */
+    workWeekStart: Day;
+    /**
+     * Sets the end day of the work week (index based).
+     * @default 5
+     */
+    workWeekEnd: Day;
+    /**
+     * Enables keyboard navigation for the Gantt.
+     * By default, navigation is enabled for the TreeList and Timeline parts of the component ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/keyboard-navigation)).
+     * @default true
+     *
+     * @remarks
+     * This property is related to accessibility.
+     */
+    navigable: boolean;
+    /**
+     * Sets the options for 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;
+    /**
+     * Sets the options for the treelist splitter pane.
+     * By default the pane is collapsible and not collapsed.
+     */
+    set treeListPaneOptions(value: TreeListPaneOptions);
+    get treeListPaneOptions(): TreeListPaneOptions;
+    /**
+     * Sets a function to apply custom CSS classes to each task.
+     * The function receives the task data item.
+     */
+    set taskClass(fn: TaskClassFn);
+    get taskClass(): TaskClassFn;
+    /**
+     * Sets a function to apply custom CSS classes to each data row.
+     * The function receives the row data item.
+     */
+    set rowClass(fn: RowClassFn);
+    get rowClass(): RowClassFn;
+    /**
+     * Gets the name of the field that contains the unique identifier for task data items.
+     * @default "id"
+     */
+    get taskIdField(): any;
+    /**
+     * Sets a callback function to indicate if a data item is expanded.
+     * If not set, all items are expanded and no expand icons are shown.
+     */
+    isExpanded: (item: object) => boolean;
+    /**
+     * Enables automatic resizing of columns to fit their content.
+     * @default false
+     */
+    columnsAutoSize: boolean;
+    /**
+     * Sets the current time marker settings for the Gantt.
+     * Applies to all views unless overridden by the settings of a particular view.
+     * @default true
+     */
+    currentTimeMarker: boolean | CurrentTimeSettings;
+    /**
+     * Enables the column menu for all columns.
+     * @default false
+     */
+    columnMenu: boolean | ColumnMenuSettings;
+    /**
+     * Enables reordering of the columns by dragging their header cells.
+     * @default false
+     */
+    columnsReorderable: boolean;
+    /**
+     * Enables resizing of the columns by dragging the header cell edges (resize handles).
+     * @default false
+     */
+    columnsResizable: boolean;
+    /**
+     * Defines the settings for auto-scrolling during dragging when the pointer moves outside the container ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/editing/dependencies-drag-create#auto-scrolling)).
+     */
+    set dragScrollSettings(settings: DragScrollSettings);
+    get dragScrollSettings(): DragScrollSettings;
+    /**
+     * Sets the options for the task tooltip, such as `position`, `callout`, and `showAfter`.
+     * @default { position: 'top', callout: true, showAfter: 100 }
+     */
+    taskTooltipOptions: TaskTooltipOptions;
+    /**
+     * Fires when a row is expanded.
+     */
+    rowExpand: EventEmitter<ExpandEvent>;
+    /**
+     * Fires when a Gantt task in the timeline pane is double-clicked.
+     * The event data contains the clicked task. Use this event to open a task editing dialog if needed.
+     */
+    taskDblClick: EventEmitter<TaskClickEvent>;
+    /**
+     * Fires when a cell is double-clicked.
+     */
+    cellDblClick: EventEmitter<CellClickEvent>;
+    /**
+     * Fires when an edited cell is closed.
+     */
+    cellClose: EventEmitter<CellCloseEvent>;
+    /**
+     * Fires when the user clicks the `Delete` button in the task editing dialog,
+     * the task delete icon, or presses the `Delete` key on a focused task.
+     * Use this event to open a confirmation dialog if needed.
+     */
+    taskDelete: EventEmitter<TaskDeleteEvent>;
+    /**
+     * Fires when a row is collapsed.
+     */
+    rowCollapse: EventEmitter<ExpandEvent>;
+    /**
+     * Fires when the user confirms deleting a task.
+     */
+    remove: EventEmitter<TaskEditEvent>;
+    /**
+     * Fires when the user cancels editing a task.
+     */
+    cancel: EventEmitter<TaskEditEvent>;
+    /**
+     * Fires when the user saves an edited task.
+     */
+    save: EventEmitter<TaskEditEvent>;
+    /**
+     * Fires when the user adds a task.
+     */
+    taskAdd: EventEmitter<TaskAddEvent>;
+    /**
+     * Fires when the user adds a dependency by dragging [see example](https://www.telerik.com/kendo-angular-ui/components/gantt/editing/dependencies-drag-create#basic-concepts).
+     */
+    dependencyAdd: EventEmitter<DependencyAddEvent>;
+    /**
+     * Fires when there are changes in the Gantt sorting.
+     * Handle this event to sort the data.
+     */
+    sortChange: EventEmitter<SortDescriptor[]>;
+    /**
+     * Fires when there are changes in the Gantt filtering.
+     * Handle this event to filter the data.
+     */
+    filterChange: EventEmitter<CompositeFilterDescriptor>;
+    /**
+     * Fires when the filter or sort state changes.
+     */
+    dataStateChange: EventEmitter<DataStateChangeEvent>;
+    /**
+     * Fires when the collapsed state of the treelist pane changes.
+     */
+    treeListPaneCollapsedChange: EventEmitter<boolean>;
+    /**
+     * Fires when the collapsed state of the timeline pane changes.
+     */
+    timelinePaneCollapsedChange: EventEmitter<boolean>;
+    /**
+     * Fires when the user resizes the timeline pane.
+     */
+    timelinePaneSizeChange: EventEmitter<string>;
+    /**
+     * Fires when the user selects a different view type.
+     * The event data contains the type of the new view.
+     */
+    activeViewChange: EventEmitter<TimelineViewType>;
+    /**
+     * Fires when the user completes resizing a column.
+     */
+    columnResize: EventEmitter<ColumnResizeEvent[]>;
+    /**
+     * Fires when the user completes reordering a column.
+     */
+    columnReorder: EventEmitter<ColumnReorderEvent>;
+    /**
+     * Fires when the user changes column visibility from the column menu or chooser.
+     */
+    columnVisibilityChange: EventEmitter<ColumnVisibilityChangeEvent>;
+    /**
+     * @hidden
+     *
+     * Fires when the user changes the locked state of the columns from the column menu or by reordering the columns.
+     */
+    columnLockedChange: EventEmitter<ColumnLockedChangeEvent>;
+    /**
+     * Fires when a cell is clicked.
+     */
+    cellClick: EventEmitter<CellClickEvent>;
+    /**
+     * Fires when a task is clicked.
+     */
+    taskClick: EventEmitter<TaskClickEvent>;
+    /**
+     * @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<any>;
+    /**
+     * @hidden
+     */
+    showEditingDialog: boolean;
+    /**
+     * @hidden
+     */
+    showConfirmationDialog: boolean;
+    /**
+     * @hidden
+     */
+    get isInEditMode(): boolean;
+    /**
+     * @hidden
+     */
+    showLicenseWatermark: boolean;
+    /**
+     * @hidden
+     */
+    licenseMessage?: LicenseMessage;
+    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<HTMLElement>, 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 was previously focused, focuses the first TreeList cell ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/keyboard-navigation#controlling-the-focus)).
+     */
+    focus(): void;
+    /**
+     * Focuses the specified cell in the TreeList ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/keyboard-navigation#controlling-the-focus)).
+     * @param rowIndex The row index.
+     * @param colIndex The column index.
+     */
+    focusCell(rowIndex: number, colIndex: number): void;
+    /**
+     * Focuses the specified task in the Timeline ([see example](https://www.telerik.com/kendo-angular-ui/components/gantt/keyboard-navigation#controlling-the-focus)).
+     * @param taskIndex The index of the task.
+     */
+    focusTask(taskIndex: number): void;
+    /**
+     * Sets the minimum width for the specified column so that its content fits.
+     * The Gantt must be resizable.
+     * @param column The column to auto-fit.
+     */
+    autoFitColumn(column: GanttColumnBase): void;
+    /**
+     * Adjusts the width of the specified columns to fit their content.
+     * If no columns are specified, fits all columns.
+     * The Gantt must be resizable to use this method.
+     * @param columns The columns to auto-fit.
+     */
+    autoFitColumns(columns?: Array<GanttColumnBase> | QueryList<GanttColumnBase>): void;
+    /**
+     * Clears loaded children for the data item so the Gantt fetches them again.
+     * @param dataItem The data item to reload.
+     * @param reloadChildren Whether to reload children.
+     */
+    reload(dataItem: any, reloadChildren?: boolean): void;
+    /**
+     * Changes the position of the specified column.
+     * The source column must be visible.
+     * @param source The column to move.
+     * @param destIndex The new position index.
+     * @param options Additional options.
+     */
+    reorderColumn(source: GanttColumnBase, destIndex: number, options?: ColumnReorderConfig): void;
+    /**
+     * Forces the Gantt to re-evaluate data items and re-render the rows and Timeline period, if needed.
+     * Also redraws dependencies and executes row-related callbacks.
+     */
+    updateView(): void;
+    /**
+     * Opens the task editing dialog for the specified data item.
+     * @param dataItem The task data item.
+     * @param formGroup The form group for editing.
+     */
+    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.
+     * @param dataItem The data item.
+     * @param column The column index, name, or object.
+     * @param formGroup The form group for editing.
+     */
+    editCell(dataItem: any, column: number | string | any, formGroup?: FormGroup): void;
+    /**
+     * Closes the currently edited cell.
+     */
+    closeCell(): void;
+    /**
+     * @hidden
+     */
+    handleCellClose(e: CellCloseEvent$1): 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: SelectionChangeEvent$1): void;
+    /**
+     * @hidden
+     */
+    handleTreeListCellClick(event: CellClickEvent$1): 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<GanttComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttComponent, "kendo-gantt", ["kendoGantt"], { "roleDescription": { "alias": "aria-roledescription"; "required": false; }; "role": { "alias": "role"; "required": false; }; "taskModelFields": { "alias": "taskModelFields"; "required": false; }; "dependencyModelFields": { "alias": "dependencyModelFields"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "data": { "alias": "data"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "validateNewDependency": { "alias": "validateNewDependency"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "toolbarSettings": { "alias": "toolbarSettings"; "required": false; }; "toolbarAriaLabel": { "alias": "toolbarAriaLabel"; "required": false; }; "fetchChildren": { "alias": "fetchChildren"; "required": false; }; "hasChildren": { "alias": "hasChildren"; "required": false; }; "dependencies": { "alias": "dependencies"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "workDayStart": { "alias": "workDayStart"; "required": false; }; "workDayEnd": { "alias": "workDayEnd"; "required": false; }; "workWeekStart": { "alias": "workWeekStart"; "required": false; }; "workWeekEnd": { "alias": "workWeekEnd"; "required": false; }; "navigable": { "alias": "navigable"; "required": false; }; "timelinePaneOptions": { "alias": "timelinePaneOptions"; "required": false; }; "treeListPaneOptions": { "alias": "treeListPaneOptions"; "required": false; }; "taskClass": { "alias": "taskClass"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "columnsAutoSize": { "alias": "columnsAutoSize"; "required": false; }; "currentTimeMarker": { "alias": "currentTimeMarker"; "required": false; }; "columnMenu": { "alias": "columnMenu"; "required": false; }; "columnsReorderable": { "alias": "columnsReorderable"; "required": false; }; "columnsResizable": { "alias": "columnsResizable"; "required": false; }; "dragScrollSettings": { "alias": "dragScrollSettings"; "required": false; }; "taskTooltipOptions": { "alias": "taskTooltipOptions"; "required": false; }; }, { "selectionChange": "selectionChange"; "rowExpand": "rowExpand"; "taskDblClick": "taskDblClick"; "cellDblClick": "cellDblClick"; "cellClose": "cellClose"; "taskDelete": "taskDelete"; "rowCollapse": "rowCollapse"; "remove": "remove"; "cancel": "cancel"; "save": "save"; "taskAdd": "taskAdd"; "dependencyAdd": "dependencyAdd"; "sortChange": "sortChange"; "filterChange": "filterChange"; "dataStateChange": "dataStateChange"; "treeListPaneCollapsedChange": "treeListPaneCollapsedChange"; "timelinePaneCollapsedChange": "timelinePaneCollapsedChange"; "timelinePaneSizeChange": "timelinePaneSizeChange"; "activeViewChange": "activeViewChange"; "columnResize": "columnResize"; "columnReorder": "columnReorder"; "columnVisibilityChange": "columnVisibilityChange"; "columnLockedChange": "columnLockedChange"; "cellClick": "cellClick"; "taskClick": "taskClick"; }, ["taskContentTemplate", "taskTemplate", "taskTooltipTemplate", "taskDragTooltipTemplate", "summaryTaskTemplate", "toolbarTemplateChildren", "columns", "views"], never, true, never>;
+}
+
+/**
+ * Binds the Gantt to an array of objects by using an ID and parent ID field to define the hierarchy.
+ *
+ * Use this directive to handle in-memory data operations such as sorting and filtering. [See example](https://www.telerik.com/kendo-angular-ui/components/gantt/data-binding/directives#binding-to-flat-data).
+ *
+ * @example
+ * ```html
+ * <kendo-gantt
+ *   [kendoGanttFlatBinding]="data"
+ *   parentIdField="parentTaskId"
+ *   idField="id"
+ *   [dependencies]="dependencies">
+ * </kendo-gantt>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link GanttComponent}
+ */
+declare class GanttFlatBindingDirective extends FlatBindingDirective {
+    /**
+     * Sets the array of data to populate the Gantt.
+     */
+    data: any[];
+    /**
+     * @hidden
+     */
+    set aggregate(value: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttFlatBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttFlatBindingDirective, "[kendoGanttFlatBinding]", ["kendoGanttFlatBinding"], { "data": { "alias": "kendoGanttFlatBinding"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Binds the Gantt to a tree of objects.
+ *
+ * Use this directive to handle in-memory data operations such as sorting and filtering. [See example](https://www.telerik.com/kendo-angular-ui/components/gantt/data-binding/directives#binding-to-hierarchical-data).
+ *
+ * @example
+ * ```html
+ * <kendo-gantt
+ *   [kendoGanttHierarchyBinding]="data"
+ *   childrenField="subtasks"
+ *   [dependencies]="dependencies">
+ * </kendo-gantt>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link GanttComponent}
+ */
+declare class GanttHierarchyBindingDirective extends HierarchyBindingDirective {
+    /**
+     * Sets the array of data to populate the Gantt.
+     */
+    data: any[];
+    /**
+     * @hidden
+     */
+    set aggregate(value: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttHierarchyBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttHierarchyBindingDirective, "[kendoGanttHierarchyBinding]", ["kendoGanttHierarchyBinding"], { "data": { "alias": "kendoGanttHierarchyBinding"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The Gantt ViewSelector component. Shows the current view type and lets you switch to another view type.
+ */
+declare class ViewSelectorComponent {
+    private localizationService;
+    hostClass: boolean;
+    /**
+     * Lists the timeline view types in the current Gantt configuration.
+     */
+    set views(value: TimelineViewType[]);
+    get views(): TimelineViewType[];
+    /**
+     * Sets the current view type.
+     * @default 'week'
+     */
+    activeView: TimelineViewType;
+    /**
+     * Fires when the user selects a different view type. The event data contains the type of the new view.
+     */
+    activeViewChange: EventEmitter<TimelineViewType>;
+    /**
+     * @hidden
+     */
+    segmentedItems: SegmentedItemSettings[];
+    private _views;
+    constructor(localizationService: LocalizationService);
+    /**
+     * @hidden
+     */
+    get selectedIndex(): number;
+    /**
+     * @hidden
+     */
+    onSelectedChange(index: number): void;
+    /**
+     * @hidden
+     */
+    getViewTypeText(viewType: TimelineViewType): string;
+    /**
+     * @hidden
+     */
+    onActiveViewChange(event: Event): void;
+    private updateSegmentedItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewSelectorComponent, "kendo-gantt-view-selector", never, { "views": { "alias": "views"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; }, { "activeViewChange": "activeViewChange"; }, never, never, true, never>;
+}
+
+/**
+ * Represents a directive that controls the expanded state of Gantt items.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt kendoGanttExpandable [expandedKeys]="expandedKeys"></kendo-gantt>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link GanttComponent}
+ */
+declare class GanttExpandableDirective extends ExpandableDirective {
+    /**
+     * Sets the item key stored in the `expandedKeys` collection.
+     * The default value is the task data item ID field, specified in the `taskModelFields` object.
+     */
+    set expandBy(value: string | ((dataItem: any) => any));
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttExpandableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttExpandableDirective, "[kendoGanttExpandable]", ["kendoGanttExpandable"], { "expandBy": { "alias": "expandBy"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ *
+ * Notifies the timeline-scroll.directive to scroll into view to requested coordinates.
+ * The scrolling is performed based on client (viewport) coordinates.
+ */
+declare class TimelineScrollService {
+    readonly horizontalScroll: Subject<number>;
+    readonly verticalScroll: Subject<number>;
+    readonly scrollCancel: Subject<any>;
+    ngOnDestroy(): void;
+    requestHorizontalScroll(clientTop: number): void;
+    requestVerticalScroll(clientLeft: number): void;
+    requestScrollCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimelineScrollService>;
+}
+
+/**
+ * Enables creating new dependencies by dragging.
+ *
+ * ```html
+ * <kendo-gantt kendoGanttDependencyDragCreate></kendo-gantt>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link GanttComponent}
+ */
+declare class DependencyDragCreateDirective implements AfterViewInit, OnDestroy {
+    private gantt;
+    private zone;
+    private renderer;
+    private mapper;
+    private popupService;
+    private timelineScrollService;
+    /**
+     * Shows the validation tooltip during drag operations.
+     *
+     * @default true
+     */
+    displayValidationTooltip: boolean;
+    private get container();
+    private get polyline();
+    private get popupContainer();
+    /**
+     * Points to the drag clue where the dragging started (the FROM task).
+     * Used to attach/detach classes to the target element and its task wrapper parent element.
+     */
+    private fromTaskClue;
+    /**
+     * The drag start element coords will be the same through the enitre dragging session, so compute them on press and cache them.
+     */
+    private polylineStartCoords;
+    /**
+     * Stored during dragging to be consumed by the container scroll subscription.
+     * The scroll event doesn't expose the current pointer position, so it has to be stored separately.
+     */
+    private currentPointerClientCoords;
+    private scrollListenerDisposer;
+    private dragPopup;
+    private dragSubscriptions;
+    constructor(gantt: GanttComponent, zone: NgZone, renderer: Renderer2, mapper: MappingService, popupService: PopupService, timelineScrollService: TimelineScrollService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private subscribeDraggable;
+    private unsubscribeDraggable;
+    private handlePress;
+    private handleDrag;
+    private handleRelease;
+    private updatePolyline;
+    private clearPolyline;
+    private assignDragStartClasses;
+    private removeDragStartClasses;
+    private scrollPointIntoView;
+    private cancelScroll;
+    private addScrollListener;
+    private removeScrollListener;
+    private openDragPopup;
+    private updateDragPopup;
+    private closeDragPopup;
+    private extractTaskName;
+    private getTooltipContext;
+    /**
+     * Restricts the popup position to not go below the scroll height or width of the container.
+     * Flips the position of the popup when there's not enough vertical space in the visible part of the container to render the popup.
+     */
+    private normalizePopupPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DependencyDragCreateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DependencyDragCreateDirective, "[kendoGanttDependencyDragCreate]", never, { "displayValidationTooltip": { "alias": "displayValidationTooltip"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Gantt timeline day view component.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-timeline-day-view></kendo-gantt-timeline-day-view>
+ * ```
+ */
+declare class TimelineDayViewComponent extends ViewBase {
+    /**
+     * Specifies the type for this view (`day`).
+     */
+    readonly type: TimelineViewType;
+    constructor(optionChangesService: OptionChangesService, dependencyDomService: DependencyDomService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineDayViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineDayViewComponent, "kendo-gantt-timeline-day-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Gantt timeline week view component.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-timeline-week-view></kendo-gantt-timeline-week-view>
+ * ```
+ */
+declare class TimelineWeekViewComponent extends ViewBase {
+    /**
+     * Specifies the type for this view (`week`).
+     */
+    readonly type: TimelineViewType;
+    constructor(optionChangesService: OptionChangesService, dependencyDomService: DependencyDomService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineWeekViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineWeekViewComponent, "kendo-gantt-timeline-week-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Gantt timeline month view component.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-timeline-month-view></kendo-gantt-timeline-month-view>
+ * ```
+ */
+declare class TimelineMonthViewComponent extends ViewBase {
+    /**
+     * Specifies the type for this view (`month`).
+     */
+    readonly type: TimelineViewType;
+    constructor(optionChangesService: OptionChangesService, dependencyDomService: DependencyDomService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineMonthViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineMonthViewComponent, "kendo-gantt-timeline-month-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Gantt timeline year view component.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-timeline-year-view></kendo-gantt-timeline-year-view>
+ * ```
+ */
+declare class TimelineYearViewComponent extends ViewBase {
+    /**
+     * Specifies the type for this view (`year`).
+     */
+    readonly type: TimelineViewType;
+    constructor(optionChangesService: OptionChangesService, dependencyDomService: DependencyDomService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineYearViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineYearViewComponent, "kendo-gantt-timeline-year-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Handles the [`selectionChange`](https://www.telerik.com/kendo-angular-ui/components/gantt/api/ganttcomponent#selectionchange) event of the Gantt component.
+ * ([See example](https://www.telerik.com/kendo-angular-ui/components/gantt/selection#built-in-directive)).
+ *
+ * @example
+ * ```html
+ * <kendo-gantt kendoGanttSelectable [(selectedKeys)]="selectedKeys"></kendo-gantt>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link GanttComponent}
+ */
+declare class SelectableDirective implements OnDestroy {
+    private gantt;
+    /**
+     * @hidden
+     */
+    set selectable(value: boolean);
+    /**
+     * Sets the selected keys.
+     */
+    set selectedKeys(value: any[]);
+    /**
+     * Emits when the selected keys change.
+     */
+    selectedKeysChange: EventEmitter<any[]>;
+    /**
+     * Sets the field name or function that identifies the unique key for a data item.
+     * Uses the string field `id` by default.
+     */
+    set itemKey(value: string | ((dataItem: any) => any));
+    private get keyGetter();
+    private selectionSubscription;
+    private state;
+    private lastChange;
+    private _keyGetter;
+    constructor(gantt: GanttComponent);
+    ngOnDestroy(): void;
+    private isSelected;
+    private selectionChange;
+    private emitSelectedItemsChange;
+    private subscribeSelection;
+    private unsubscribeSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableDirective, "[kendoGanttSelectable]", ["kendoGanttSelectable"], { "selectable": { "alias": "selectable"; "required": false; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; }; "itemKey": { "alias": "itemKey"; "required": false; }; }, { "selectedKeysChange": "selectedKeysChange"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class Messages extends ComponentMessages {
+    /**
+     * The title of the "General" tab of the editing dialog TabStrip.
+     */
+    taskEditingGeneralTabTitle: string;
+    /**
+     * The title of the "Predecessors" dependencies tab of the editing dialog TabStrip.
+     */
+    taskEditingPredecessorsTabTitle: string;
+    /**
+     * The title of the "Successors" dependencies tab of the editing dialog TabStrip.
+     */
+    taskEditingSuccessorsTabTitle: string;
+    /**
+     * The text of the "Add" button in the dependencies tabs of the editing dialog TabStrip.
+     */
+    taskEditingDependenciesAddButtonText: string;
+    /**
+     * The text of the "Remove" button in the dependencies tabs of the editing dialog TabStrip.
+     */
+    taskEditingDependenciesRemoveButtonText: string;
+    /**
+     * The title of the "Task Title" Grid column in the dependencies tabs of the editing dialog TabStrip.
+     */
+    taskEditingDependenciesGridNameColumnTitle: string;
+    /**
+     * The title of the "Type" Grid column in the dependencies tabs of the editing dialog TabStrip.
+     */
+    taskEditingDependenciesGridTypeColumnTitle: string;
+    /**
+     * The text of the task editing dialog 'Delete' button.
+     */
+    deleteButtonText: string;
+    /**
+     * The label for the task delete button.
+     */
+    taskDeleteLabel: string;
+    /**
+     * The title of the task editing dialog.
+     */
+    taskEditingDialogTitle: string;
+    /**
+     * The title of the task editing dialog close button.
+     */
+    taskEditingDialogCloseTitle: string;
+    /**
+     * The title of the confirmation dialog close button.
+     */
+    confirmationDialogCloseTitle: string;
+    /**
+     * The title of the delete task confirmation dialog.
+     */
+    confirmationDialogTitle: string;
+    /**
+     * The text of the DropDownButton in the AddTask component.
+     */
+    addTaskText: string;
+    /**
+     * The text of the `Add Child` option in the AddTask component.
+     */
+    addChildText: string;
+    /**
+     * The text of the `Add Above` option in the AddTask component.
+     */
+    addAboveText: string;
+    /**
+     * The text of the `Add Below` option in the AddTask component.
+     */
+    addBelowText: string;
+    /**
+     * The text of the task editing dialog `Cancel` button.
+     */
+    cancelButtonText: string;
+    /**
+     * The text of the task editing dialog `Save` button.
+     */
+    saveButtonText: string;
+    /**
+     * The label of the 'title' field input in editing mode.
+     */
+    titleFieldInputLabel: string;
+    /**
+     * The label of the 'start' field input in editing mode.
+     */
+    startFieldInputLabel: string;
+    /**
+     * The label of the 'end' field input in editing mode.
+     */
+    endFieldInputLabel: string;
+    /**
+     * The label of the 'completionRatio' field input in editing mode.
+     */
+    completionRatioFieldInputLabel: string;
+    /**
+     * The content of the delete task confirmation dialog.
+     */
+    confirmationDialogContent: string;
+    /**
+     * The text of the day view in the ViewSelector component.
+     */
+    dayViewText: string;
+    /**
+     * The text of the week view in the ViewSelector component.
+     */
+    weekViewText: string;
+    /**
+     * The text of the month view in the ViewSelector component.
+     */
+    monthViewText: string;
+    /**
+     * The text of the year view in the ViewSelector component.
+     */
+    yearViewText: string;
+    /**
+     * The no-records text.
+     */
+    noRecords: string;
+    /**
+     * The label of the filter cell or icon.
+     */
+    filter: string;
+    /**
+     * The text of the `Equal` (**Is equal to**) filter operator.
+     */
+    filterEqOperator: string;
+    /**
+     * The text of the `NotEqual` (**Is not equal to**) filter operator.
+     */
+    filterNotEqOperator: string;
+    /**
+     * The text of the `IsNull` (**Is null**) filter operator.
+     */
+    filterIsNullOperator: string;
+    /**
+     * The text of the `IsNotNull` (**Is not null**) filter operator.
+     */
+    filterIsNotNullOperator: string;
+    /**
+     * The text of the `IsEmpty` (**Is empty**) filter operator.
+     */
+    filterIsEmptyOperator: string;
+    /**
+     * The text of the `IsNotEmpty` (**Is not empty**) filter operator.
+     */
+    filterIsNotEmptyOperator: string;
+    /**
+     * The text of the `StartsWith` (**Starts with**) filter operator.
+     */
+    filterStartsWithOperator: string;
+    /**
+     * The text of the `Contains` (**Contains**) filter operator.
+     */
+    filterContainsOperator: string;
+    /**
+     * The text of the `DoesNotContain` (**Does not contain**) filter operator.
+     */
+    filterNotContainsOperator: string;
+    /**
+     * The text of the `EndsWith` (**Ends with**) string filter operator.
+     */
+    filterEndsWithOperator: string;
+    /**
+     * The text of the `GreaterOrEqualTo` (**Is greater than or equal to**) numeric filter operator.
+     */
+    filterGteOperator: string;
+    /**
+     * The text of the `Greater` (**Is greater than**) numeric filter operator.
+     */
+    filterGtOperator: string;
+    /**
+     * The text of the `LessOrEqualTo` (**Is less than or equal to**) numeric filter operator.
+     */
+    filterLteOperator: string;
+    /**
+     * The text of the `Less` (**Is less than**) numeric filter operator.
+     */
+    filterLtOperator: string;
+    /**
+     * The text of the `IsTrue` Boolean filter option.
+     */
+    filterIsTrue: string;
+    /**
+     * The text of the `IsFalse` Boolean filter option.
+     */
+    filterIsFalse: string;
+    /**
+     * The text of the `(All)` option for Boolean filter.
+     */
+    filterBooleanAll: string;
+    /**
+     * The text of the `AfterOrEqualTo` (**Is after or equal to**) date filter operator.
+     */
+    filterAfterOrEqualOperator: string;
+    /**
+     * The text of the `After` (**Is after**) date filter operator.
+     */
+    filterAfterOperator: string;
+    /**
+     * The text of the `Before` (**Is before**) date filter operator.
+     */
+    filterBeforeOperator: string;
+    /**
+     * The text of the `BeforeOrEqualTo` (**Is before or equal to**) date filter operator.
+     */
+    filterBeforeOrEqualOperator: string;
+    /**
+     * The text of the **Filter** button.
+     */
+    filterFilterButton: string;
+    /**
+     * The text of the **Clear filter** button.
+     */
+    filterClearButton: string;
+    /**
+     * The text of the `And` filter logic.
+     */
+    filterAndLogic: string;
+    /**
+     * The text of the `Or` filter logic.
+     */
+    filterOrLogic: string;
+    /**
+     * The loading text.
+     *
+     * > The `loading` property is part of the accessibility support of the Gantt.
+     * Its value is detectable by screen readers and is not otherwise visible.
+     */
+    loading: string;
+    /**
+     * The title of the icon for the column menu.
+     */
+    columnMenu: string;
+    /**
+     * The text that is displayed in the column menu for the column items.
+     */
+    columns: string;
+    /**
+     * @hidden
+     * The text that is displayed in the column menu for the lock item.
+     */
+    lock: string;
+    /**
+     * @hidden
+     * The text that is displayed in the column menu for the unlock item.
+     */
+    unlock: string;
+    /**
+     * The label of the sort icon.
+     */
+    sortable: string;
+    /**
+     * The text that is displayed in the column menu for the ascending sort item.
+     */
+    sortAscending: string;
+    /**
+     * The text that is displayed in the column menu for the descending sort item.
+     */
+    sortDescending: string;
+    /**
+     * The status announcement when a column is sorted in an ascending order.
+     * Deprecated - the announcement now relies entirely on the `aria-sort` attribute.
+     * @hidden
+     */
+    sortedAscending: string;
+    /**
+     * The status announcement when a column is sorted in a descending order.
+     * Deprecated - the announcement now relies entirely on the `aria-sort` attribute.
+     * @hidden
+     */
+    sortedDescending: string;
+    /**
+     * The status announcement when a column is no longer sorted.
+     */
+    sortedDefault: string;
+    /**
+     * The text that is displayed in the column menu or in the column chooser item
+     * for the **Apply** button of the columns.
+     */
+    columnsApply: string;
+    /**
+     * The text that is displayed in the column menu or in the column chooser item
+     * for the **Reset** button of the columns.
+     */
+    columnsReset: string;
+    /**
+     * The text shown in the task tooltip before the task start date.
+     */
+    tooltipStartDateText: string;
+    /**
+     * The text shown in the task tooltip before the task end date.
+     */
+    tooltipEndDateText: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Messages, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Messages, "kendo-gantt-messages-base", never, { "taskEditingGeneralTabTitle": { "alias": "taskEditingGeneralTabTitle"; "required": false; }; "taskEditingPredecessorsTabTitle": { "alias": "taskEditingPredecessorsTabTitle"; "required": false; }; "taskEditingSuccessorsTabTitle": { "alias": "taskEditingSuccessorsTabTitle"; "required": false; }; "taskEditingDependenciesAddButtonText": { "alias": "taskEditingDependenciesAddButtonText"; "required": false; }; "taskEditingDependenciesRemoveButtonText": { "alias": "taskEditingDependenciesRemoveButtonText"; "required": false; }; "taskEditingDependenciesGridNameColumnTitle": { "alias": "taskEditingDependenciesGridNameColumnTitle"; "required": false; }; "taskEditingDependenciesGridTypeColumnTitle": { "alias": "taskEditingDependenciesGridTypeColumnTitle"; "required": false; }; "deleteButtonText": { "alias": "deleteButtonText"; "required": false; }; "taskDeleteLabel": { "alias": "taskDeleteLabel"; "required": false; }; "taskEditingDialogTitle": { "alias": "taskEditingDialogTitle"; "required": false; }; "taskEditingDialogCloseTitle": { "alias": "taskEditingDialogCloseTitle"; "required": false; }; "confirmationDialogCloseTitle": { "alias": "confirmationDialogCloseTitle"; "required": false; }; "confirmationDialogTitle": { "alias": "confirmationDialogTitle"; "required": false; }; "addTaskText": { "alias": "addTaskText"; "required": false; }; "addChildText": { "alias": "addChildText"; "required": false; }; "addAboveText": { "alias": "addAboveText"; "required": false; }; "addBelowText": { "alias": "addBelowText"; "required": false; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "saveButtonText": { "alias": "saveButtonText"; "required": false; }; "titleFieldInputLabel": { "alias": "titleFieldInputLabel"; "required": false; }; "startFieldInputLabel": { "alias": "startFieldInputLabel"; "required": false; }; "endFieldInputLabel": { "alias": "endFieldInputLabel"; "required": false; }; "completionRatioFieldInputLabel": { "alias": "completionRatioFieldInputLabel"; "required": false; }; "confirmationDialogContent": { "alias": "confirmationDialogContent"; "required": false; }; "dayViewText": { "alias": "dayViewText"; "required": false; }; "weekViewText": { "alias": "weekViewText"; "required": false; }; "monthViewText": { "alias": "monthViewText"; "required": false; }; "yearViewText": { "alias": "yearViewText"; "required": false; }; "noRecords": { "alias": "noRecords"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "filterEqOperator": { "alias": "filterEqOperator"; "required": false; }; "filterNotEqOperator": { "alias": "filterNotEqOperator"; "required": false; }; "filterIsNullOperator": { "alias": "filterIsNullOperator"; "required": false; }; "filterIsNotNullOperator": { "alias": "filterIsNotNullOperator"; "required": false; }; "filterIsEmptyOperator": { "alias": "filterIsEmptyOperator"; "required": false; }; "filterIsNotEmptyOperator": { "alias": "filterIsNotEmptyOperator"; "required": false; }; "filterStartsWithOperator": { "alias": "filterStartsWithOperator"; "required": false; }; "filterContainsOperator": { "alias": "filterContainsOperator"; "required": false; }; "filterNotContainsOperator": { "alias": "filterNotContainsOperator"; "required": false; }; "filterEndsWithOperator": { "alias": "filterEndsWithOperator"; "required": false; }; "filterGteOperator": { "alias": "filterGteOperator"; "required": false; }; "filterGtOperator": { "alias": "filterGtOperator"; "required": false; }; "filterLteOperator": { "alias": "filterLteOperator"; "required": false; }; "filterLtOperator": { "alias": "filterLtOperator"; "required": false; }; "filterIsTrue": { "alias": "filterIsTrue"; "required": false; }; "filterIsFalse": { "alias": "filterIsFalse"; "required": false; }; "filterBooleanAll": { "alias": "filterBooleanAll"; "required": false; }; "filterAfterOrEqualOperator": { "alias": "filterAfterOrEqualOperator"; "required": false; }; "filterAfterOperator": { "alias": "filterAfterOperator"; "required": false; }; "filterBeforeOperator": { "alias": "filterBeforeOperator"; "required": false; }; "filterBeforeOrEqualOperator": { "alias": "filterBeforeOrEqualOperator"; "required": false; }; "filterFilterButton": { "alias": "filterFilterButton"; "required": false; }; "filterClearButton": { "alias": "filterClearButton"; "required": false; }; "filterAndLogic": { "alias": "filterAndLogic"; "required": false; }; "filterOrLogic": { "alias": "filterOrLogic"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "columnMenu": { "alias": "columnMenu"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "lock": { "alias": "lock"; "required": false; }; "unlock": { "alias": "unlock"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sortAscending": { "alias": "sortAscending"; "required": false; }; "sortDescending": { "alias": "sortDescending"; "required": false; }; "sortedAscending": { "alias": "sortedAscending"; "required": false; }; "sortedDescending": { "alias": "sortedDescending"; "required": false; }; "sortedDefault": { "alias": "sortedDefault"; "required": false; }; "columnsApply": { "alias": "columnsApply"; "required": false; }; "columnsReset": { "alias": "columnsReset"; "required": false; }; "tooltipStartDateText": { "alias": "tooltipStartDateText"; "required": false; }; "tooltipEndDateText": { "alias": "tooltipEndDateText"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the custom messages component for the Kendo UI for Angular Gantt.
+ * Use this component to override default messages.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt-messages
+ *   addTaskText="Add Task"
+ *   cancelButtonText="Cancel">
+ * </kendo-gantt-messages>
+ * ```
+ */
+declare class CustomMessagesComponent extends Messages {
+    protected service: LocalizationService;
+    constructor(service: LocalizationService);
+    protected get override(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomMessagesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CustomMessagesComponent, "kendo-gantt-messages", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Displays the UI for adding new items to the Gantt.
+ * Use this in a toolbar template to show a custom icon or a list of options.
+ */
+declare class GanttAddTaskComponent {
+    private localizationService;
+    private editService;
+    private ngZone;
+    /**
+     * Sets the data for the DropDownButton.
+     * Provide the data as an array-like list.
+     */
+    data: GanttAddTaskActionItem[];
+    /**
+     * Sets the name of an existing icon in a Kendo UI theme.
+     * @default 'plus'
+     */
+    icon: string;
+    /**
+     * Sets an [`SVGIcon`](https://www.telerik.com/kendo-angular-ui/components/icons/api/svgicon) to render inside the `GanttAddTaskComponent` using
+     * an [`SVGIconComponent`](https://www.telerik.com/kendo-angular-ui/components/icons/api/svgiconcomponent).
+     */
+    svgIcon: SVGIcon;
+    constructor(localizationService: LocalizationService, editService: EditService, ngZone: NgZone);
+    /**
+     * @hidden
+     */
+    getText(message: string): string;
+    /**
+     * @hidden
+     */
+    handleOpen(e: any): void;
+    /**
+     * @hidden
+     */
+    handleMouseClick(): void;
+    /**
+     * @hidden
+     */
+    handleItemClick(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttAddTaskComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttAddTaskComponent, "kendo-gantt-add-task", never, { "data": { "alias": "data"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Gantt task drag directive.
+ *
+ * Use this directive to enable dragging of tasks in the Gantt. The directive listens and emits events with information about the dragged task.
+ *
+ * @example
+ * ```html
+ * <kendo-gantt [data]="tasks" kendoGanttTaskDrag (taskDrag)="onTaskDrag($event)" (taskDragEnd)="onTaskDragEnd($event)">
+ * </kendo-gantt>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link GanttComponent}
+ */
+declare class TaskDragDirective {
+    /**
+     * Emits while the user resizes or moves a task by dragging.
+     */
+    taskDrag: EventEmitter<TaskDragEvent>;
+    /**
+     * Fires when the user finishes dragging to resize or move a task.
+     * The event data gives you all information needed to update the task and related tasks.
+     */
+    taskDragEnd: EventEmitter<TaskDragEvent>;
+    private subs;
+    constructor(gantt: GanttComponent, mapper: MappingService, dragTargetContainer: DragTargetContainerDirective, taskDragService: TaskDragService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TaskDragDirective, "[kendoGanttTaskDrag]", never, {}, { "taskDrag": "taskDrag"; "taskDragEnd": "taskDragEnd"; }, never, never, true, [{ directive: typeof i1.DragTargetContainerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Represents the [`NgModule`](link:site.data.urls.angular['ngmoduleapi']) definition for the Gantt component.
+ *
+ * Use this module to include the Gantt component in your NgModule-based application.
+ *
+ * @example
+ * ```typescript
+ * import { GanttModule } from '@progress/kendo-angular-gantt';
+ * import { NgModule } from '@angular/core';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *   declarations: [AppComponent],
+ *   imports: [BrowserModule, GanttModule],
+ *   bootstrap: [AppComponent]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class GanttModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GanttModule, never, [typeof GanttComponent, typeof GanttFlatBindingDirective, typeof GanttHierarchyBindingDirective, typeof GanttTaskContentTemplateDirective, typeof GanttTaskTemplateDirective, typeof GanttSummaryTaskTemplateDirective, typeof GanttTaskDragTooltipTemplateDirective, typeof ToolbarTemplateDirective, typeof ViewSelectorComponent, typeof GanttColumnComponent, typeof GanttColumnGroupComponent, typeof GanttSpanColumnComponent, typeof FilterCellTemplateDirective, typeof FilterMenuTemplateDirective, typeof CellTemplateDirective, typeof EditTemplateDirective, typeof ColumnMenuTemplateDirective, typeof HeaderTemplateDirective, typeof FooterTemplateDirective, typeof GanttExpandableDirective, typeof DependencyDragCreateDirective, typeof TimelineDayViewComponent, typeof TimelineWeekViewComponent, typeof TimelineMonthViewComponent, typeof TimelineYearViewComponent, typeof SelectableDirective, typeof CustomMessagesComponent, typeof GanttAddTaskComponent, typeof TaskDragDirective, typeof GanttTaskTooltipTemplateDirective], [typeof GanttComponent, typeof GanttFlatBindingDirective, typeof GanttHierarchyBindingDirective, typeof GanttTaskContentTemplateDirective, typeof GanttTaskTemplateDirective, typeof GanttSummaryTaskTemplateDirective, typeof GanttTaskDragTooltipTemplateDirective, typeof ToolbarTemplateDirective, typeof ViewSelectorComponent, typeof GanttColumnComponent, typeof GanttColumnGroupComponent, typeof GanttSpanColumnComponent, typeof FilterCellTemplateDirective, typeof FilterMenuTemplateDirective, typeof CellTemplateDirective, typeof EditTemplateDirective, typeof ColumnMenuTemplateDirective, typeof HeaderTemplateDirective, typeof FooterTemplateDirective, typeof GanttExpandableDirective, typeof DependencyDragCreateDirective, typeof TimelineDayViewComponent, typeof TimelineWeekViewComponent, typeof TimelineMonthViewComponent, typeof TimelineYearViewComponent, typeof SelectableDirective, typeof CustomMessagesComponent, typeof GanttAddTaskComponent, typeof TaskDragDirective, typeof GanttTaskTooltipTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GanttModule>;
+}
+
+/**
+ * @hidden
+ */
+declare class TaskFieldsComponent {
+    mapper: MappingService;
+    private editService;
+    private localizationService;
+    constructor(mapper: MappingService, editService: EditService, localizationService: GanttLocalizationService);
+    /**
+     * @hidden
+     */
+    get formGroup(): FormGroup;
+    getText(token: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskFieldsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaskFieldsComponent, "kendo-gantt-task-fields", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class DependenciesTableComponent {
+    mapper: MappingService;
+    editService: EditService;
+    private localizationService;
+    tasks: any[];
+    dependencies: any[];
+    dependencyType: 'predecessor' | 'successor';
+    dependenciesChange: EventEmitter<any>;
+    selectedKeys: any[];
+    formGroups: FormArray;
+    dependencyTypes: {
+        type: string;
+        id: number;
+    }[];
+    plusIcon: SVGIcon;
+    minusIcon: SVGIcon;
+    get taskId(): number;
+    get dependencyIdField(): string;
+    constructor(mapper: MappingService, editService: EditService, localizationService: GanttLocalizationService);
+    ngOnInit(): void;
+    getFormControl(dataItemIndex: number, field: string): FormControl;
+    getText(token: string): string;
+    getDependencyTypes(): {
+        type: string;
+        id: number;
+    }[];
+    addHandler(): void;
+    removeHandler(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DependenciesTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DependenciesTableComponent, "kendo-gantt-dependencies-table", never, { "tasks": { "alias": "tasks"; "required": false; }; "dependencies": { "alias": "dependencies"; "required": false; }; "dependencyType": { "alias": "dependencyType"; "required": false; }; }, { "dependenciesChange": "dependenciesChange"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class EditDialogComponent {
+    mapper: MappingService;
+    editService: EditService;
+    cdr: ChangeDetectorRef;
+    private localizationService;
+    data: any[];
+    loadedTasks: any[];
+    saveIcon: SVGIcon;
+    cancelIcon: SVGIcon;
+    deleteIcon: SVGIcon;
+    constructor(mapper: MappingService, editService: EditService, cdr: ChangeDetectorRef, localizationService: LocalizationService);
+    ngOnInit(): void;
+    get predecessors(): GanttDependency[];
+    set predecessors(items: GanttDependency[]);
+    get successors(): GanttDependency[];
+    set successors(items: GanttDependency[]);
+    getText(token: string): string;
+    getDependencyType(typeId: number): string;
+    handleEditingResult(editResultType: 'save' | 'cancel'): void;
+    handleTaskDelete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditDialogComponent, "kendo-gantt-edit-dialog", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class DragValidationTooltipComponent {
+    /**
+     * Sets the status class of the attempted operation.
+     * Note that the status will be ignored and the `neutral` status class will be rendered,
+     * if the any of the fromTaskName or toTaskName are not populated.
+     */
+    isValid: boolean;
+    /**
+     * The name of the task where the dragging has started.
+     */
+    fromTaskName: string;
+    /**
+     * The name of the task which is being currently hovered.
+     */
+    toTaskName: string;
+    /**
+     * Specifies whether the valid/invalid validity classes should be rendered or not.
+     * Prevents the validity classes being rendered when e.g. the same task is hovered during drag,
+     * or when a task body is hovered and not an actual drag clue.
+     */
+    showValidityStatus: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragValidationTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DragValidationTooltipComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class ToolbarNavigationService {
+    private renderer;
+    focusableContent: any[];
+    focusIndex: number;
+    constructor(renderer: Renderer2);
+    updateFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToolbarNavigationService>;
+}
+
+/**
+ * @hidden
+ */
+declare class ToolbarComponent {
+    private hostEl;
+    private navigationService;
+    context: any;
+    role: string;
+    hostClasses: boolean;
+    clickHandler(ev: MouseEvent): void;
+    arrowLeftListener(): void;
+    arrowRightListener(): void;
+    activeViewChange: EventEmitter<TimelineViewType>;
+    showAddTask: boolean;
+    showViewSelector: boolean;
+    views: TimelineViewType[];
+    activeView: TimelineViewType;
+    toolbarTemplate: ToolbarTemplateDirective;
+    navigable: boolean;
+    set position(value: 'top' | 'bottom');
+    get position(): 'top' | 'bottom';
+    get toolbarTemplateRef(): TemplateRef<any>;
+    get renderTemplate(): boolean;
+    private _position;
+    constructor(hostEl: ElementRef, navigationService: ToolbarNavigationService);
+    handleViewChange(view: TimelineViewType): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "kendo-gantt-toolbar", never, { "showAddTask": { "alias": "showAddTask"; "required": false; }; "showViewSelector": { "alias": "showViewSelector"; "required": false; }; "views": { "alias": "views"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "toolbarTemplate": { "alias": "toolbarTemplate"; "required": false; }; "navigable": { "alias": "navigable"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "activeViewChange": "activeViewChange"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttTaskComponent extends GanttTaskBase {
+    private editService;
+    taskContentTemplate: TemplateRef<any>;
+    taskTemplate: TemplateRef<any>;
+    xIcon: SVGIcon;
+    touchEnabled: boolean;
+    get showDragHandles(): boolean;
+    constructor(editService: EditService, mapper: MappingService, timelineViewService: TimelineViewService, dependencyDomService: DependencyDomService, optionChangesService: OptionChangesService, cdr: ChangeDetectorRef, navigationService: NavigationService);
+    onTaskDelete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTaskComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttTaskComponent, "kendo-gantt-task", never, { "taskContentTemplate": { "alias": "taskContentTemplate"; "required": false; }; "taskTemplate": { "alias": "taskTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttMilestoneTaskComponent extends GanttTaskBase {
+    milestoneWrapperClass: boolean;
+    touchEnabled: boolean;
+    constructor(mapper: MappingService, timelineViewService: TimelineViewService, dependencyDomService: DependencyDomService, optionChangesService: OptionChangesService, cdr: ChangeDetectorRef, navigationService: NavigationService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttMilestoneTaskComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttMilestoneTaskComponent, "kendo-gantt-milestone-task", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttSummaryTaskComponent extends GanttTaskBase {
+    summaryWrapperClass: boolean;
+    template: TemplateRef<any>;
+    isExpanded: (task: object) => boolean;
+    touchEnabled: boolean;
+    get ariaExpanded(): string;
+    constructor(mapper: MappingService, timelineViewService: TimelineViewService, dependencyDomService: DependencyDomService, optionChangesService: OptionChangesService, cdr: ChangeDetectorRef, navigationService: NavigationService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttSummaryTaskComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttSummaryTaskComponent, "kendo-gantt-summary-task", never, { "template": { "alias": "template"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttHeaderTableBodyComponent {
+    tbodyClass: boolean;
+    groupSlots: any[];
+    slots: any[];
+    trackBySlotIndex(index: number, item: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttHeaderTableBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttHeaderTableBodyComponent, "[kendoGanttHeaderTableBody]", never, { "groupSlots": { "alias": "groupSlots"; "required": false; }; "slots": { "alias": "slots"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttTasksTableBodyComponent {
+    private dependencyDomService;
+    private mapper;
+    set timelineRow(timelineRow: ElementRef<HTMLTableRowElement>);
+    selectable: boolean;
+    rows: ViewItem[];
+    activeView: TimelineViewType;
+    taskContentTemplate: TemplateRef<any>;
+    taskTemplate: TemplateRef<any>;
+    summaryTaskTemplate: TemplateRef<any>;
+    taskClass: TaskClassFn;
+    isExpanded: (item: object) => boolean;
+    isTaskSelected: (item: object) => boolean;
+    renderDependencyDragClues: boolean;
+    taskPointerEnter: EventEmitter<GanttTask>;
+    taskPointerLeave: EventEmitter<undefined>;
+    constructor(dependencyDomService: DependencyDomService, mapper: MappingService);
+    trackBy: (_: number, item: any) => any;
+    isMileStone(item: ViewItem): boolean;
+    mapItemToTask(item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTasksTableBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttTasksTableBodyComponent, "[kendoGanttTasksTableBody]", never, { "selectable": { "alias": "selectable"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "taskContentTemplate": { "alias": "taskContentTemplate"; "required": false; }; "taskTemplate": { "alias": "taskTemplate"; "required": false; }; "summaryTaskTemplate": { "alias": "summaryTaskTemplate"; "required": false; }; "taskClass": { "alias": "taskClass"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "isTaskSelected": { "alias": "isTaskSelected"; "required": false; }; "renderDependencyDragClues": { "alias": "renderDependencyDragClues"; "required": false; }; }, { "taskPointerEnter": "taskPointerEnter"; "taskPointerLeave": "taskPointerLeave"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class TimelineScrollableDirective {
+    private timelineScrollableContainer;
+    private scrollService;
+    private zone;
+    scrollSettings: DragScrollSettings;
+    private subscriptions;
+    private verticalScrollInterval;
+    private horizontalScrollInterval;
+    constructor(timelineScrollableContainer: ElementRef<Element>, scrollService: TimelineScrollService, zone: NgZone);
+    ngOnDestroy(): void;
+    private scrollHorizontallyTo;
+    private scrollVerticallyTo;
+    private cancelScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineScrollableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimelineScrollableDirective, "[kendoGanttTimelineScrollable]", never, { "scrollSettings": { "alias": "scrollSettings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class GanttDependencyDirective {
+    private polyline;
+    private zone;
+    private renderer;
+    private mapper;
+    private dependencyDomService;
+    dependency: any;
+    private subscriptions;
+    constructor(polyline: ElementRef<SVGPolylineElement>, zone: NgZone, renderer: Renderer2, mapper: MappingService, dependencyDomService: DependencyDomService);
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    updatePoints({ timelineRow, contentContainer, tasks }: DependencyDomArgs): void;
+    private clearPoints;
+    private drawPoints;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttDependencyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttDependencyDirective, "[kendoGanttDependency]", never, { "dependency": { "alias": "dependency"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class LocalizedMessagesDirective extends Messages {
+    protected service: LocalizationService;
+    constructor(service: LocalizationService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedMessagesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LocalizedMessagesDirective, "[kendoGanttLocalizedMessages]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+* Use the `KENDO_GANTT` utility array to import all Kendo UI for Angular Gantt components and directives to a standalone Angular component.
+*/
+declare const KENDO_GANTT: readonly [typeof GanttComponent, typeof GanttFlatBindingDirective, typeof GanttHierarchyBindingDirective, typeof GanttTaskContentTemplateDirective, typeof GanttTaskTemplateDirective, typeof GanttSummaryTaskTemplateDirective, typeof GanttTaskDragTooltipTemplateDirective, typeof ToolbarTemplateDirective, typeof ViewSelectorComponent, typeof GanttColumnComponent, typeof GanttColumnGroupComponent, typeof GanttSpanColumnComponent, typeof FilterCellTemplateDirective, typeof FilterMenuTemplateDirective, typeof CellTemplateDirective, typeof EditTemplateDirective, typeof ColumnMenuTemplateDirective, typeof HeaderTemplateDirective, typeof FooterTemplateDirective, typeof GanttExpandableDirective, typeof DependencyDragCreateDirective, typeof TimelineDayViewComponent, typeof TimelineWeekViewComponent, typeof TimelineMonthViewComponent, typeof TimelineYearViewComponent, typeof SelectableDirective, typeof CustomMessagesComponent, typeof GanttAddTaskComponent, typeof TaskDragDirective, typeof GanttTaskTooltipTemplateDirective];
+
+export { CellCloseEvent, CellTemplateDirective, ColumnMenuTemplateDirective, CustomMessagesComponent, DependenciesTableComponent, DependencyDragCreateDirective, DependencyType, DragValidationTooltipComponent, EditDialogComponent, EditTemplateDirective, FilterCellTemplateDirective, FilterMenuTemplateDirective, FooterTemplateDirective, GanttAddTaskComponent, GanttColumnBase, GanttColumnComponent, GanttColumnGroupComponent, GanttComponent, GanttDependencyDirective, GanttExpandableDirective, GanttFlatBindingDirective, GanttHeaderTableBodyComponent, GanttHierarchyBindingDirective, GanttMilestoneTaskComponent, GanttModule, GanttSpanColumnComponent, GanttSummaryTaskComponent, GanttSummaryTaskTemplateDirective, GanttTaskComponent, GanttTaskContentTemplateDirective, GanttTaskDragTooltipTemplateDirective, GanttTaskTemplateDirective, GanttTaskTooltipTemplateDirective, GanttTasksTableBodyComponent, GanttTimelineComponent, HeaderTemplateDirective, KENDO_GANTT, LocalizedMessagesDirective, SelectableDirective, TaskDragDirective, TaskFieldsComponent, TimelineDayViewComponent, TimelineMonthViewComponent, TimelineScrollableDirective, TimelineWeekViewComponent, TimelineYearViewComponent, ToolbarComponent, ToolbarTemplateDirective, ViewSelectorComponent };
+export type { CellClickEvent, CellContentType, ClickEvent, ColumnLockedChangeEvent, ColumnMenuSettings, ColumnReorderConfig, ColumnReorderEvent, ColumnResizeEvent, ColumnSortSettings, ColumnVisibilityChangeEvent, CurrentTimeSettings, DataStateChangeEvent, DateRange, DependencyAddEvent, DragScrollSettings, EditEventDependencies, GanttAddTaskActionItem, GanttDependency, GanttDependencyModelFields, GanttTask, GanttTaskModelFields, RowClassFn, SelectedViewChangeEvent, SelectionChangeEvent, Slot, SortSettings, TaskAddEvent, TaskClassFn, TaskClickEvent, TaskDeleteEvent, TaskDragEvent, TaskEditEvent, TaskEditItem, TaskTooltipOptions, TimelineHeaderDateFormat, TimelinePaneOptions, TimelineViewType, ToolbarPosition, ToolbarSettings, TreeListPaneOptions };