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 * as _angular_core from '@angular/core';
import { EventEmitter, InjectionToken, TemplateRef, OnInit, OnDestroy, ElementRef, ChangeDetectorRef, NgZone, Signal, OutputEmitterRef, WritableSignal, AfterViewInit, QueryList, PipeTransform } from '@angular/core';
import { SelectionModel } from '@angular/cdk/collections';
import { BehaviorSubject, Subject, Observable } from 'rxjs';
import * as _worktile_gantt from '@worktile/gantt';
import * as i3 from '@angular/cdk/scrolling';
import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
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';

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;
}

interface GanttViewTickSchema {
    date: GanttDate;
    rect: {
        x: number;
        width: number;
        background?: string;
    };
    label: {
        text: string;
        y: number | string;
        x?: number;
        style?: {
            color?: string;
            fontSize?: number | string;
            fontWeight?: string | number;
        };
    };
    metadata?: {
        isWeekend?: boolean;
        isToday?: boolean;
        [key: string]: any;
    };
}
declare class GanttViewTick {
    private schema;
    constructor(schema: GanttViewTickSchema);
    get date(): GanttDate;
    get rect(): GanttViewTickSchema['rect'];
    get label(): GanttViewTickSchema['label'];
    get metadata(): GanttViewTickSchema['metadata'];
}

declare enum GanttLinkType {
    fs = 1,
    ff = 2,
    ss = 3,
    sf = 4
}
declare enum GanttLinkLineType {
    curve = "curve",
    straight = "straight"
}
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 GanttViewType {
    day = "day",
    quarter = "quarter",
    month = "month",
    year = "year",
    week = "week",
    hour = "hour"
}

declare const PERIOD_TICK_TOP = "40%";
declare const UNIT_TICK_TOP = "80%";
interface GanttViewDate {
    date: GanttDate;
    isCustom?: boolean;
}
interface GanttViewOptions {
    start?: GanttDate;
    end?: GanttDate;
    minBoundary?: GanttDate;
    maxBoundary?: GanttDate;
    unitWidth?: number;
    loadDuration?: {
        amount: number;
        unit: GanttDateUtil;
    };
    tickFormats?: {
        period: string;
        unit: string;
    };
    precisionUnit?: 'day' | 'hour' | 'minute';
    dragTooltipFormat?: string;
    holiday?: {
        isHoliday: (GanttDate: any) => boolean;
        hideHoliday: boolean;
    };
    [key: string]: any;
}
declare abstract class GanttView {
    viewType: GanttViewType | string;
    start$: BehaviorSubject<GanttDate>;
    end$: BehaviorSubject<GanttDate>;
    get start(): GanttDate;
    get end(): GanttDate;
    periodTicks: GanttViewTick[];
    unitTicks: GanttViewTick[];
    width: number;
    unitWidth: number;
    periodWidth: number;
    showNowIndicator: boolean;
    options: GanttViewOptions;
    constructor(start: GanttViewDate, end: GanttViewDate, options: GanttViewOptions);
    abstract rangeStartOf(date: GanttDate): GanttDate;
    abstract rangeEndOf(date: GanttDate): GanttDate;
    abstract getPeriodWidth(): number;
    abstract getDayWidth(date: GanttDate): number;
    abstract getPeriodTicks(): GanttViewTick[];
    abstract getUnitTicks(): GanttViewTick[];
    protected hideHoliday(date: GanttDate): boolean;
    protected recomputeLayout(): void;
    alignToPrecisionStart(date: GanttDate): GanttDate;
    alignToPrecisionEnd(date: GanttDate): GanttDate;
    calculateIntervalWidth(start: GanttDate, end: GanttDate): number;
    extendStart(): {
        start: GanttDate;
        end: GanttDate;
    } | null;
    extendEnd(): {
        start: GanttDate;
        end: GanttDate;
    } | null;
    /**
     * 获取横向滚动加载的时间跨度配置
     */
    private getLoadDuration;
    updateDate(start: GanttDate, end: GanttDate): void;
    getWidth(): number;
    getUnitWidth(): number;
    getNowX(): number;
    getXAtDate(date: GanttDate): number;
    getDateAtX(x: number): GanttDate;
    calculateRangeWidth(start: GanttDate, end: GanttDate): number;
    getPrecisionUnitWidth(date: GanttDate): number;
    getVisibleDateIndexOffset(start: GanttDate, end: GanttDate): number;
    getDateByIndexOffset(baseDate: GanttDate, indexOffset: number): GanttDate;
}

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;
}

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 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: _angular_core.ɵɵFactoryDeclaration<GanttDragContainer, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GanttDragContainer>;
}

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;
        tickFormats: {
            period?: string;
            unit?: string;
        };
    }>;
};
declare const GANTT_I18N_LOCALE_TOKEN: InjectionToken<GanttI18nLocaleConfig[]>;

