@timelinekit/core 1.0.0

package/dist/ganttchart/chart/chart-time-axis.d.ts

@@ -0,0 +1,32 @@
+import { BehaviorSubject } from "rxjs";
+import { TimelineKitLocale } from "../locale";
+import { WorkingCalendar } from "../model/working-calendar";
+export declare class ChartTimeline {
+    #private;
+    zoomIndex$: BehaviorSubject<number>;
+    visibleStartTime$: BehaviorSubject<Date>;
+    get currentZoom(): ChartTimeAxisZoom;
+    constructor(calendar$: BehaviorSubject<WorkingCalendar>, locale$: BehaviorSubject<TimelineKitLocale>);
+    createDefaultZooms(): ChartTimeAxisZoom[];
+    assignZooms(zooms: ChartTimeAxisZoom[], defaultZoomIndex: number): void;
+    zoomIn(): boolean;
+    zoomOut(): boolean;
+    findBestZoomIndex(minDate: Date, maxDate: Date, availableWidth: number): number;
+}
+export declare class ChartTimeAxisZoom {
+    axis: ChartTimeAxis[];
+    baseCellWidth: number;
+    constructor(axis: ChartTimeAxis[], baseCellWidth: number);
+}
+export declare class ChartTimeAxis {
+    #private;
+    unit: ChartTimeAxisUnit;
+    unitsPerCell: number;
+    formatter: (date: Date) => string;
+    constructor(unit: ChartTimeAxisUnit, unitsPerCell: number, calendar: BehaviorSubject<WorkingCalendar>, formatter: (date: Date) => string);
+    getCellStartTime(time: Date): Date;
+    getCellStartX(time: Date, visibleStart: Date, zoom: ChartTimeAxisZoom): number;
+    getAdd(time: Date, amount: number): Date;
+    getX(time: Date, visibleStart: Date, zoom: ChartTimeAxisZoom): number;
+}
+export type ChartTimeAxisUnit = 'Minute' | 'Hour' | 'Day' | 'Week' | 'Month' | 'Quarter' | 'Half' | 'Year';

package/dist/ganttchart/chart/chart.d.ts

@@ -0,0 +1,7 @@
+import { GanttChartContext } from "../ganttchart-engine";
+export declare class Chart {
+    #private;
+    constructor(gc: GanttChartContext, chartElement: any);
+    get chartWidth(): number;
+    destroy(): void;
+}

