@worktile/gantt 19.0.8-next.3 → 20.0.0-next.0

package/index.d.ts

@@ -1,5 +1,1405 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@worktile/gantt" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken, EventEmitter, TemplateRef, OnChanges, OnInit, OnDestroy, ElementRef, ChangeDetectorRef, NgZone, SimpleChanges, QueryList, AfterViewInit, AfterViewChecked, WritableSignal, PipeTransform } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/cdk/drag-drop';
+import { CdkDragStart, CdkDragMove, CdkDragEnd, CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i3 from '@angular/cdk/scrolling';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { BehaviorSubject, Subject, Observable } from 'rxjs';
+import * as date_fns from 'date-fns';
+import { Locale, FirstWeekContainsDate } from 'date-fns';
+export { Locale, addDays, addHours, addMinutes, addMonths, addQuarters, addSeconds, addWeeks, addYears, differenceInCalendarDays, differenceInCalendarQuarters, differenceInDays, differenceInMinutes, eachDayOfInterval, eachHourOfInterval, eachMonthOfInterval, eachWeekOfInterval, endOfDay, endOfHour, endOfMinute, endOfMonth, endOfQuarter, endOfWeek, endOfYear, format, fromUnixTime, getDaysInMonth, getUnixTime, getWeek, isToday, isWeekend, setDate, startOfDay, startOfHour, startOfMinute, startOfMonth, startOfQuarter, startOfWeek, startOfYear } from 'date-fns';
+import { SelectionModel } from '@angular/cdk/collections';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as _worktile_gantt from '@worktile/gantt';
+
+type GanttDateUtil = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+declare function setDefaultTimeZone(zone: string): void;
+declare function getDefaultTimeZone(): string;
+declare class GanttDate {
+    value: Date;
+    constructor(date?: Date | string | number);
+    getYear(): number;
+    getMonth(): number;
+    getDay(): number;
+    getTime(): number;
+    getDate(): number;
+    getHours(): number;
+    getMinutes(): number;
+    getSeconds(): number;
+    getMilliseconds(): number;
+    getWeek(options?: {
+        locale?: Locale;
+        weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    }): number;
+    getDaysInMonth(): number;
+    getDaysInQuarter(): number;
+    getDaysInYear(): number;
+    setDate(dayOfMonth: number): GanttDate;
+    clone(): GanttDate;
+    add(amount: number, unit?: GanttDateUtil): GanttDate;
+    addSeconds(amount: number): GanttDate;
+    addMinutes(amount: number): GanttDate;
+    addHours(amount: number): GanttDate;
+    addDays(amount: number): GanttDate;
+    addWeeks(amount: number): GanttDate;
+    addMonths(amount: number): GanttDate;
+    addQuarters(amount: number): GanttDate;
+    addYears(amount: number): GanttDate;
+    startOfMinute(): GanttDate;
+    startOfHour(): GanttDate;
+    startOfDay(): GanttDate;
+    startOfWeek(options?: {
+        locale?: Locale;
+        weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    }): GanttDate;
+    startOfMonth(): GanttDate;
+    startOfQuarter(): GanttDate;
+    startOfYear(): GanttDate;
+    endOfMinute(): GanttDate;
+    endOfHour(): GanttDate;
+    endOfDay(): GanttDate;
+    endOfWeek(options?: {
+        locale?: Locale;
+        weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    }): GanttDate;
+    endOfMonth(): GanttDate;
+    endOfQuarter(): GanttDate;
+    endOfYear(): GanttDate;
+    getUnixTime(): number;
+    format(mat: string, options?: {
+        locale?: Locale;
+        weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        firstWeekContainsDate?: FirstWeekContainsDate;
+        useAdditionalWeekYearTokens?: boolean;
+        useAdditionalDayOfYearTokens?: boolean;
+    }): string;
+    isWeekend(): boolean;
+    isToday(): boolean;
+}
+
+declare class GanttDatePoint {
+    start: GanttDate;
+    text: string;
+    x: number;
+    y: number | string;
+    additions?: {
+        isWeekend: boolean;
+        isToday: boolean;
+    };
+    style?: Partial<CSSStyleDeclaration>;
+    fill?: string;
+    constructor(start: GanttDate, text: string, x: number, y: number | string, additions?: {
+        isWeekend: boolean;
+        isToday: boolean;
+    }, style?: Partial<CSSStyleDeclaration>, fill?: string);
+}
+
+declare enum GanttViewType {
+    day = "day",
+    quarter = "quarter",
+    month = "month",
+    year = "year",
+    week = "week",
+    hour = "hour"
+}
+
+interface GanttItemRefs {
+    width: number;
+    x: number;
+    y: number;
+}
+declare enum GanttItemType {
+    bar = "bar",
+    range = "range",
+    custom = "custom"
+}
+interface GanttItem<T = unknown> {
+    id: string;
+    title: string;
+    start?: number | Date;
+    end?: number | Date;
+    group_id?: string;
+    links?: (GanttLink | string)[];
+    draggable?: boolean;
+    itemDraggable?: boolean;
+    linkable?: boolean;
+    expandable?: boolean;
+    expanded?: boolean;
+    children?: GanttItem[];
+    color?: string;
+    barStyle?: Partial<CSSStyleDeclaration>;
+    laneStyle?: Partial<CSSStyleDeclaration>;
+    origin?: T;
+    type?: GanttItemType;
+    progress?: number;
+}
+declare class GanttItemInternal {
+    private view?;
+    id: string;
+    title: string;
+    start: GanttDate | null;
+    end: GanttDate | null;
+    links: GanttLink[];
+    color?: string;
+    barStyle?: Partial<CSSStyleDeclaration>;
+    laneStyle?: Partial<CSSStyleDeclaration>;
+    draggable?: boolean;
+    itemDraggable?: boolean;
+    linkable?: boolean;
+    origin: GanttItem;
+    expandable?: boolean;
+    expanded?: boolean;
+    loading: boolean;
+    children: GanttItemInternal[];
+    type?: GanttItemType;
+    progress?: number;
+    viewType?: GanttViewType;
+    level: number;
+    get refs(): {
+        width: number;
+        x: number;
+        y: number;
+    };
+    refs$: BehaviorSubject<{
+        width: number;
+        x: number;
+        y: number;
+    }>;
+    constructor(item: GanttItem, level: number, view?: GanttView);
+    private fillDateWhenStartOrEndIsNil;
+    updateRefs(refs: GanttItemRefs): void;
+    updateDate(start: GanttDate, end: GanttDate): void;
+    updateLevel(level: number): void;
+    addChildren(items: GanttItem[]): void;
+    setExpand(expanded: boolean): void;
+    addLink(link: GanttLink): void;
+}
+
+declare enum GanttLinkType {
+    fs = 1,
+    ff = 2,
+    ss = 3,
+    sf = 4
+}
+declare enum GanttLinkLineType {
+    curve = "curve",
+    straight = "straight"
+}
+declare enum LinkColors {
+    default = "#cacaca",
+    blocked = "#FF7575",
+    active = "#6698ff"
+}
+interface GanttLink {
+    type: GanttLinkType;
+    link: string;
+    color?: {
+        default: string;
+        active?: string;
+    } | string;
+}
+interface GanttLinkItem {
+    id: string;
+    before: {
+        x: number;
+        y: number;
+    };
+    after: {
+        x: number;
+        y: number;
+    };
+    start: GanttDate;
+    end: GanttDate;
+    origin: GanttItem;
+    links: GanttLink[];
+}
+interface LinkInternal {
+    path: string;
+    source: GanttItem;
+    target: GanttItem;
+    type: GanttLinkType;
+    color: string;
+    defaultColor?: string;
+    activeColor?: string;
+}
+interface GanttLinkOptions {
+    dependencyTypes?: GanttLinkType[];
+    showArrow?: boolean;
+    lineType?: GanttLinkLineType;
+}
+
+declare enum GanttI18nLocale {
+    zhHans = "zh-hans",
+    zhHant = "zh-hant",
+    enUs = "en-us",
+    deDe = "de-de",
+    jaJp = "ja-jp",
+    ruRu = "ru-ru"
+}
+type GanttI18nLocaleConfig = {
+    id: GanttI18nLocale | string;
+    dateLocale?: Locale;
+    views: Record<GanttViewType, {
+        label: string;
+        dateFormats: {
+            primary?: string;
+            secondary?: string;
+        };
+    }>;
+};
+declare const GANTT_I18N_LOCALE_TOKEN: InjectionToken<GanttI18nLocaleConfig[]>;
+
+interface GanttDateFormat {
+    hour?: string;
+    day?: string;
+    week?: string;
+    month?: string;
+    quarter?: string;
+    year?: string;
+    yearMonth?: string;
+    yearQuarter?: string;
+}
+interface GanttDateOptions {
+    /**
+     * @deprecated dateOptions is deprecated, use i18n locale setting instead
+     * https://worktile.github.io/ngx-gantt/guides/configuration/i18n
+     */
+    locale?: Locale;
+    timeZone?: string;
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+}
+interface GanttStyleOptions {
+    headerHeight?: number;
+    lineHeight?: number;
+    barHeight?: number;
+}
+interface GanttGlobalConfig {
+    locale?: GanttI18nLocale | string;
+    /** @deprecated dateFormat is deprecated, please configure through i18n. https://worktile.github.io/ngx-gantt/guides/configuration/i18n */
+    dateFormat?: GanttDateFormat;
+    dateOptions?: GanttDateOptions;
+    linkOptions?: GanttLinkOptions;
+    styleOptions?: GanttStyleOptions;
+}
+declare const defaultConfig: GanttGlobalConfig;
+declare const GANTT_GLOBAL_CONFIG: InjectionToken<GanttGlobalConfig>;
+declare class GanttConfigService {
+    config: GanttGlobalConfig;
+    private i18nLocales;
+    constructor();
+    setLocale(locale: string): void;
+    private getLocaleConfig;
+    getViewsLocale(): GanttI18nLocaleConfig['views'];
+    getDateLocale(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GanttConfigService>;
+}
+
+declare const primaryDatePointTop = "40%";
+declare const secondaryDatePointTop = "80%";
+interface GanttViewDate {
+    date: GanttDate;
+    isCustom?: boolean;
+}
+interface GanttViewOptions {
+    start?: GanttDate;
+    end?: GanttDate;
+    min?: GanttDate;
+    max?: GanttDate;
+    cellWidth?: number;
+    addAmount?: number;
+    addUnit?: GanttDateUtil;
+    /** @deprecated dateFormat is deprecated, please use dateDisplayFormats or setting i18n locale */
+    dateFormat?: GanttDateFormat;
+    dateDisplayFormats?: {
+        primary?: string;
+        secondary?: string;
+    };
+    datePrecisionUnit?: 'day' | 'hour' | 'minute';
+    dragPreviewDateFormat?: string;
+    [key: string]: any;
+}
+declare abstract class GanttView {
+    viewType: GanttViewType;
+    start$: BehaviorSubject<GanttDate>;
+    end$: BehaviorSubject<GanttDate>;
+    get start(): GanttDate;
+    get end(): GanttDate;
+    primaryDatePoints: GanttDatePoint[];
+    secondaryDatePoints: GanttDatePoint[];
+    width: number;
+    cellWidth: number;
+    primaryWidth: number;
+    showTimeline: boolean;
+    options: GanttViewOptions;
+    dateFormats: {
+        primary?: string;
+        secondary?: string;
+    };
+    constructor(start: GanttViewDate, end: GanttViewDate, options: GanttViewOptions);
+    abstract viewStartOf(date: GanttDate): GanttDate;
+    abstract viewEndOf(date: GanttDate): GanttDate;
+    /**
+     * deprecated, please use viewStartOf()
+     * @deprecated
+     */
+    startOf(date: GanttDate): GanttDate;
+    /**
+     * deprecated, please use viewEndOf()
+     * @deprecated
+     */
+    endOf(date: GanttDate): GanttDate;
+    abstract getPrimaryWidth(): number;
+    abstract getDayOccupancyWidth(date: GanttDate): number;
+    abstract getPrimaryDatePoints(): GanttDatePoint[];
+    abstract getSecondaryDatePoints(): GanttDatePoint[];
+    startOfPrecision(date: GanttDate): GanttDate;
+    endOfPrecision(date: GanttDate): GanttDate;
+    differenceByPrecisionUnit(dateLeft: GanttDate, dateRight: GanttDate): number;
+    getDateIntervalWidth(start: GanttDate, end: GanttDate): number;
+    protected initialize(): void;
+    addStartDate(): {
+        start: GanttDate;
+        end: GanttDate;
+    };
+    addEndDate(): {
+        start: GanttDate;
+        end: GanttDate;
+    };
+    updateDate(start: GanttDate, end: GanttDate): void;
+    getWidth(): number;
+    getCellWidth(): number;
+    getTodayXPoint(): number;
+    getXPointByDate(date: GanttDate): number;
+    getDateByXPoint(x: number): GanttDate;
+    getDateRangeWidth(start: GanttDate, end: GanttDate): number;
+    getMinRangeWidthByPrecisionUnit(date: GanttDate): number;
+}
+
+interface Dictionary<T = unknown> {
+    [key: string]: T;
+}
+
+declare enum InBarPosition {
+    start = "start",
+    finish = "finish"
+}
+type LinkDragPosition = {
+    element: HTMLElement;
+    item: GanttItemInternal;
+    pos?: InBarPosition;
+};
+interface LinkDragPath {
+    from?: LinkDragPosition;
+    to?: LinkDragPosition;
+}
+declare class GanttDragContainer {
+    ganttUpper: GanttUpper;
+    dragStarted: EventEmitter<GanttDragEvent<unknown>>;
+    dragMoved: EventEmitter<GanttDragEvent<unknown>>;
+    dragEnded: EventEmitter<GanttDragEvent<unknown>>;
+    linkDragStarted: EventEmitter<GanttLinkDragEvent<unknown>>;
+    linkDragEntered: EventEmitter<GanttLinkDragEvent<unknown>>;
+    linkDragEnded: EventEmitter<GanttLinkDragEvent<unknown>>;
+    linkDraggingId: string;
+    linkDragPath: LinkDragPath;
+    constructor();
+    emitLinkDragStarted(from: LinkDragPosition): void;
+    emitLinkDragEntered(to: LinkDragPosition): void;
+    emitLinkDragLeaved(): void;
+    emitLinkDragEnded(to?: LinkDragPosition): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttDragContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GanttDragContainer>;
+}
+
+interface GanttBaselineItem {
+    id: string;
+    start?: number;
+    end?: number;
+}
+declare class GanttBaselineItemInternal {
+    id: string;
+    start: GanttDate;
+    end: GanttDate;
+    origin: GanttBaselineItem;
+    get refs(): {
+        width: number;
+        x: number;
+        y: number;
+    };
+    refs$: BehaviorSubject<{
+        width: number;
+        x: number;
+        y: number;
+    }>;
+    constructor(item: GanttBaselineItem);
+    updateRefs(refs: GanttItemRefs): void;
+}
+
+declare class NgxGanttTableComponent {
+    draggable: boolean;
+    maxWidth: number;
+    width: number;
+    dropEnterPredicate?: (context: GanttTableDragEnterPredicateContext) => boolean;
+    dragDropped: EventEmitter<GanttTableDragDroppedEvent<unknown>>;
+    dragStarted: EventEmitter<GanttTableDragStartedEvent<unknown>>;
+    dragEnded: EventEmitter<GanttTableDragEndedEvent<unknown>>;
+    columnChanges: EventEmitter<GanttTableEvent>;
+    resizeChange: EventEmitter<number>;
+    itemClick: EventEmitter<GanttTableItemClickEvent<unknown>>;
+    rowBeforeTemplate: TemplateRef<any>;
+    rowAfterTemplate: TemplateRef<any>;
+    tableEmptyTemplate: TemplateRef<any>;
+    tableFooterTemplate: TemplateRef<any>;
+    settingsSlot: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttTableComponent, "ngx-gantt-table", never, { "draggable": { "alias": "draggable"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "width": { "alias": "width"; "required": false; }; "dropEnterPredicate": { "alias": "dropEnterPredicate"; "required": false; }; }, { "dragDropped": "dragDropped"; "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; "columnChanges": "columnChanges"; "resizeChange": "resizeChange"; "itemClick": "itemClick"; }, ["rowBeforeTemplate", "rowAfterTemplate", "tableEmptyTemplate", "tableFooterTemplate", "settingsSlot"], never, true, never>;
+}
+
+declare abstract class GanttUpper implements OnChanges, OnInit, OnDestroy {
+    protected elementRef: ElementRef<HTMLElement>;
+    protected cdr: ChangeDetectorRef;
+    protected ngZone: NgZone;
+    protected config: GanttGlobalConfig;
+    originItems: GanttItem[];
+    originGroups: GanttGroup[];
+    originBaselineItems: GanttBaselineItem[];
+    viewType: GanttViewType;
+    start: number;
+    end: number;
+    showTodayLine: boolean;
+    draggable: boolean;
+    styles: GanttStyleOptions;
+    showToolbar: boolean;
+    toolbarOptions: GanttToolbarOptions;
+    viewOptions: GanttViewOptions;
+    set linkOptions(options: GanttLinkOptions);
+    get linkOptions(): GanttLinkOptions;
+    disabledLoadOnScroll: boolean;
+    set selectable(value: BooleanInput);
+    get selectable(): boolean;
+    set multiple(value: BooleanInput);
+    get multiple(): boolean;
+    quickTimeFocus: boolean;
+    loadOnScroll: EventEmitter<GanttLoadOnScrollEvent>;
+    dragStarted: EventEmitter<GanttDragEvent<unknown>>;
+    dragMoved: EventEmitter<GanttDragEvent<unknown>>;
+    dragEnded: EventEmitter<GanttDragEvent<unknown>>;
+    barClick: EventEmitter<GanttBarClickEvent<unknown>>;
+    viewChange: EventEmitter<GanttView>;
+    expandChange: EventEmitter<GanttItemInternal | GanttGroupInternal | (GanttItemInternal | GanttGroupInternal)[]>;
+    barTemplate: TemplateRef<any>;
+    rangeTemplate: TemplateRef<any>;
+    itemTemplate: TemplateRef<any>;
+    baselineTemplate: TemplateRef<any>;
+    groupTemplate: TemplateRef<any>;
+    groupHeaderTemplate: TemplateRef<any>;
+    toolbarTemplate: TemplateRef<any>;
+    configService: GanttConfigService;
+    linkable: boolean;
+    linkDragEnded: EventEmitter<GanttLinkDragEvent<unknown>>;
+    view: GanttView;
+    items: GanttItemInternal[];
+    groups: GanttGroupInternal[];
+    baselineItems: GanttBaselineItemInternal[];
+    baselineItemsMap: Dictionary<GanttBaselineItemInternal>;
+    get element(): HTMLElement;
+    firstChange: boolean;
+    dragContainer: GanttDragContainer;
+    unsubscribe$: Subject<void>;
+    selectionModel: SelectionModel<string>;
+    table?: NgxGanttTableComponent;
+    private groupsMap;
+    private _selectable;
+    private _multiple;
+    private _linkOptions;
+    ganttClass: boolean;
+    constructor();
+    private createView;
+    private setupGroups;
+    protected setupItems(): void;
+    private setupBaselineItems;
+    private setupExpandedState;
+    private getViewDate;
+    computeRefs(): void;
+    private initSelectionModel;
+    private initCssVariables;
+    expandGroups(expanded: boolean): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    computeItemsRefs(...items: GanttItemInternal[] | GanttBaselineItemInternal[]): void;
+    trackBy(index: number, item: GanttGroupInternal | GanttItemInternal): string | number;
+    detectChanges(): void;
+    expandGroup(group: GanttGroupInternal): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getGanttItem(id: string): GanttItemInternal;
+    getGanttItems(ids: string[]): GanttItemInternal[];
+    isSelected(id: string): boolean;
+    changeView(type: GanttViewType): void;
+    rerenderView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttUpper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttUpper, never, never, { "originItems": { "alias": "items"; "required": false; }; "originGroups": { "alias": "groups"; "required": false; }; "originBaselineItems": { "alias": "baselineItems"; "required": false; }; "viewType": { "alias": "viewType"; "required": false; }; "start": { "alias": "start"; "required": false; }; "end": { "alias": "end"; "required": false; }; "showTodayLine": { "alias": "showTodayLine"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "styles": { "alias": "styles"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "toolbarOptions": { "alias": "toolbarOptions"; "required": false; }; "viewOptions": { "alias": "viewOptions"; "required": false; }; "linkOptions": { "alias": "linkOptions"; "required": false; }; "disabledLoadOnScroll": { "alias": "disabledLoadOnScroll"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "quickTimeFocus": { "alias": "quickTimeFocus"; "required": false; }; }, { "loadOnScroll": "loadOnScroll"; "dragStarted": "dragStarted"; "dragMoved": "dragMoved"; "dragEnded": "dragEnded"; "barClick": "barClick"; "viewChange": "viewChange"; "expandChange": "expandChange"; }, ["barTemplate", "rangeTemplate", "itemTemplate", "baselineTemplate", "groupTemplate", "groupHeaderTemplate", "toolbarTemplate"], never, true, never>;
+}
+declare const GANTT_UPPER_TOKEN: InjectionToken<GanttUpper>;
+
+declare class NgxGanttTableColumnComponent {
+    ganttUpper: GanttUpper;
+    private elementRef;
+    columnWidth: string;
+    set width(width: number | string);
+    name: string;
+    showExpandIcon: boolean;
+    templateRef: TemplateRef<any>;
+    headerTemplateRef: TemplateRef<any>;
+    constructor();
+    get classList(): DOMTokenList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttTableColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttTableColumnComponent, "ngx-gantt-column", never, { "width": { "alias": "width"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showExpandIcon": { "alias": "showExpandIcon"; "required": false; }; }, {}, ["templateRef", "headerTemplateRef"], never, true, never>;
+}
+
+declare class GanttDragEvent<T = unknown> {
+    item: GanttItem<T>;
+}
+declare class GanttTableEvent {
+    columns: QueryList<NgxGanttTableColumnComponent>;
+}
+declare class GanttLinkDragEvent<T = unknown> {
+    source: GanttItem<T>;
+    target?: GanttItem<T>;
+    type?: GanttLinkType;
+}
+declare class GanttLoadOnScrollEvent {
+    start: number;
+    end: number;
+}
+declare class GanttLineClickEvent<T = unknown> {
+    event: MouseEvent;
+    source: GanttItem<T>;
+    target: GanttItem<T>;
+}
+declare class GanttBarClickEvent<T = unknown> {
+    event: Event;
+    item: GanttItem<T>;
+}
+declare class GanttTableItemClickEvent<T = unknown> {
+    event: Event;
+    current?: GanttItem<T>;
+}
+declare class GanttSelectedEvent<T = unknown> extends GanttTableItemClickEvent<T> {
+    selectedValue: GanttItem<T> | GanttItem<T>[];
+}
+declare class GanttTableDragDroppedEvent<T = unknown> {
+    source: GanttItem<T>;
+    sourceParent: GanttItem<T>;
+    target: GanttItem<T>;
+    targetParent: GanttItem<T>;
+    dropPosition: GanttTableDropPosition;
+}
+declare class GanttTableDragStartedEvent<T = unknown> {
+    source: GanttItem<T>;
+    sourceParent: GanttItem<T>;
+}
+declare class GanttTableDragEndedEvent<T = unknown> {
+    source: GanttItem<T>;
+    sourceParent: GanttItem<T>;
+}
+type GanttTableDropPosition = 'before' | 'inside' | 'after';
+declare class GanttTableDragEnterPredicateContext<T = unknown> {
+    source: GanttItem<T>;
+    target: GanttItem<T>;
+    dropPosition: GanttTableDropPosition;
+}
+declare class GanttVirtualScrolledIndexChangeEvent {
+    index: number;
+    renderedRange: {
+        start: number;
+        end: number;
+    };
+    count: number;
+}
+
+interface GanttGroup<T = unknown> {
+    id: string;
+    title: string;
+    expanded?: boolean;
+    origin?: T;
+    class?: string;
+}
+declare class GanttGroupInternal {
+    id: string;
+    title: string;
+    origin: GanttGroup;
+    items: GanttItemInternal[];
+    mergedItems: GanttItemInternal[][];
+    expanded?: boolean;
+    refs?: {
+        height?: number;
+    };
+    class?: string;
+    constructor(group: GanttGroup);
+    setExpand(expanded: boolean): void;
+}
+
+interface GanttToolbarOptions {
+    viewTypes?: GanttViewType[];
+}
+
+declare class NgxGanttRootComponent implements OnInit, OnDestroy {
+    private elementRef;
+    private ngZone;
+    private dom;
+    dragContainer: GanttDragContainer;
+    ganttUpper: GanttUpper;
+    private printService;
+    sideWidth: number;
+    sideTemplate: TemplateRef<any>;
+    mainTemplate: TemplateRef<any>;
+    /** The native `<gantt-drag-backdrop></gantt-drag-backdrop>` element. */
+    backdrop: ElementRef<HTMLElement>;
+    verticalScrollbarWidth: number;
+    horizontalScrollbarHeight: number;
+    private unsubscribe$;
+    private get view();
+    onWindowResize(): void;
+    constructor();
+    ngOnInit(): void;
+    computeScrollBarOffset(): void;
+    ngOnDestroy(): void;
+    private setupViewScroll;
+    private setupResize;
+    private setupScrollClass;
+    scrollToToday(): void;
+    scrollToDate(date: number | Date | GanttDate): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttRootComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttRootComponent, "ngx-gantt-root", never, { "sideWidth": { "alias": "sideWidth"; "required": false; }; }, {}, ["sideTemplate", "mainTemplate"], ["*"], true, never>;
+}
+
+declare class NgxGanttComponent extends GanttUpper implements OnInit, OnChanges, AfterViewInit, AfterViewChecked {
+    private viewportRuler;
+    maxLevel: number;
+    async: boolean;
+    childrenResolve: (GanttItem: any) => Observable<GanttItem[]>;
+    linkable: boolean;
+    set loading(loading: boolean);
+    virtualScrollEnabled: boolean;
+    loadingDelay: number;
+    linkDragStarted: EventEmitter<GanttLinkDragEvent<unknown>>;
+    linkDragEnded: EventEmitter<GanttLinkDragEvent<unknown>>;
+    lineClick: EventEmitter<GanttLineClickEvent<unknown>>;
+    selectedChange: EventEmitter<GanttSelectedEvent<unknown>>;
+    virtualScrolledIndexChange: EventEmitter<GanttVirtualScrolledIndexChangeEvent>;
+    table: NgxGanttTableComponent;
+    columns: QueryList<NgxGanttTableColumnComponent>;
+    tableEmptyTemplate: TemplateRef<any>;
+    ganttRoot: NgxGanttRootComponent;
+    footerTemplate: TemplateRef<any>;
+    virtualScroll: CdkVirtualScrollViewport;
+    ganttTableBody: ElementRef<HTMLDivElement>;
+    tableScrollWidth: i0.WritableSignal<number>;
+    private resizeObserver;
+    get loading(): boolean;
+    flatItems: (GanttGroupInternal | GanttItemInternal)[];
+    viewportItems: (GanttGroupInternal | GanttItemInternal)[];
+    private _loading;
+    private loadingTimer;
+    private rangeStart;
+    private rangeEnd;
+    private flatItemsMap;
+    private draggingItem;
+    constructor();
+    ngOnInit(): void;
+    computeRefs(): void;
+    setupItems(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    private buildFlatItems;
+    private afterExpand;
+    private appendDraggingItemToViewportItems;
+    expandChildren(item: GanttItemInternal): void;
+    selectItem(selectEvent: GanttSelectedEvent): void;
+    scrollToToday(): void;
+    scrollToDate(date: number | Date | GanttDate): void;
+    scrolledIndexChange(index: number): void;
+    expandGroups(expanded: boolean): void;
+    expandGroup(group: GanttGroupInternal): void;
+    itemDragStarted(event: GanttTableDragStartedEvent): void;
+    itemDragEnded(event: GanttTableDragEndedEvent): void;
+    private initScrollContainerObserver;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttComponent, "ngx-gantt", never, { "maxLevel": { "alias": "maxLevel"; "required": false; }; "async": { "alias": "async"; "required": false; }; "childrenResolve": { "alias": "childrenResolve"; "required": false; }; "linkable": { "alias": "linkable"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "virtualScrollEnabled": { "alias": "virtualScrollEnabled"; "required": false; }; "loadingDelay": { "alias": "loadingDelay"; "required": false; }; }, { "linkDragStarted": "linkDragStarted"; "linkDragEnded": "linkDragEnded"; "lineClick": "lineClick"; "selectedChange": "selectedChange"; "virtualScrolledIndexChange": "virtualScrolledIndexChange"; }, ["table", "tableEmptyTemplate", "footerTemplate", "columns"], never, true, never>;
+}
+
+interface GanttAbstractComponent {
+    table: NgxGanttTableComponent;
+    styles: GanttStyleOptions;
+    maxLevel: number;
+    async: boolean;
+    cdr: ChangeDetectorRef;
+    expandGroup(group: GanttGroupInternal): void;
+    expandChildren(item: GanttItemInternal): void;
+}
+
+declare class GanttTableHeaderComponent implements OnInit, OnDestroy {
+    private elementRef;
+    gantt: GanttAbstractComponent;
+    private cdr;
+    dragStartLeft: number;
+    tableWidth: number;
+    customWidth: number;
+    private unsubscribe$;
+    columns: QueryList<NgxGanttTableColumnComponent>;
+    resizeLineElementRef: ElementRef<HTMLElement>;
+    className: string;
+    get height(): string;
+    get lineHeight(): string;
+    constructor();
+    ngOnInit(): void;
+    private columnsChange;
+    private dragFixed;
+    onResizeStarted(event: CdkDragStart): void;
+    onResizeMoved(event: CdkDragMove, column?: NgxGanttTableColumnComponent): void;
+    onResizeEnded(event: CdkDragEnd, column: NgxGanttTableColumnComponent): void;
+    onOverallResizeEnded(event: CdkDragEnd): void;
+    private showAuxiliaryLine;
+    private hideAuxiliaryLine;
+    private getCalcWidth;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTableHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttTableHeaderComponent, "gantt-table-header", never, { "columns": { "alias": "columns"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GanttTableBodyComponent implements OnInit, OnDestroy, AfterViewInit {
+    gantt: GanttAbstractComponent;
+    ganttUpper: GanttUpper;
+    private cdr;
+    private document;
+    protected elementRef: ElementRef<HTMLElement>;
+    private _viewportItems;
+    set viewportItems(data: (GanttGroupInternal | GanttItemInternal)[]);
+    get viewportItems(): (GanttGroupInternal | GanttItemInternal)[];
+    flatItems: (GanttGroupInternal | GanttItemInternal)[];
+    columns: QueryList<NgxGanttTableColumnComponent>;
+    groupTemplate: TemplateRef<any>;
+    emptyTemplate: TemplateRef<any>;
+    rowBeforeTemplate: TemplateRef<any>;
+    rowAfterTemplate: TemplateRef<any>;
+    draggable: boolean;
+    dropEnterPredicate?: (context: GanttTableDragEnterPredicateContext) => boolean;
+    dragDropped: EventEmitter<GanttTableDragDroppedEvent<unknown>>;
+    dragStarted: EventEmitter<GanttTableDragStartedEvent<unknown>>;
+    dragEnded: EventEmitter<GanttTableDragEndedEvent<unknown>>;
+    itemClick: EventEmitter<GanttSelectedEvent<unknown>>;
+    ganttTableClass: boolean;
+    ganttTableEmptyClass: boolean;
+    ganttTableDragging: boolean;
+    cdkDrags: QueryList<CdkDrag<GanttItemInternal>>;
+    hasGroup: boolean;
+    hasExpandIcon: boolean;
+    private itemDragsMap;
+    private itemDragMoved;
+    private itemDropTarget;
+    private destroy$;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    expandGroup(group: GanttGroupInternal): void;
+    expandChildren(event: MouseEvent, item: GanttItemInternal): void;
+    onItemDragStarted(event: CdkDragStart<GanttItemInternal>): void;
+    emitItemDragMoved(event: CdkDragMove): void;
+    onItemDragMoved(event: CdkDragMove<GanttItemInternal>): void;
+    onItemDragEnded(event: CdkDragEnd<GanttItemInternal>): void;
+    onListDropped(event: CdkDragDrop<GanttItemInternal[], GanttItemInternal[], GanttItemInternal>): void;
+    trackBy(index: number, item: GanttGroupInternal | GanttItemInternal): string | number;
+    ngOnDestroy(): void;
+    private removeItem;
+    private insertItem;
+    private insertChildrenItem;
+    private getParentByItem;
+    private getExpandChildrenByDrag;
+    private getChildrenElementsByElement;
+    private getTargetPosition;
+    private showDropPositionPlaceholder;
+    private cleanupDragArtifacts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttTableBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttTableBodyComponent, "gantt-table-body", never, { "viewportItems": { "alias": "viewportItems"; "required": false; }; "flatItems": { "alias": "flatItems"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "groupTemplate": { "alias": "groupTemplate"; "required": false; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; }; "rowBeforeTemplate": { "alias": "rowBeforeTemplate"; "required": false; }; "rowAfterTemplate": { "alias": "rowAfterTemplate"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "dropEnterPredicate": { "alias": "dropEnterPredicate"; "required": false; }; }, { "dragDropped": "dragDropped"; "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+declare enum ScrollDirection {
+    NONE = 0,
+    LEFT = 1,
+    RIGHT = 2
+}
+interface ScrollEvent {
+    target: Element;
+    direction: ScrollDirection;
+}
+declare class GanttDomService implements OnDestroy {
+    private ngZone;
+    private platformId;
+    root: Element;
+    side: Element;
+    container: Element;
+    sideContainer: Element;
+    mainContainer: Element;
+    verticalScrollContainer: Element;
+    calendarHeader: Element;
+    mainItems: Element;
+    calendarOverlay: Element;
+    linksOverlay: Element;
+    visibleRangeX: WritableSignal<{
+        min: number;
+        max: number;
+    }>;
+    private mainFooter;
+    private mainScrollbar;
+    private unsubscribe$;
+    constructor();
+    private disableBrowserWheelEvent;
+    initialize(root: ElementRef<HTMLElement>): void;
+    /**
+     * @returns An observable that will emit outside the Angular zone. Note, consumers should re-enter the Angular zone
+     * to run the change detection if needed.
+     */
+    getViewerScroll(options?: AddEventListenerOptions): Observable<ScrollEvent>;
+    getResize(): Observable<Event>;
+    getResizeByElement(element: Element): Observable<unknown>;
+    scrollMainContainer(left: number): void;
+    setVisibleRangeX(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttDomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GanttDomService>;
+}
+
+declare class GanttMainComponent implements OnInit {
+    ganttUpper: GanttUpper;
+    dom: GanttDomService;
+    protected ngZone: NgZone;
+    viewportItems: (GanttGroupInternal | GanttItemInternal)[];
+    flatItems: (GanttGroupInternal | GanttItemInternal)[];
+    groupHeaderTemplate: TemplateRef<any>;
+    itemTemplate: TemplateRef<any>;
+    barTemplate: TemplateRef<any>;
+    rangeTemplate: TemplateRef<any>;
+    baselineTemplate: TemplateRef<any>;
+    ganttRoot: NgxGanttRootComponent;
+    quickTimeFocus: boolean;
+    barClick: EventEmitter<GanttBarClickEvent<unknown>>;
+    lineClick: EventEmitter<GanttLineClickEvent<unknown>>;
+    ganttMainClass: boolean;
+    private unsubscribe$;
+    constructor();
+    ngOnInit(): void;
+    toItemType(data: GanttItemInternal | GanttGroupInternal): GanttItemInternal;
+    trackBy(index: number, item: GanttGroupInternal | GanttItemInternal): string | number;
+    private setupResize;
+    quickTime(item: GanttItem, type: 'left' | 'right'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttMainComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttMainComponent, "gantt-main", never, { "viewportItems": { "alias": "viewportItems"; "required": false; }; "flatItems": { "alias": "flatItems"; "required": false; }; "groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "barTemplate": { "alias": "barTemplate"; "required": false; }; "rangeTemplate": { "alias": "rangeTemplate"; "required": false; }; "baselineTemplate": { "alias": "baselineTemplate"; "required": false; }; "ganttRoot": { "alias": "ganttRoot"; "required": false; }; "quickTimeFocus": { "alias": "quickTimeFocus"; "required": false; }; }, { "barClick": "barClick"; "lineClick": "lineClick"; }, never, never, true, never>;
+}
+
+declare class GanttCalendarHeaderComponent implements OnInit {
+    ganttUpper: GanttUpper;
+    private ngZone;
+    private elementRef;
+    get view(): _worktile_gantt.GanttView;
+    private unsubscribe$;
+    viewTypes: typeof GanttViewType;
+    className: string;
+    get height(): string;
+    constructor();
+    ngOnInit(): void;
+    setTodayPoint(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttCalendarHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttCalendarHeaderComponent, "gantt-calendar-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class GanttCalendarGridComponent implements OnInit, OnDestroy {
+    ganttUpper: GanttUpper;
+    private ngZone;
+    private elementRef;
+    get view(): _worktile_gantt.GanttView;
+    private unsubscribe$;
+    mainHeight: number;
+    todayBorderRadius: number;
+    viewTypes: typeof GanttViewType;
+    className: string;
+    constructor();
+    setTodayPoint(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttCalendarGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttCalendarGridComponent, "gantt-calendar-grid", never, {}, {}, never, never, true, never>;
+}
+
+declare class GanttLinksComponent implements OnInit, OnChanges, OnDestroy {
+    ganttUpper: GanttUpper;
+    private cdr;
+    private elementRef;
+    private ganttDragContainer;
+    private ngZone;
+    flatItems: (GanttGroupInternal | GanttItemInternal)[];
+    lineClick: EventEmitter<GanttLineClickEvent<unknown>>;
+    links: LinkInternal[];
+    ganttLinkTypes: typeof GanttLinkType;
+    showArrow: boolean;
+    private linkItems;
+    private firstChange;
+    private linkLine;
+    private unsubscribe$;
+    ganttLinksOverlay: boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private computeItemPosition;
+    buildLinks(): void;
+    trackBy(index: number): number;
+    onLineClick(event: MouseEvent, link: LinkInternal): void;
+    mouseEnterPath(link: LinkInternal, index: number): void;
+    mouseLeavePath(link: LinkInternal): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttLinksComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttLinksComponent, "gantt-links-overlay", never, { "flatItems": { "alias": "flatItems"; "required": false; }; }, { "lineClick": "lineClick"; }, never, never, true, never>;
+}
+
+declare class GanttLoaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttLoaderComponent, "gantt-loader", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class GanttItemUpper implements OnChanges, OnInit, OnDestroy {
+    protected elementRef: ElementRef<HTMLElement>;
+    protected ganttUpper: GanttUpper;
+    template: TemplateRef<any>;
+    item: GanttItemInternal;
+    firstChange: boolean;
+    unsubscribe$: Subject<void>;
+    refsUnsubscribe$: Subject<void>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private itemChange;
+    private setPositions;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttItemUpper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GanttItemUpper, never, never, { "template": { "alias": "template"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgxGanttBarComponent extends GanttItemUpper implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private dragContainer;
+    private drag;
+    ganttUpper: GanttUpper;
+    private ngZone;
+    barClick: EventEmitter<GanttBarClickEvent<unknown>>;
+    contentElementRef: ElementRef<HTMLDivElement>;
+    ganttItemClass: boolean;
+    handles: QueryList<ElementRef<HTMLElement>>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    onBarClick(event: Event): void;
+    private setContentBackground;
+    stopPropagation(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttBarComponent, "ngx-gantt-bar,gantt-bar", never, {}, { "barClick": "barClick"; }, never, never, true, never>;
+}
+
+declare class GanttIconComponent {
+    private elementRef;
+    isIcon: boolean;
+    set iconName(name: string);
+    constructor();
+    setSvg(name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttIconComponent, "gantt-icon", never, { "iconName": { "alias": "iconName"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GanttDragBackdropComponent {
+    ganttUpper: GanttUpper;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttDragBackdropComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttDragBackdropComponent, "gantt-drag-backdrop", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgxGanttRangeComponent extends GanttItemUpper {
+    ganttRangeClass: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttRangeComponent, "ngx-gantt-range,gantt-range", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgxGanttBaselineComponent implements OnInit {
+    private elementRef;
+    ganttUpper: GanttUpper;
+    baselineItem: GanttBaselineItemInternal;
+    template: TemplateRef<any>;
+    unsubscribe$: Subject<void>;
+    ganttBaselineClass: boolean;
+    constructor();
+    ngOnInit(): void;
+    private setPositions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttBaselineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttBaselineComponent, "ngx-gantt-baseline,gantt-baseline", never, { "baselineItem": { "alias": "baselineItem"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgxGanttToolbarComponent {
+    protected ganttUpper: GanttUpper;
+    template: TemplateRef<any>;
+    ganttItemClass: boolean;
+    get top(): string;
+    views: Record<GanttViewType, {
+        label: string;
+        dateFormats: {
+            primary?: string;
+            secondary?: string;
+        };
+    }>;
+    constructor();
+    selectView(view: GanttViewType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxGanttToolbarComponent, "ngx-gantt-toolbar,gantt-toolbar", never, { "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GanttScrollbarComponent {
+    ganttUpper: GanttUpper;
+    hasFooter: i0.InputSignal<boolean>;
+    tableWidth: i0.InputSignal<number>;
+    ganttRoot: i0.InputSignal<NgxGanttRootComponent>;
+    tableScrollWidth: i0.InputSignal<number>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttScrollbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GanttScrollbarComponent, "gantt-scrollbar", never, { "hasFooter": { "alias": "hasFooter"; "required": false; "isSignal": true; }; "tableWidth": { "alias": "tableWidth"; "required": false; "isSignal": true; }; "ganttRoot": { "alias": "ganttRoot"; "required": false; "isSignal": true; }; "tableScrollWidth": { "alias": "tableScrollWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IsGanttRangeItemPipe implements PipeTransform {
+    transform(value: GanttItemType): value is GanttItemType.range;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsGanttRangeItemPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsGanttRangeItemPipe, "isGanttRangeItem", true>;
+}
+declare class IsGanttBarItemPipe implements PipeTransform {
+    transform(value: GanttItemType): value is GanttItemType.bar;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsGanttBarItemPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsGanttBarItemPipe, "isGanttBarItem", true>;
+}
+declare class IsGanttCustomItemPipe implements PipeTransform {
+    transform(value: GanttItemType): value is GanttItemType.custom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsGanttCustomItemPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsGanttCustomItemPipe, "isGanttCustomItem", true>;
+}
+declare class IsGanttGroupPipe implements PipeTransform {
+    transform(data: GanttItemInternal | GanttGroupInternal): data is GanttGroupInternal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsGanttGroupPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsGanttGroupPipe, "isGanttGroup", true>;
+}
+
+declare class NgxGanttModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxGanttModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxGanttModule, never, [typeof i1.CommonModule, typeof i2.DragDropModule, typeof i3.ScrollingModule, typeof NgxGanttComponent, typeof NgxGanttTableComponent, typeof NgxGanttTableColumnComponent, typeof GanttTableHeaderComponent, typeof GanttTableBodyComponent, typeof GanttMainComponent, typeof GanttCalendarHeaderComponent, typeof GanttCalendarGridComponent, typeof GanttLinksComponent, typeof GanttLoaderComponent, typeof NgxGanttBarComponent, typeof GanttIconComponent, typeof GanttDragBackdropComponent, typeof NgxGanttRangeComponent, typeof NgxGanttRootComponent, typeof NgxGanttBaselineComponent, typeof NgxGanttToolbarComponent, typeof GanttScrollbarComponent, typeof IsGanttRangeItemPipe, typeof IsGanttBarItemPipe, typeof IsGanttCustomItemPipe, typeof IsGanttGroupPipe], [typeof NgxGanttComponent, typeof NgxGanttTableComponent, typeof NgxGanttTableColumnComponent, typeof NgxGanttRootComponent, typeof NgxGanttBarComponent, typeof NgxGanttRangeComponent, typeof NgxGanttBaselineComponent, typeof NgxGanttToolbarComponent, typeof GanttCalendarHeaderComponent, typeof GanttCalendarGridComponent, typeof GanttDragBackdropComponent, typeof GanttScrollbarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxGanttModule>;
+}
+
+declare const _default$5: {
+    id: GanttI18nLocale;
+    views: {
+        hour: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        day: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        week: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        month: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        quarter: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        year: {
+            label: string;
+            dateFormats: {
+                secondary: string;
+            };
+        };
+    };
+};
+
+declare const _default$4: {
+    id: GanttI18nLocale;
+    views: {
+        hour: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        day: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        week: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        month: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        quarter: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        year: {
+            label: string;
+            dateFormats: {
+                secondary: string;
+            };
+        };
+    };
+};
+
+declare const _default$3: {
+    id: GanttI18nLocale;
+    views: {
+        hour: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        day: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        week: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        month: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        quarter: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        year: {
+            label: string;
+            dateFormats: {
+                secondary: string;
+            };
+        };
+    };
+};
+
+declare const _default$2: {
+    id: GanttI18nLocale;
+    views: {
+        hour: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        day: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        week: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        month: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        quarter: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        year: {
+            label: string;
+            dateFormats: {
+                secondary: string;
+            };
+        };
+    };
+};
+
+declare const _default$1: {
+    id: GanttI18nLocale;
+    dateLocale: date_fns.Locale;
+    views: {
+        hour: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        day: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        week: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        month: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        quarter: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        year: {
+            label: string;
+            dateFormats: {
+                secondary: string;
+            };
+        };
+    };
+};
+
+declare const _default: {
+    id: GanttI18nLocale;
+    dateLocale: date_fns.Locale;
+    views: {
+        hour: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        day: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        week: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        month: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        quarter: {
+            label: string;
+            dateFormats: {
+                primary: string;
+                secondary: string;
+            };
+        };
+        year: {
+            label: string;
+            dateFormats: {
+                secondary: string;
+            };
+        };
+    };
+};
+
+declare function registerView<T extends typeof GanttView>(type: string, view: T): void;
+
+declare class GanttPrintService {
+    private root;
+    private mainContainer;
+    constructor();
+    private setInlineStyles;
+    private recursElementChildren;
+    register(root: ElementRef<HTMLElement>): void;
+    print(name?: string, ignoreElementClass?: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GanttPrintService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GanttPrintService>;
+}
+
+export { GANTT_GLOBAL_CONFIG, GANTT_I18N_LOCALE_TOKEN, GANTT_UPPER_TOKEN, GanttBarClickEvent, GanttBaselineItemInternal, GanttCalendarGridComponent, GanttCalendarHeaderComponent, GanttConfigService, GanttDate, GanttDatePoint, GanttDragBackdropComponent, GanttDragEvent, GanttGroupInternal, GanttI18nLocale, GanttItemInternal, GanttItemType, GanttItemUpper, GanttLineClickEvent, GanttLinkDragEvent, GanttLinkLineType, GanttLinkType, GanttLoadOnScrollEvent, GanttLoaderComponent, GanttPrintService, GanttScrollbarComponent, GanttSelectedEvent, GanttTableDragDroppedEvent, GanttTableDragEndedEvent, GanttTableDragEnterPredicateContext, GanttTableDragStartedEvent, GanttTableEvent, GanttTableItemClickEvent, GanttUpper, GanttView, GanttViewType, GanttVirtualScrolledIndexChangeEvent, IsGanttBarItemPipe, IsGanttCustomItemPipe, IsGanttGroupPipe, IsGanttRangeItemPipe, LinkColors, NgxGanttBarComponent, NgxGanttBaselineComponent, NgxGanttComponent, NgxGanttModule, NgxGanttRangeComponent, NgxGanttRootComponent, NgxGanttTableColumnComponent, NgxGanttTableComponent, NgxGanttToolbarComponent, _default$1 as deDeLocale, defaultConfig, _default$3 as enUsLocale, getDefaultTimeZone, _default$2 as jaJpLocale, primaryDatePointTop, registerView, _default as ruRuLocale, secondaryDatePointTop, setDefaultTimeZone, _default$5 as zhHansLocale, _default$4 as zhHantLocale };
+export type { GanttBaselineItem, GanttDateFormat, GanttDateOptions, GanttDateUtil, GanttGlobalConfig, GanttGroup, GanttI18nLocaleConfig, GanttItem, GanttItemRefs, GanttLink, GanttLinkItem, GanttLinkOptions, GanttStyleOptions, GanttTableDropPosition, GanttToolbarOptions, GanttViewDate, GanttViewOptions, LinkInternal };