interface GanttDateOptions {
    timeZone?: string;
    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
}
interface GanttStyleOptions {
    primaryColor?: string;
    headerHeight?: number;
    /** @deprecated use rowHeight instead */
    lineHeight?: number;
    rowHeight?: number;
    barHeight?: number;
    defaultTheme?: string;
    themes?: Record<string, {
        primary?: string;
        danger?: string;
        highlight?: string;
        background?: string;
        text?: {
            main?: string;
            muted?: string;
            light?: string;
            inverse?: string;
        };
        gray?: {
            100?: string;
            200?: string;
            300?: string;
            400?: string;
            500?: string;
            600?: string;
        };
    }>;
}
interface GanttGlobalConfig {
    locale?: GanttI18nLocale | string;
    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();
    mergeStyleOptions(options: GanttStyleOptions): GanttStyleOptions;
    setLocale(locale: string): void;
    private getLocaleConfig;
    getViewsLocale(): GanttI18nLocaleConfig['views'];
    getDateLocale(): date_fns.Locale;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttConfigService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GanttConfigService>;
}

declare class NgxGanttTableComponent {
    readonly draggable: _angular_core.InputSignal<boolean>;
    readonly maxWidth: _angular_core.InputSignal<number>;
    readonly width: _angular_core.InputSignal<number>;
    readonly dropEnterPredicate: _angular_core.InputSignal<(context: GanttTableDragEnterPredicateContext) => boolean>;
    readonly dragDropped: _angular_core.OutputEmitterRef<GanttTableDragDroppedEvent<unknown>>;
    readonly dragStarted: _angular_core.OutputEmitterRef<GanttTableDragStartedEvent<unknown>>;
    readonly dragEnded: _angular_core.OutputEmitterRef<GanttTableDragEndedEvent<unknown>>;
    readonly columnChanges: _angular_core.OutputEmitterRef<GanttTableEvent>;
    readonly resizeChange: _angular_core.OutputEmitterRef<number>;
    readonly itemClick: _angular_core.OutputEmitterRef<GanttTableItemClickEvent<unknown>>;
    readonly rowBeforeTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly rowAfterTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly tableEmptyTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly tableFooterTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly settingsSlot: _angular_core.Signal<TemplateRef<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttTableComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttTableComponent, "ngx-gantt-table", never, { "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "dropEnterPredicate": { "alias": "dropEnterPredicate"; "required": false; "isSignal": true; }; }, { "dragDropped": "dragDropped"; "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; "columnChanges": "columnChanges"; "resizeChange": "resizeChange"; "itemClick": "itemClick"; }, ["rowBeforeTemplate", "rowAfterTemplate", "tableEmptyTemplate", "tableFooterTemplate", "settingsSlot"], never, true, never>;
}

interface Dictionary<T = unknown> {
    [key: string]: T;
}