package/dist/ganttchart/chart/handlers/add-task-part.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class AddTaskPartHandler extends ChartHandler {
+    #private;
+    constructor(gc: GanttChartContext);
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/connector-dots-handler.d.ts

@@ -0,0 +1,16 @@
+import { BehaviorSubject } from "rxjs";
+import { Point } from "../../../common/common";
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class ConnectorDotsHandler extends ChartHandler {
+    #private;
+    connectorDotsTask$: BehaviorSubject<Task | null>;
+    constructor(gc: GanttChartContext);
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseLeave(p: Point, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/handler.d.ts

@@ -0,0 +1,32 @@
+import { Point } from "../../../common/common";
+import { BaseChartHandlerBase } from "../../../common/base-chart-handler";
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { TaskPart } from "../../model/task-part";
+import { ChartTooltipLine } from "../tooltip/chart-tooltip-renderer";
+export declare abstract class ChartHandler extends BaseChartHandlerBase {
+    #private;
+    constructor(gc: GanttChartContext);
+    protected getTaskRowAt(p: Point): Task | null;
+    protected getTaskAt(p: Point): TaskAt | null;
+    protected getShapeHeight(task: Task): number;
+    protected containsVertically(task: Task, p: Point): boolean;
+    protected getTaskPartAt(task: Task, p: Point, trailingTolerance?: number): TaskPartAt | null;
+    protected getRowY(task: Task): number;
+    protected drawTaskProgressHighlight(task: Task, x1: number, x2: number): void;
+    protected drawTaskHighlightX1X2(task: Task, x1: number, x2: number): void;
+    protected drawTaskHighlight(task: Task): void;
+    protected drawTooltip(forTasks: Task[], startX: number, title: string, lines: ChartTooltipLine[]): void;
+}
+export { ChartHandlerResult } from "../../../common/handler-result";
+export interface TaskAt {
+    task: Task;
+    taskPart: TaskPart | null;
+    x1: number;
+    x2: number;
+}
+export interface TaskPartAt {
+    taskPart: TaskPart | null;
+    x1: number;
+    x2: number;
+}

package/dist/ganttchart/chart/handlers/handlers.d.ts

@@ -0,0 +1,14 @@
+import { Subject } from "rxjs";
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ClassWithListeners } from "../../../common/class-with-listeners";
+export declare class ChartHandlers extends ClassWithListeners {
+    #private;
+    operationComplete$: Subject<void>;
+    redraw$: Subject<void>;
+    constructor(gc: GanttChartContext, chartElement: any);
+    getMousePosition(event: any): Point;
+    init(chartElement: any, canvas: any): void;
+    clear(): void;
+    private isWithinScrollbar;
+}

package/dist/ganttchart/chart/handlers/move-milestone.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class MoveMilestoneHandler extends ChartHandler {
+    #private;
+    constructor(gc: GanttChartContext);
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/move-task-part.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class MoveTaskPartHandler extends ChartHandler {
+    #private;
+    constructor(gc: GanttChartContext);
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/resize-task-part.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class ResizeTaskPartHandler extends ChartHandler {
+    #private;
+    constructor(gc: GanttChartContext);
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/select-link.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class SelectLinkHandler extends ChartHandler {
+    #private;
+    constructor(gc: GanttChartContext);
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/handlers/select-task.d.ts

@@ -0,0 +1,22 @@
+import { Subject } from "rxjs";
+import { Point } from "../../../common/common";
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class SelectTaskHandler extends ChartHandler {
+    #private;
+    dblClick$: Subject<Task>;
+    contextMenu$: Subject<TaskContextMenuArgs>;
+    constructor(gc: GanttChartContext);
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
+    onMouseLeave(p: Point, event: any): Promise<ChartHandlerResult>;
+    onContextMenu(p: Point, event: any): ChartHandlerResult;
+    onDblClick(p: Point, event: any): ChartHandlerResult;
+}
+export interface TaskContextMenuArgs {
+    task: Task;
+    mouseEvent: any;
+}

package/dist/ganttchart/chart/handlers/set-task-progress.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "../../../common/common";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { ChartHandler, ChartHandlerResult } from "./handler";
+export declare class SetTaskProgressHandler extends ChartHandler {
+    #private;
+    constructor(gc: GanttChartContext);
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseUp(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+}

package/dist/ganttchart/chart/renderers/chart-background-renderer.d.ts

@@ -0,0 +1,8 @@
+import { BaseBackgroundRenderer } from "../../../common/base-background-renderer";
+import { GanttChartContext } from "../../ganttchart-engine";
+export declare class ChartBackgroundRenderer extends BaseBackgroundRenderer {
+    #private;
+    constructor(gc: GanttChartContext);
+    protected getContentBottom(canvasHeight: number): number;
+    protected drawHorizontalGridLines(canvas: any, ctx: any): void;
+}

package/dist/ganttchart/chart/renderers/chart-header-renderer.d.ts

@@ -0,0 +1,7 @@
+import { GanttChartContext } from "../../ganttchart-engine";
+import { RendererBase } from "./renderer-base";
+export declare class ChartHeaderRenderer extends RendererBase {
+    #private;
+    constructor(gc: GanttChartContext);
+    render(canvas: any): void;
+}

package/dist/ganttchart/chart/renderers/chart-links-renderer.d.ts

@@ -0,0 +1,7 @@
+import { GanttChartContext } from "../../ganttchart-engine";
+import { RendererBase } from "./renderer-base";
+export declare class ChartLinksRenderer extends RendererBase {
+    #private;
+    constructor(gc: GanttChartContext);
+    render(canvas: any): void;
+}

package/dist/ganttchart/chart/renderers/chart-markers-renderer.d.ts

@@ -0,0 +1,7 @@
+import { GanttChartContext } from "../../ganttchart-engine";
+import { RendererBase } from "./renderer-base";
+export declare class ChartMarkersRenderer extends RendererBase {
+    #private;
+    constructor(gc: GanttChartContext);
+    render(canvas: any): void;
+}

package/dist/ganttchart/chart/renderers/chart-tasks-renderer.d.ts

@@ -0,0 +1,14 @@
+import { Rect } from "../../../common/common";
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { RendererBase } from "./renderer-base";
+export declare class ChartTasksRenderer extends RendererBase {
+    #private;
+    constructor(gc: GanttChartContext);
+    render(canvas: any): void;
+    drawTaskHighlightX1X2(ctx: any, task: Task, x1: number, x2: number): void;
+    drawTaskProgressHighlight(ctx: any, task: Task, x1: number, x2: number): void;
+    drawTaskHighlight(ctx: any, task: Task): void;
+}
+export declare function createGradientVertical(ctx: any, rect: Rect, color1: string, color2: string): any;
+export declare function createGradientHorizontal(ctx: any, rect: Rect, color1: string, color2: string): any;

package/dist/ganttchart/chart/renderers/renderer-base.d.ts

@@ -0,0 +1,9 @@
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+export declare class RendererBase {
+    #private;
+    constructor(gc: GanttChartContext);
+    get rowHeight(): number;
+    protected getRowY(task: Task): number;
+    protected getContentBottom(canvasHeight: number): number;
+}

package/dist/ganttchart/chart/task-link.calculator.d.ts

@@ -0,0 +1,16 @@
+import { TaskLink } from "../model/task-link";
+import { GanttChartContext } from "../ganttchart-engine";
+export declare class TaskLinkCalculator {
+    #private;
+    constructor(gc: GanttChartContext);
+    get rowHeight(): number;
+    getCoords(link: TaskLink): TaskLinkCoordinates;
+}
+export interface TaskLinkCoordinates {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    sign: number;
+    type: string;
+}

package/dist/ganttchart/chart/task-progress-calculator.d.ts

@@ -0,0 +1,9 @@
+import { Task } from "../model/task";
+import { GanttChartContext } from "../ganttchart-engine";
+export declare class TaskProgressCalculator {
+    #private;
+    constructor(gc: GanttChartContext);
+    getTotalWidth(task: Task): number;
+    getProgressAt(task: Task, x: number): number;
+    getProgressX(task: Task, progress: number): number;
+}

package/dist/ganttchart/chart/tooltip/chart-tooltip-renderer.d.ts

@@ -0,0 +1,11 @@
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+export declare class ChartTooltipRenderer {
+    #private;
+    constructor(gc: GanttChartContext);
+    drawTooltip(canvas: any, forTasks: Task[], startX: number, title: string, lines: ChartTooltipLine[]): void;
+}
+export interface ChartTooltipLine {
+    name: string;
+    value: string;
+}

package/dist/ganttchart/clipboard.d.ts

@@ -0,0 +1,32 @@
+import { Task } from "./model/task";
+import { TaskList } from "./model/task-list";
+import { TaskLink, TaskLinkType } from "./model/task-link";
+import { ResourceList } from "./model/resource-list";
+import { WorkingCalendar } from "./model/working-calendar";
+import { BehaviorSubject } from "rxjs";
+export interface ClipboardContext {
+    list: TaskList;
+    resources: ResourceList;
+    calendar$: BehaviorSubject<WorkingCalendar>;
+    projectTimeline$: BehaviorSubject<any>;
+    sheetSelectedTasks$: BehaviorSubject<Task[]>;
+}
+export interface TasksPastedEventArgs {
+    tasks: Task[];
+    links: TaskLink[];
+    taskIdMap: Map<string, Task>;
+    droppedLinks: DroppedLinkInfo[];
+}
+export interface DroppedLinkInfo {
+    type: TaskLinkType;
+    fromId: string;
+    toId: string;
+    externalSide: 'from' | 'to';
+}
+export declare class ClipboardManager {
+    #private;
+    constructor(gc: ClipboardContext);
+    copy(tasks: Task[]): Promise<void>;
+    cut(tasks: Task[]): Promise<void>;
+    paste(): Promise<TasksPastedEventArgs | null>;
+}

package/dist/ganttchart/critical-path-calculator.d.ts

@@ -0,0 +1,7 @@
+import { TaskList } from "./model/task-list";
+import { WorkingCalendar } from "./model/working-calendar";
+export declare class CriticalPathCalculator {
+    #private;
+    constructor(list: TaskList, calendar: WorkingCalendar);
+    calculate(): void;
+}

package/dist/ganttchart/divider/divider.d.ts

@@ -0,0 +1,5 @@
+import { BaseDivider } from "../../common/base-divider";
+import { GanttChartContext } from "../ganttchart-engine";
+export declare class Divider extends BaseDivider {
+    constructor(gc: GanttChartContext, wrapperElement: any, sheetElement: any, dividerElement: any, chartElement: any);
+}

package/dist/ganttchart/export/data-exporter.d.ts

@@ -0,0 +1,30 @@
+import { GanttChartContext } from "../ganttchart-engine";
+import { Sheet } from "../sheet/sheet";
+export interface CsvExportOptions {
+    /** Column delimiter. Default: ',' */
+    delimiter?: ',' | ';' | '\t';
+    /** Include column headers? Default: true */
+    includeHeaders?: boolean;
+    /** Which columns to export (by code). Default: all visible columns */
+    columns?: string[];
+    /** Append dependency links as a separate section? Default: false */
+    includeLinks?: boolean;
+}
+export interface ExcelExportOptions {
+    /** Name of the tasks sheet. Default: 'Tasks' */
+    sheetName?: string;
+    /** Include a sheet with dependency links? Default: true */
+    includeLinksSheet?: boolean;
+    /** Include a sheet with resources? Default: true */
+    includeResourcesSheet?: boolean;
+    /** Apply cell formatting (bold summary rows, column widths)? Default: true */
+    includeFormatting?: boolean;
+    /** Which columns to export (by code). Default: all visible columns */
+    columns?: string[];
+}
+export declare class DataExporter {
+    #private;
+    constructor(gc: GanttChartContext, sheet: Sheet);
+    exportToCsv(options?: CsvExportOptions): string;
+    exportToExcel(options?: ExcelExportOptions): Promise<Blob>;
+}

package/dist/ganttchart/export/export-common.d.ts

@@ -0,0 +1,23 @@
+import { BaseExportDimensions } from "../../common/export-utils";
+import { GanttChartContext } from "../ganttchart-engine";
+import { Sheet } from "../sheet/sheet";
+import { GanttChartTheme } from "../themes/theme";
+export interface ExportColumn {
+    code: string;
+    name: string;
+    width: number;
+    align: string | null;
+    valueFormatter: (task: any) => string;
+}
+export interface ExportDimensions extends BaseExportDimensions {
+    visibleColumns: ExportColumn[];
+    visibleRowCount: number;
+}
+export declare class ExportRenderer {
+    #private;
+    constructor(gc: GanttChartContext, sheet: Sheet);
+    get theme(): GanttChartTheme;
+    calculateDimensions(): ExportDimensions;
+    renderSheet(ctx: any, dims: ExportDimensions): void;
+    renderChart(ctx: any, sheetWidth: number, dims: ExportDimensions, scale?: number): void;
+}

package/dist/ganttchart/export/image-exporter.d.ts

@@ -0,0 +1,7 @@
+import { GanttChartContext } from "../ganttchart-engine";
+import { Sheet } from "../sheet/sheet";
+import { ExportDimensions } from "./export-common";
+import { BaseImageExporter } from "../../common/base-image-exporter";
+export declare class ImageExporter extends BaseImageExporter<ExportDimensions> {
+    constructor(gc: GanttChartContext, sheet: Sheet);
+}

package/dist/ganttchart/export/pdf-exporter.d.ts

@@ -0,0 +1,12 @@
+import { GanttChartContext } from "../ganttchart-engine";
+import { Sheet } from "../sheet/sheet";
+import { ExportDimensions } from "./export-common";
+import { BasePdfExporter } from "../../common/base-pdf-exporter";
+export type { BasePdfExportOptions as PdfExportOptions } from "../../common/export-utils";
+export declare class PdfExporter extends BasePdfExporter<ExportDimensions> {
+    constructor(gc: GanttChartContext, sheet: Sheet);
+    protected computeVerticalPageBreaks(dims: ExportDimensions, contentHeightPx: number, headerHeight: number): {
+        srcY: number;
+        height: number;
+    }[];
+}

package/dist/ganttchart/ganttchart-engine.d.ts

@@ -0,0 +1,172 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { TaskList, TaskFilterFn } from "./model/task-list";
+import { WorkingCalendar } from "./model/working-calendar";
+import { ChartTimeline } from "./chart/chart-time-axis";
+import { Sheet } from "./sheet/sheet";
+import { GanttChartTheme } from "./themes/theme";
+import { Task, TaskEventArgs } from "./model/task";
+import { ResourceList } from "./model/resource-list";
+import { TaskLinkEventArgs } from "./model/task-link";
+import { TaskContextMenuArgs } from "./chart/handlers/select-task";
+import { Cursor, DateRange } from "../common/common";
+import { CurrencySymbolDisplayMode } from "../common/functions";
+import type { CsvExportOptions, ExcelExportOptions } from "./export/data-exporter";
+import type { PdfExportOptions } from "./export/pdf-exporter";
+import type { Marker } from "./model/marker";
+import type { ColumnState } from "../table/table";
+import { TableContext, TableRowContextMenuEventArgs, TableColumnHeaderEventArgs, TableColumnEventArgs, TableCellEditing, TableFocusedCell, TableRowEventArgs } from "../table/table-context";
+import { DialogEditorArgs } from "../table/editors/dialog-editor";
+import { InputEditorArgs } from "../table/editors/input-editor";
+import { TimelineKitLocale } from "./locale";
+import { TasksPastedEventArgs } from "./clipboard";
+export declare class GanttChartEngine {
+    #private;
+    get list(): TaskList;
+    get resources(): ResourceList;
+    get calendar$(): BehaviorSubject<WorkingCalendar>;
+    set calendar$(value: WorkingCalendar);
+    get events(): GanttChartEvents;
+    get sheet(): Sheet;
+    get selectedTasks(): Task[];
+    get canEdit(): boolean;
+    set canEdit(value: boolean);
+    get showGridLines(): boolean;
+    set showGridLines(value: boolean);
+    get showCriticalPath(): boolean;
+    set showCriticalPath(value: boolean);
+    get showBaseline(): boolean;
+    set showBaseline(value: boolean);
+    get showTodayLine(): boolean;
+    set showTodayLine(value: boolean);
+    get markers(): Marker[];
+    set markers(value: Marker[]);
+    addMarker(marker: Marker): void;
+    removeMarker(marker: Marker): void;
+    clearMarkers(): void;
+    get filter(): TaskFilterFn | null;
+    set filter(value: TaskFilterFn | null);
+    clearFilter(): void;
+    get hasBaseline(): boolean;
+    saveBaseline(): void;
+    clearBaseline(): void;
+    constructor(hostElement: any);
+    destroy(): void;
+    get canUndo$(): BehaviorSubject<boolean>;
+    get canRedo$(): BehaviorSubject<boolean>;
+    undo(): void;
+    redo(): void;
+    zoomIn(): boolean;
+    zoomOut(): boolean;
+    indent(): false | void;
+    outdent(): false | void;
+    moveUp(): false | void;
+    moveDown(): false | void;
+    copy(): Promise<void>;
+    cut(): Promise<void>;
+    paste(): Promise<TasksPastedEventArgs | null>;
+    goToProjectStart(): void;
+    scrollToDate(date: Date): void;
+    scrollToTask(task: Task): void;
+    zoomToFit(tasks?: Task[]): void;
+    saveColumns(): ColumnState[];
+    loadColumns(states: ColumnState[]): void;
+    get projectTimeline(): DateRange;
+    set projectTimeline(value: DateRange);
+    get settings(): GanttChartSettings;
+    save(): string;
+    load(text: string): void;
+    exportToImage(): Promise<Blob>;
+    exportToCsv(options?: CsvExportOptions): string;
+    exportToPdf(options?: PdfExportOptions): Promise<Blob>;
+    exportToExcel(options?: ExcelExportOptions): Promise<Blob>;
+}
+export declare class GanttChartContext {
+    #private;
+    table: TableContext<Task>;
+    settings: GanttChartSettings;
+    locale$: BehaviorSubject<TimelineKitLocale>;
+    calendar$: BehaviorSubject<WorkingCalendar>;
+    list: TaskList;
+    resources: ResourceList;
+    timeline: ChartTimeline;
+    get sheetScrollTop$(): BehaviorSubject<number>;
+    get sheetRowAdded$(): Subject<TableRowEventArgs<Task>>;
+    get sheetSelectedTasks$(): BehaviorSubject<Task[]>;
+    get sheetFocusedCell$(): BehaviorSubject<TableFocusedCell<Task> | null>;
+    get sheetCellEditing$(): BehaviorSubject<TableCellEditing<Task> | null>;
+    get sheetCellDialogEdit$(): Subject<DialogEditorArgs<Task>>;
+    get sheetCellInputEdit$(): Subject<InputEditorArgs<Task>>;
+    get sheetCellInvalidValue$(): Subject<void>;
+    get sheetRowContextMenu$(): Subject<TableRowContextMenuEventArgs<Task>>;
+    get sheetColumnHeaderContextMenu$(): Subject<TableColumnHeaderEventArgs<Task>>;
+    get sheetColumnResized$(): Subject<TableColumnEventArgs<Task>>;
+    get sheetColumnReordered$(): Subject<TableColumnEventArgs<Task>>;
+    get canEdit$(): BehaviorSubject<boolean>;
+    get canEdit(): boolean;
+    sheetRowMouseOver$: BehaviorSubject<TaskEventArgs | null>;
+    autoScrolling: boolean;
+    chartMouseWheel$: Subject<any>;
+    chartRedrawn$: Subject<void>;
+    chartBackgroundRedrawn$: Subject<void>;
+    chartCursor$: Subject<Cursor>;
+    chartTaskHover$: BehaviorSubject<Task | null>;
+    theme$: BehaviorSubject<GanttChartTheme>;
+    showGridLines$: BehaviorSubject<boolean>;
+    showCriticalPath$: BehaviorSubject<boolean>;
+    showBaseline$: BehaviorSubject<boolean>;
+    showTodayLine$: BehaviorSubject<boolean>;
+    markers$: BehaviorSubject<Marker[]>;
+    taskDblClick$: Subject<TaskEventArgs>;
+    taskContextMenu$: Subject<TaskContextMenuArgs>;
+    chartContextMenu$: Subject<ChartContextMenuArgs>;
+    projectTimeline$: BehaviorSubject<DateRange>;
+    dividerPositionChanged$: Subject<void>;
+    dividerResizing$: BehaviorSubject<boolean>;
+    constructor();
+    getRowY(task: Task): number;
+    get calendar(): WorkingCalendar;
+}
+export declare class GanttChartEvents {
+    taskAdded$: Subject<TaskEventArgs>;
+    taskChanged$: Subject<TaskEventArgs>;
+    taskRemoved$: Subject<TaskEventArgs>;
+    taskDblClick$: Subject<TaskEventArgs>;
+    taskContextMenu$: Subject<TaskContextMenuArgs>;
+    chartContextMenu$: Subject<ChartContextMenuArgs>;
+    sheetRowContextMenu$: Subject<TableRowContextMenuEventArgs<Task>>;
+    sheetColumnHeaderContextMenu$: Subject<TableColumnHeaderEventArgs<Task>>;
+    sheetColumnResized$: Subject<TableColumnEventArgs<Task>>;
+    sheetColumnReordered$: Subject<TableColumnEventArgs<Task>>;
+    sheetCellDialogEdit$: Subject<DialogEditorArgs<Task>>;
+    sheetCellInputEdit$: Subject<InputEditorArgs<Task>>;
+    sheetCellEditing$: Subject<TableCellEditing<Task> | null>;
+    sheetCellInvalidValue$: Subject<void>;
+    projectTimeline$: Subject<DateRange>;
+    linkAdded$: Subject<TaskLinkEventArgs>;
+    linkRemoved$: Subject<TaskLinkEventArgs>;
+    tasksPasted$: Subject<TasksPastedEventArgs>;
+    undone$: Subject<void>;
+    redone$: Subject<void>;
+    constructor(gc: GanttChartContext);
+}
+export { DateRange } from "../common/common";
+export interface ChartContextMenuArgs {
+    date: Date;
+    area: 'header' | 'content';
+    task: Task | null;
+    mouseEvent: any;
+}
+export declare class GanttChartSettings {
+    #private;
+    private ctx;
+    get currencySymbol(): string;
+    set currencySymbol(value: string);
+    get currencySymbolDisplayMode(): CurrencySymbolDisplayMode;
+    set currencySymbolDisplayMode(value: CurrencySymbolDisplayMode);
+    get locale(): TimelineKitLocale;
+    set locale(value: TimelineKitLocale);
+    get theme(): GanttChartTheme;
+    set theme(value: GanttChartTheme);
+    changed$: Subject<void>;
+    constructor(ctx: GanttChartContext);
+}