declare abstract class GanttUpper implements OnInit, OnDestroy {
    protected elementRef: ElementRef<HTMLElement>;
    protected cdr: ChangeDetectorRef;
    protected ngZone: NgZone;
    protected config: GanttGlobalConfig;
    readonly originItems: _angular_core.InputSignal<GanttItem<unknown>[]>;
    readonly originGroups: _angular_core.InputSignal<GanttGroup<unknown>[]>;
    readonly originBaselineItems: _angular_core.InputSignal<GanttBaselineItem[]>;
    readonly viewType: _angular_core.ModelSignal<GanttViewType>;
    readonly start: _angular_core.InputSignal<number>;
    readonly end: _angular_core.InputSignal<number>;
    readonly showTodayLine: _angular_core.InputSignal<boolean>;
    readonly draggable: _angular_core.InputSignal<boolean>;
    readonly originStyles: _angular_core.InputSignal<GanttStyleOptions>;
    readonly styles: Signal<GanttStyleOptions>;
    readonly showToolbar: _angular_core.InputSignal<boolean>;
    readonly toolbarOptions: _angular_core.InputSignal<GanttToolbarOptions>;
    readonly viewOptions: _angular_core.InputSignal<GanttViewOptions>;
    readonly inputLinkOptions: _angular_core.InputSignal<GanttLinkOptions>;
    readonly linkOptions: Signal<GanttLinkOptions>;
    readonly disabledLoadOnScroll: _angular_core.InputSignal<boolean>;
    readonly selectable: _angular_core.InputSignalWithTransform<boolean, any>;
    readonly multiple: _angular_core.InputSignalWithTransform<boolean, any>;
    readonly quickTimeFocus: _angular_core.InputSignal<boolean>;
    readonly loadOnScroll: OutputEmitterRef<GanttLoadOnScrollEvent>;
    readonly dragStarted: OutputEmitterRef<GanttDragEvent<unknown>>;
    readonly dragMoved: OutputEmitterRef<GanttDragEvent<unknown>>;
    readonly dragEnded: OutputEmitterRef<GanttDragEvent<unknown>>;
    readonly barClick: OutputEmitterRef<GanttBarClickEvent<unknown>>;
    readonly viewChange: OutputEmitterRef<GanttView>;
    readonly expandChange: OutputEmitterRef<GanttItemInternal | GanttGroupInternal | (GanttItemInternal | GanttGroupInternal)[]>;
    readonly barTemplate: Signal<TemplateRef<any>>;
    readonly rangeTemplate: Signal<TemplateRef<any>>;
    readonly itemTemplate: Signal<TemplateRef<any>>;
    readonly baselineTemplate: Signal<TemplateRef<any>>;
    readonly groupTemplate: Signal<TemplateRef<any>>;
    readonly groupHeaderTemplate: Signal<TemplateRef<any>>;
    readonly toolbarTemplate: Signal<TemplateRef<any>>;
    readonly disableLoadOnScroll: _angular_core.WritableSignal<boolean>;
    readonly previousViewType: _angular_core.WritableSignal<unknown>;
    readonly previousViewOptions: _angular_core.WritableSignal<unknown>;
    configService: GanttConfigService;
    linkable: Signal<boolean>;
    linkDragEnded?: OutputEmitterRef<GanttLinkDragEvent>;
    view: GanttView;
    items: GanttItemInternal[];
    groups: GanttGroupInternal[];
    baselineItems: GanttBaselineItemInternal[];
    baselineItemsMap: Dictionary<GanttBaselineItemInternal>;
    get element(): HTMLElement;
    dragContainer: GanttDragContainer;
    unsubscribe$: Subject<void>;
    selectionModel: SelectionModel<string>;
    table?: Signal<NgxGanttTableComponent>;
    private groupsMap;
    protected isEffectFinished: _angular_core.WritableSignal<boolean>;
    colors: Signal<{
        primary?: string;
        danger?: string;
        highlight?: string;
        background?: string;
        text?: {
            main?: string;
            muted?: string;
            light?: string;
            inverse?: string;
        };
        gray?: {
            100?: string;
            200?: string;
            300?: string;
            400?: string;
            500?: string;
            600?: string;
        };
    }>;
    ganttClass: boolean;
    constructor();
    private createView;
    private setupGroups;
    protected setupItems(): void;
    private setupBaselineItems;
    private setupExpandedState;
    private getViewDate;
    computeRefs(): void;
    private initSelectionModel;
    expandGroups(expanded: boolean): void;
    ngOnInit(): 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(): void;
    rerenderView(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttUpper, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GanttUpper, never, never, { "originItems": { "alias": "items"; "required": false; "isSignal": true; }; "originGroups": { "alias": "groups"; "required": false; "isSignal": true; }; "originBaselineItems": { "alias": "baselineItems"; "required": false; "isSignal": true; }; "viewType": { "alias": "viewType"; "required": false; "isSignal": true; }; "start": { "alias": "start"; "required": false; "isSignal": true; }; "end": { "alias": "end"; "required": false; "isSignal": true; }; "showTodayLine": { "alias": "showTodayLine"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "originStyles": { "alias": "styles"; "required": false; "isSignal": true; }; "showToolbar": { "alias": "showToolbar"; "required": false; "isSignal": true; }; "toolbarOptions": { "alias": "toolbarOptions"; "required": false; "isSignal": true; }; "viewOptions": { "alias": "viewOptions"; "required": false; "isSignal": true; }; "inputLinkOptions": { "alias": "linkOptions"; "required": false; "isSignal": true; }; "disabledLoadOnScroll": { "alias": "disabledLoadOnScroll"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "quickTimeFocus": { "alias": "quickTimeFocus"; "required": false; "isSignal": true; }; }, { "viewType": "viewTypeChange"; "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;
    readonly width: _angular_core.InputSignal<string | number>;
    readonly columnWidth: WritableSignal<string>;
    readonly name: _angular_core.InputSignal<string>;
    readonly showExpandIcon: _angular_core.InputSignal<boolean>;
    readonly templateRef: Signal<TemplateRef<any>>;
    readonly headerTemplateRef: Signal<TemplateRef<any>>;
    constructor();
    get classList(): DOMTokenList;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttTableColumnComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttTableColumnComponent, "ngx-gantt-column", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "showExpandIcon": { "alias": "showExpandIcon"; "required": false; "isSignal": true; }; }, {}, ["templateRef", "headerTemplateRef"], never, true, never>;
}

declare class GanttDragEvent<T = unknown> {
    item: GanttItem<T>;
}
declare class GanttTableEvent {
    columns: ReadonlyArray<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 abstract class GanttItemUpper implements OnDestroy {
    protected elementRef: ElementRef<HTMLElement>;
    protected ganttUpper: GanttUpper;
    readonly template: _angular_core.InputSignal<TemplateRef<any>>;
    readonly item: _angular_core.InputSignal<GanttItemInternal>;
    firstChange: boolean;
    unsubscribe$: Subject<void>;
    refsUnsubscribe$: Subject<void>;
    constructor();
    private itemChange;
    private setPositions;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttItemUpper, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GanttItemUpper, never, never, { "template": { "alias": "template"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NgxGanttBarComponent extends GanttItemUpper implements OnInit, AfterViewInit, OnDestroy {
    private dragContainer;
    private drag;
    private ngZone;
    ganttUpper: GanttUpper;
    readonly barClick: _angular_core.OutputEmitterRef<GanttBarClickEvent<unknown>>;
    readonly contentElementRef: Signal<ElementRef<HTMLDivElement>>;
    readonly previousItem: Signal<GanttItemInternal>;
    ganttItemClass: boolean;
    handles: QueryList<ElementRef<HTMLElement>>;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onBarClick(event: Event): void;
    private setContentBackground;
    stopPropagation(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttBarComponent, "ngx-gantt-bar,gantt-bar", never, {}, { "barClick": "barClick"; }, never, never, true, never>;
}

declare class NgxGanttPlaceholderComponent extends GanttItemUpper {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttPlaceholderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttPlaceholderComponent, "ngx-gantt-bar-placeholder,gantt-bar-placeholder", never, {}, {}, never, never, true, never>;
}

declare class NgxGanttBaselineComponent implements OnInit {
    private elementRef;
    ganttUpper: GanttUpper;
    readonly baselineItem: _angular_core.InputSignal<GanttBaselineItemInternal>;
    readonly template: _angular_core.InputSignal<TemplateRef<any>>;
    unsubscribe$: Subject<void>;
    ganttBaselineClass: boolean;
    constructor();
    ngOnInit(): void;
    private setPositions;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttBaselineComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttBaselineComponent, "ngx-gantt-baseline,gantt-baseline", never, { "baselineItem": { "alias": "baselineItem"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GanttCalendarGridComponent implements OnDestroy {
    ganttUpper: GanttUpper;
    private elementRef;
    get view(): _worktile_gantt.GanttView;
    private unsubscribe$;
    mainHeight: number;
    todayBorderRadius: number;
    viewTypes: typeof GanttViewType;
    className: string;
    constructor();
    setTodayPoint(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttCalendarGridComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttCalendarGridComponent, "gantt-calendar-grid", never, {}, {}, never, never, true, never>;
}

declare class GanttCalendarHeaderComponent implements OnInit {
    ganttUpper: GanttUpper;
    private elementRef;
    get view(): _worktile_gantt.GanttView;
    private unsubscribe$;
    viewTypes: typeof GanttViewType;
    className: string;
    constructor();
    ngOnInit(): void;
    setTodayPoint(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttCalendarHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttCalendarHeaderComponent, "gantt-calendar-header", never, {}, {}, never, never, true, never>;
}

declare class GanttDragBackdropComponent {
    ganttUpper: GanttUpper;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttDragBackdropComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttDragBackdropComponent, "gantt-drag-backdrop", never, {}, {}, never, never, true, never>;
}

declare class GanttLoaderComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttLoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttLoaderComponent, "gantt-loader", never, {}, {}, never, never, true, never>;
}

declare class NgxGanttRangeComponent extends GanttItemUpper {
    ganttRangeClass: boolean;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttRangeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttRangeComponent, "ngx-gantt-range,gantt-range", never, {}, {}, never, never, true, never>;
}

declare class NgxGanttRootComponent implements OnDestroy {
    private elementRef;
    private ngZone;
    private dom;
    dragContainer: GanttDragContainer;
    ganttUpper: GanttUpper;
    private printService;
    private cdr;
    readonly sideWidth: _angular_core.InputSignal<number>;
    readonly sideTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly mainTemplate: _angular_core.Signal<TemplateRef<any>>;
    /** The native `<gantt-drag-backdrop></gantt-drag-backdrop>` element. */
    readonly backdrop: _angular_core.Signal<ElementRef<any>>;
    verticalScrollbarWidth: number;
    horizontalScrollbarHeight: number;
    private unsubscribe$;
    private get view();
    onWindowResize(): void;
    constructor();
    computeScrollBarOffset(): void;
    ngOnDestroy(): void;
    private setupViewScroll;
    private setupResize;
    private setupScrollClass;
    scrollToToday(): void;
    scrollToDate(date: number | Date | GanttDate): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttRootComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttRootComponent, "ngx-gantt-root", never, { "sideWidth": { "alias": "sideWidth"; "required": false; "isSignal": true; }; }, {}, ["sideTemplate", "mainTemplate"], ["*"], true, never>;
}

declare class GanttScrollbarComponent {
    ganttUpper: GanttUpper;
    hasFooter: _angular_core.InputSignal<boolean>;
    tableWidth: _angular_core.InputSignal<number>;
    ganttRoot: _angular_core.InputSignal<NgxGanttRootComponent>;
    tableScrollWidth: _angular_core.InputSignal<number>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttScrollbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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 NgxGanttToolbarComponent {
    protected ganttUpper: GanttUpper;
    readonly template: _angular_core.InputSignal<TemplateRef<any>>;
    ganttItemClass: boolean;
    views: Record<GanttViewType, {
        label: string;
        tickFormats: {
            period?: string;
            unit?: string;
        };
    }>;
    constructor();
    selectView(view: GanttViewType): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttToolbarComponent, "ngx-gantt-toolbar,gantt-toolbar", never, { "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GanttSyncScrollXDirective implements OnInit, OnDestroy {
    readonly syncScrollX: _angular_core.InputSignal<string>;
    private elementRef;
    private syncScrollService;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttSyncScrollXDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GanttSyncScrollXDirective, "[syncScrollX]", never, { "syncScrollX": { "alias": "syncScrollX"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class GanttSyncScrollYDirective implements OnInit, OnDestroy {
    readonly syncScrollY: _angular_core.InputSignal<string>;
    private syncScrollService;
    private elementRef;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttSyncScrollYDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GanttSyncScrollYDirective, "[syncScrollY]", never, { "syncScrollY": { "alias": "syncScrollY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GanttPrintService {
    private root;
    private mainContainer;
    constructor();
    private setInlineStyles;
    private recursElementChildren;
    register(root: ElementRef<HTMLElement>): void;
    html2canvas(ignoreElementClass?: string): Promise<HTMLCanvasElement>;
    print(name?: string, ignoreElementClass?: string): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttPrintService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GanttPrintService>;
}

declare class GanttSyncScrollService {
    private ngZone;
    private scrollGroupsMap;
    constructor();
    registerScrollEvent(groupName: string, element: HTMLElement, direction: 'x' | 'y'): void;
    unregisterScrollEvent(groupName: string, element: HTMLElement): void;
    private monitorScrollChange;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttSyncScrollService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GanttSyncScrollService>;
}

declare class NgxGanttComponent extends GanttUpper implements OnInit, AfterViewInit {
    private viewportRuler;
    readonly maxLevel: _angular_core.InputSignal<number>;
    readonly async: _angular_core.InputSignal<boolean>;
    readonly childrenResolve: _angular_core.InputSignal<(GanttItem: any) => Observable<GanttItem[]>>;
    readonly linkable: _angular_core.InputSignal<boolean>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly virtualScrollEnabled: _angular_core.InputSignal<boolean>;
    readonly loadingDelay: _angular_core.InputSignal<number>;
    readonly linkDragStarted: _angular_core.OutputEmitterRef<GanttLinkDragEvent<unknown>>;
    readonly linkDragEnded: _angular_core.OutputEmitterRef<GanttLinkDragEvent<unknown>>;
    readonly lineClick: _angular_core.OutputEmitterRef<GanttLineClickEvent<unknown>>;
    readonly selectedChange: _angular_core.OutputEmitterRef<GanttSelectedEvent<unknown>>;
    readonly virtualScrolledIndexChange: _angular_core.OutputEmitterRef<GanttVirtualScrolledIndexChangeEvent>;
    readonly table: _angular_core.Signal<NgxGanttTableComponent>;
    readonly columns: _angular_core.Signal<readonly NgxGanttTableColumnComponent[]>;
    readonly ganttRoot: _angular_core.Signal<NgxGanttRootComponent>;
    readonly footerTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly virtualScroll: _angular_core.Signal<CdkVirtualScrollViewport>;
    readonly ganttTableBody: _angular_core.Signal<ElementRef<HTMLDivElement>>;
    realLoading: boolean;
    tableScrollWidth: _angular_core.WritableSignal<number>;
    private resizeObserver;
    flatItems: (GanttGroupInternal | GanttItemInternal)[];
    viewportItems: (GanttGroupInternal | GanttItemInternal)[];
    private loadingTimer;
    private rangeStart;
    private rangeEnd;
    private flatItemsMap;
    private draggingItem;
    constructor();
    ngOnInit(): void;
    computeRefs(): void;
    setupItems(): void;
    ngAfterViewInit(): 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: _angular_core.ɵɵFactoryDeclaration<NgxGanttComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxGanttComponent, "ngx-gantt", never, { "maxLevel": { "alias": "maxLevel"; "required": false; "isSignal": true; }; "async": { "alias": "async"; "required": false; "isSignal": true; }; "childrenResolve": { "alias": "childrenResolve"; "required": false; "isSignal": true; }; "linkable": { "alias": "linkable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "virtualScrollEnabled": { "alias": "virtualScrollEnabled"; "required": false; "isSignal": true; }; "loadingDelay": { "alias": "loadingDelay"; "required": false; "isSignal": true; }; }, { "linkDragStarted": "linkDragStarted"; "linkDragEnded": "linkDragEnded"; "lineClick": "lineClick"; "selectedChange": "selectedChange"; "virtualScrolledIndexChange": "virtualScrolledIndexChange"; }, ["table", "columns", "footerTemplate"], never, true, never>;
}

interface GanttAbstractComponent {
    table: Signal<NgxGanttTableComponent>;
    styles: Signal<GanttStyleOptions>;
    maxLevel: Signal<number>;
    async: Signal<boolean>;
    cdr: ChangeDetectorRef;
    expandGroup(group: GanttGroupInternal): void;
    expandChildren(item: GanttItemInternal): void;
}

declare class GanttTableHeaderComponent {
    private elementRef;
    gantt: GanttAbstractComponent;
    dragStartLeft: number;
    tableWidth: number;
    customWidth: number;
    private columnsLayoutInitialized;
    readonly columns: _angular_core.InputSignal<readonly NgxGanttTableColumnComponent[]>;
    readonly resizeLineElementRef: _angular_core.Signal<ElementRef<HTMLElement>>;
    className: string;
    constructor();
    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;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttTableHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttTableHeaderComponent, "gantt-table-header", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GanttTableBodyComponent implements OnDestroy, AfterViewInit {
    gantt: GanttAbstractComponent;
    ganttUpper: GanttUpper;
    private document;
    protected elementRef: ElementRef<HTMLElement>;
    readonly viewportItems: _angular_core.InputSignal<(GanttItemInternal | GanttGroupInternal)[]>;
    readonly hasGroup: _angular_core.Signal<boolean>;
    readonly ganttTableEmptyClass: _angular_core.Signal<boolean>;
    readonly flatItems: _angular_core.InputSignal<(GanttItemInternal | GanttGroupInternal)[]>;
    readonly columns: _angular_core.InputSignal<readonly NgxGanttTableColumnComponent[]>;
    readonly groupTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly emptyTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly rowBeforeTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly rowAfterTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly draggable: _angular_core.InputSignal<boolean>;
    readonly dropEnterPredicate: _angular_core.InputSignal<(context: GanttTableDragEnterPredicateContext) => boolean>;
    readonly dragDropped: _angular_core.OutputEmitterRef<GanttTableDragDroppedEvent<unknown>>;
    readonly dragStarted: _angular_core.OutputEmitterRef<GanttTableDragStartedEvent<unknown>>;
    readonly dragEnded: _angular_core.OutputEmitterRef<GanttTableDragEndedEvent<unknown>>;
    readonly itemClick: _angular_core.OutputEmitterRef<GanttSelectedEvent<unknown>>;
    cdkDrags: QueryList<CdkDrag<GanttItemInternal>>;
    readonly hasExpandIcon: _angular_core.WritableSignal<boolean>;
    private itemDragsMap;
    private itemDragMoved;
    private itemDropTarget;
    private destroy$;
    ganttTableDragging: boolean;
    constructor();
    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: _angular_core.ɵɵFactoryDeclaration<GanttTableBodyComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttTableBodyComponent, "gantt-table-body", never, { "viewportItems": { "alias": "viewportItems"; "required": false; "isSignal": true; }; "flatItems": { "alias": "flatItems"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "groupTemplate": { "alias": "groupTemplate"; "required": false; "isSignal": true; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; "isSignal": true; }; "rowBeforeTemplate": { "alias": "rowBeforeTemplate"; "required": false; "isSignal": true; }; "rowAfterTemplate": { "alias": "rowAfterTemplate"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "dropEnterPredicate": { "alias": "dropEnterPredicate"; "required": false; "isSignal": true; }; }, { "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;
    syncHorizontalScroll(left: number): void;
    setVisibleRangeX(): void;
    applyCssVariables(element: HTMLElement, options?: GanttStyleOptions): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttDomService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GanttDomService>;
}

declare class GanttMainComponent {
    ganttUpper: GanttUpper;
    dom: GanttDomService;
    protected ngZone: NgZone;
    readonly viewportItems: _angular_core.InputSignal<(GanttItemInternal | GanttGroupInternal)[]>;
    readonly flatItems: _angular_core.InputSignal<(GanttItemInternal | GanttGroupInternal)[]>;
    readonly groupHeaderTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly barTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly rangeTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly baselineTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly ganttRoot: _angular_core.InputSignal<NgxGanttRootComponent>;
    readonly quickTimeFocus: _angular_core.InputSignal<boolean>;
    readonly barClick: _angular_core.OutputEmitterRef<GanttBarClickEvent<unknown>>;
    readonly lineClick: _angular_core.OutputEmitterRef<GanttLineClickEvent<unknown>>;
    ganttMainClass: boolean;
    private unsubscribe$;
    constructor();
    toItemType(data: GanttItemInternal | GanttGroupInternal): GanttItemInternal;
    trackBy(index: number, item: GanttGroupInternal | GanttItemInternal): string | number;
    private setupResize;
    quickTime(item: GanttItem, type: 'left' | 'right'): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttMainComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttMainComponent, "gantt-main", never, { "viewportItems": { "alias": "viewportItems"; "required": false; "isSignal": true; }; "flatItems": { "alias": "flatItems"; "required": false; "isSignal": true; }; "groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "barTemplate": { "alias": "barTemplate"; "required": false; "isSignal": true; }; "rangeTemplate": { "alias": "rangeTemplate"; "required": false; "isSignal": true; }; "baselineTemplate": { "alias": "baselineTemplate"; "required": false; "isSignal": true; }; "ganttRoot": { "alias": "ganttRoot"; "required": false; "isSignal": true; }; "quickTimeFocus": { "alias": "quickTimeFocus"; "required": false; "isSignal": true; }; }, { "barClick": "barClick"; "lineClick": "lineClick"; }, never, never, true, never>;
}

declare class GanttLinksComponent implements OnInit, OnDestroy {
    ganttUpper: GanttUpper;
    private cdr;
    private elementRef;
    private ganttDragContainer;
    readonly flatItems: _angular_core.InputSignal<(GanttItemInternal | GanttGroupInternal)[]>;
    readonly lineClick: _angular_core.OutputEmitterRef<GanttLineClickEvent<unknown>>;
    links: LinkInternal[];
    ganttLinkTypes: typeof GanttLinkType;
    showArrow: boolean;
    private linkItems;
    private linkLine;
    private unsubscribe$;
    ganttLinksOverlay: boolean;
    constructor();
    ngOnInit(): 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: _angular_core.ɵɵFactoryDeclaration<GanttLinksComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttLinksComponent, "gantt-links-overlay", never, { "flatItems": { "alias": "flatItems"; "required": false; "isSignal": true; }; }, { "lineClick": "lineClick"; }, never, never, true, never>;
}

declare class GanttIconComponent {
    private elementRef;
    isIcon: boolean;
    readonly iconName: _angular_core.InputSignal<string>;
    constructor();
    setSvg(name: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GanttIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GanttIconComponent, "gantt-icon", never, { "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IsGanttRangeItemPipe implements PipeTransform {
    transform(value: GanttItemType): value is GanttItemType.range;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsGanttRangeItemPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsGanttRangeItemPipe, "isGanttRangeItem", true>;
}
declare class IsGanttBarItemPipe implements PipeTransform {
    transform(value: GanttItemType): value is GanttItemType.bar;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsGanttBarItemPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsGanttBarItemPipe, "isGanttBarItem", true>;
}
declare class IsGanttCustomItemPipe implements PipeTransform {
    transform(value: GanttItemType): value is GanttItemType.custom;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsGanttCustomItemPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsGanttCustomItemPipe, "isGanttCustomItem", true>;
}
declare class IsGanttGroupPipe implements PipeTransform {
    transform(data: GanttItemInternal | GanttGroupInternal): data is GanttGroupInternal;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsGanttGroupPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsGanttGroupPipe, "isGanttGroup", true>;
}

declare class NgxGanttModule {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxGanttModule, never>;
    static ɵmod: _angular_core.ɵɵ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 NgxGanttPlaceholderComponent, 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 NgxGanttPlaceholderComponent, typeof GanttCalendarHeaderComponent, typeof GanttCalendarGridComponent, typeof GanttDragBackdropComponent, typeof GanttScrollbarComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NgxGanttModule>;
}

declare const _default$5: {
    id: GanttI18nLocale;
    views: {
        hour: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        day: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        week: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        month: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        quarter: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        year: {
            label: string;
            tickFormats: {
                unit: string;
            };
        };
    };
};

declare const _default$4: {
    id: GanttI18nLocale;
    views: {
        hour: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        day: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        week: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        month: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        quarter: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        year: {
            label: string;
            tickFormats: {
                unit: string;
            };
        };
    };
};

declare const _default$3: {
    id: GanttI18nLocale;
    views: {
        hour: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        day: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        week: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        month: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        quarter: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        year: {
            label: string;
            tickFormats: {
                unit: string;
            };
        };
    };
};

declare const _default$2: {
    id: GanttI18nLocale;
    views: {
        hour: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        day: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        week: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        month: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        quarter: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        year: {
            label: string;
            tickFormats: {
                unit: string;
            };
        };
    };
};

declare const _default$1: {
    id: GanttI18nLocale;
    dateLocale: Locale;
    views: {
        hour: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        day: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        week: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        month: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        quarter: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        year: {
            label: string;
            tickFormats: {
                unit: string;
            };
        };
    };
};

declare const _default: {
    id: GanttI18nLocale;
    dateLocale: Locale;
    views: {
        hour: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        day: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        week: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        month: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        quarter: {
            label: string;
            tickFormats: {
                period: string;
                unit: string;
            };
        };
        year: {
            label: string;
            tickFormats: {
                unit: string;
            };
        };
    };
};

declare function registerView<T extends typeof GanttView>(type: string, view: T): void;

export { GANTT_GLOBAL_CONFIG, GANTT_I18N_LOCALE_TOKEN, GANTT_UPPER_TOKEN, GanttBarClickEvent, GanttBaselineItemInternal, GanttCalendarGridComponent, GanttCalendarHeaderComponent, GanttConfigService, GanttDate, GanttDragBackdropComponent, GanttDragEvent, GanttGroupInternal, GanttI18nLocale, GanttItemInternal, GanttItemType, GanttItemUpper, GanttLineClickEvent, GanttLinkDragEvent, GanttLinkLineType, GanttLinkType, GanttLoadOnScrollEvent, GanttLoaderComponent, GanttPrintService, GanttScrollbarComponent, GanttSelectedEvent, GanttSyncScrollService, GanttSyncScrollXDirective, GanttSyncScrollYDirective, GanttTableDragDroppedEvent, GanttTableDragEndedEvent, GanttTableDragEnterPredicateContext, GanttTableDragStartedEvent, GanttTableEvent, GanttTableItemClickEvent, GanttUpper, GanttView, GanttViewTick, GanttViewType, GanttVirtualScrolledIndexChangeEvent, IsGanttBarItemPipe, IsGanttCustomItemPipe, IsGanttGroupPipe, IsGanttRangeItemPipe, NgxGanttBarComponent, NgxGanttBaselineComponent, NgxGanttComponent, NgxGanttModule, NgxGanttPlaceholderComponent, NgxGanttRangeComponent, NgxGanttRootComponent, NgxGanttTableColumnComponent, NgxGanttTableComponent, NgxGanttToolbarComponent, PERIOD_TICK_TOP, PERIOD_TICK_TOP as PRIMARY_TICK_TOP, UNIT_TICK_TOP as SECONDARY_TICK_TOP, UNIT_TICK_TOP, _default$1 as deDeLocale, defaultConfig, _default$3 as enUsLocale, getDefaultTimeZone, _default$2 as jaJpLocale, registerView, _default as ruRuLocale, setDefaultTimeZone, _default$5 as zhHansLocale, _default$4 as zhHantLocale };
export type { GanttBaselineItem, GanttDateOptions, GanttDateUtil, GanttGlobalConfig, GanttGroup, GanttI18nLocaleConfig, GanttItem, GanttItemRefs, GanttLink, GanttLinkItem, GanttLinkOptions, GanttStyleOptions, GanttTableDropPosition, GanttToolbarOptions, GanttViewDate, GanttViewOptions, LinkInternal };