@timelinekit/core 1.0.0

package/dist/ganttchart/locale.d.ts

@@ -0,0 +1,66 @@
+import type { ConstraintType } from "./model/task";
+import type { TaskLinkType } from "./model/task-link";
+export interface TimelineKitLocale {
+    /** BCP 47 language tag for Intl formatting (dates, numbers), e.g. 'en-US', 'cs-CZ', 'de-DE' */
+    language: string;
+    columns: {
+        name: string;
+        length: string;
+        start: string;
+        end: string;
+        progress: string;
+        resources: string;
+        work: string;
+        cost: string;
+    };
+    columnTooltips: {
+        work: string;
+        cost: string;
+    };
+    tooltips: {
+        addTask: string;
+        addTaskPart: string;
+        moveTask: string;
+        moveTaskPart: string;
+        resizeTask: string;
+        resizeTaskPart: string;
+        moveMilestone: string;
+        setProgress: string;
+        addLink: string;
+    };
+    labels: {
+        start: string;
+        end: string;
+        length: string;
+        progress: string;
+        from: string;
+        to: string;
+        type: string;
+        lag: string;
+    };
+    constraints: Record<ConstraintType, string>;
+    linkTypes: Record<TaskLinkType, string>;
+    warnings: {
+        behindSchedule: string;
+        behindScheduleByOneDay: string;
+        behindScheduleByDays: (days: number) => string;
+        constraintViolation: (constraintLabel: string, date: string) => string;
+    };
+    export: {
+        tasksSheetName: string;
+        linksSheetName: string;
+        resourcesSheetName: string;
+        eventsSheetName: string;
+    };
+    scheduler: {
+        resource: string;
+        name: string;
+        type: string;
+        addEvent: string;
+        moveEvent: string;
+        resizeEvent: string;
+    };
+    /** Optional custom date parser. Receives raw user input, returns Date or null. */
+    dateParser?: (value: string) => Date | null;
+}
+export declare const defaultLocale: TimelineKitLocale;

package/dist/ganttchart/model/custom-property.d.ts

@@ -0,0 +1 @@
+export { CustomProperty } from "../../common/custom-property";

package/dist/ganttchart/model/lag.d.ts

@@ -0,0 +1,16 @@
+import { LengthUnit } from "./length";
+import { WorkingCalendar } from "./working-calendar";
+export declare class Lag {
+    #private;
+    get unit(): LengthUnit;
+    get value(): number;
+    constructor(unit: LengthUnit, value: number);
+    toHours(calendar: WorkingCalendar): number;
+    toString(): string;
+    equals(other: Lag): boolean;
+    static zero(): Lag;
+    static tryParse(value: string): Lag | null;
+    static parse(value: string): Lag;
+    toAny(): any;
+    static fromAny(obj: any): Lag;
+}

package/dist/ganttchart/model/length.d.ts

@@ -0,0 +1,16 @@
+import { WorkingCalendar } from "./working-calendar";
+export declare class Length {
+    #private;
+    get unit(): LengthUnit;
+    get value(): number;
+    constructor(unit: LengthUnit, value: number);
+    getEndTime(startTime: Date, calendar: WorkingCalendar): Date;
+    static getLength(startTime: Date, endTime: Date, unit: LengthUnit, calendar: WorkingCalendar): Length;
+    equals(length: Length): boolean;
+    toString(): string;
+    static tryParse(value: string): Length | null;
+    static parse(value: string): Length;
+    static fromAny(obj: any): Length;
+    toAny(): any;
+}
+export type LengthUnit = 'Minute' | 'Hour' | 'Day' | 'Week' | 'Month';

package/dist/ganttchart/model/marker.d.ts

@@ -0,0 +1,7 @@
+export interface Marker {
+    date: Date;
+    label?: string;
+    color?: string;
+    lineWidth?: number;
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+}

package/dist/ganttchart/model/rate.d.ts

@@ -0,0 +1,9 @@
+export declare class Rate {
+    #private;
+    get value(): number;
+    get type(): RateType;
+    constructor(value: number, type: RateType);
+    toAny(): any;
+    static fromAny(obj: any): Rate;
+}
+export type RateType = 'PerDay' | 'PerHour';

package/dist/ganttchart/model/resource-list.d.ts

@@ -0,0 +1,16 @@
+import { Subject } from "rxjs";
+import { Resource, ResourceEventArgs } from "./resource";
+export declare class ResourceList {
+    #private;
+    resourceChanged$: Subject<ResourceEventArgs>;
+    resourceRemoved$: Subject<ResourceEventArgs>;
+    resourceRemoving$: Subject<ResourceEventArgs>;
+    constructor();
+    get length(): number;
+    indexOf(resource: Resource): number;
+    getResource(index: number): Resource;
+    getResourceById(id: string): Resource | null;
+    addResource(resource: Resource): Resource;
+    assign(resources: Resource[]): void;
+    removeResource(resource: Resource): void;
+}

package/dist/ganttchart/model/resource.d.ts

@@ -0,0 +1,29 @@
+import { Subject } from "rxjs";
+import { ResourceList } from "./resource-list";
+import { Rate } from "./rate";
+export declare class Resource {
+    #private;
+    get id(): string;
+    get name(): string;
+    set name(value: string);
+    get type(): ResourceType;
+    set type(value: ResourceType);
+    get fixedCostPerUse(): number;
+    set fixedCostPerUse(value: number);
+    get fixedCostPerResource(): number;
+    set fixedCostPerResource(value: number);
+    get avatarIconUrl(): string | null;
+    set avatarIconUrl(value: string | null);
+    get list(): ResourceList | null;
+    set list(value: ResourceList | null);
+    get rate(): Rate | null;
+    set rate(value: Rate | null);
+    changed$: Subject<ResourceEventArgs>;
+    constructor(id: string | null, name: string, type: ResourceType);
+    toAny(): any;
+    static fromAny(obj: any): Resource;
+}
+export type ResourceType = 'Unique' | 'Generic';
+export interface ResourceEventArgs {
+    resource: Resource;
+}

package/dist/ganttchart/model/sheet-column.d.ts

@@ -0,0 +1,27 @@
+import { Subject } from "rxjs";
+import { SheetCellEditor } from "../sheet/editors/cell-editor";
+import { SheetCellRenderer } from "../sheet/renderers/sheet-cell-renderer";
+import { Task } from "./task";
+export declare class SheetColumn {
+    #private;
+    get code(): string;
+    get name(): string;
+    get width(): number;
+    set width(value: number);
+    get minWidth(): number;
+    set minWidth(value: number);
+    get valueFormatter(): SheetCellValueFormatter;
+    get renderer(): SheetCellRenderer;
+    get align(): TextAlign | null;
+    get editor(): SheetCellEditor | null;
+    get isEditable(): SheetCellIsEditable;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get tooltip(): string | null;
+    get isCustom(): boolean;
+    changed$: Subject<SheetColumn>;
+    constructor(code: string, name: string, valueFormatter: SheetCellValueFormatter, renderer: SheetCellRenderer, editor: SheetCellEditor | null, isEditable: SheetCellIsEditable, width?: number, minWidth?: number, align?: TextAlign, tooltip?: string);
+}
+export type SheetCellValueFormatter = (task: Task) => string;
+export type TextAlign = 'Left' | 'Center' | 'Right';
+export type SheetCellIsEditable = (task: Task) => boolean;

package/dist/ganttchart/model/task-filters.d.ts

@@ -0,0 +1,14 @@
+import { Task } from "./task";
+import { Resource } from "./resource";
+import { TaskFilterFn } from "./task-list";
+export declare const TaskFilters: {
+    criticalPath: (task: Task) => boolean;
+    incomplete: (task: Task) => boolean;
+    complete: (task: Task) => boolean;
+    behindSchedule: (task: Task) => boolean;
+    milestones: (task: Task) => boolean;
+    byResource: (resource: Resource) => TaskFilterFn;
+    byDateRange: (start: Date, end: Date) => TaskFilterFn;
+    byName: (search: string) => TaskFilterFn;
+    combine: (...filters: TaskFilterFn[]) => TaskFilterFn;
+};

package/dist/ganttchart/model/task-link.d.ts

@@ -0,0 +1,22 @@
+import { Lag } from "./lag";
+import { Task } from "./task";
+import { TaskList } from "./task-list";
+export declare class TaskLink {
+    #private;
+    get id(): string;
+    get from(): Task;
+    get to(): Task;
+    get type(): TaskLinkType;
+    get lag(): Lag;
+    get list(): TaskList | null;
+    set list(value: TaskList | null);
+    constructor(id: string | null, from: Task, to: Task, type: TaskLinkType, lag?: Lag);
+    toAny(): any;
+    static fromAny(obj: any, tasks: Task[]): TaskLink;
+}
+export type TaskLinkType = 'FinishToStart' | 'StartToStart' | 'FinishToFinish' | 'StartToFinish';
+export type ConnectorSide = 'Start' | 'Finish';
+export declare function getLinkType(fromSide: ConnectorSide, toSide: ConnectorSide): TaskLinkType;
+export interface TaskLinkEventArgs {
+    link: TaskLink;
+}

package/dist/ganttchart/model/task-list-adapter.d.ts

@@ -0,0 +1,28 @@
+import { Subject } from "rxjs";
+import { TableItemEventArgs, TreeTableDataSource } from "../../table/table-data-source";
+import { Task } from "./task";
+import { TaskList } from "./task-list";
+export declare class TaskListAdapter implements TreeTableDataSource<Task> {
+    #private;
+    itemChanged$: Subject<TableItemEventArgs<Task>>;
+    itemRemoved$: Subject<TableItemEventArgs<Task>>;
+    itemCollapsedChanged$: Subject<TableItemEventArgs<Task>>;
+    complexOperationFinished$: Subject<void>;
+    constructor(list: TaskList);
+    get list(): TaskList;
+    get length(): number;
+    getItem(index: number): Task;
+    getItemById(id: string): Task | null;
+    indexOf(item: Task): number;
+    addEmptyItem(): Task;
+    insertEmptyItem(index: number): Task;
+    removeItems(items: Task[]): void;
+    getItemLabel(item: Task): string;
+    isItemHidden(item: Task): boolean;
+    getNextVisible(item: Task): Task | null;
+    getPreviousVisible(item: Task): Task | null;
+    indent(items: Task[]): void;
+    outdent(items: Task[]): void;
+    moveUp(items: Task[]): void;
+    moveDown(items: Task[]): void;
+}

package/dist/ganttchart/model/task-list.d.ts

@@ -0,0 +1,65 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { Lag } from "./lag";
+import { Task, TaskEventArgs, TaskResourceAddingEventArgs, TaskTypeChangeEventArgs } from "./task";
+import { WorkingCalendar } from "./working-calendar";
+import { TaskLink, TaskLinkEventArgs, TaskLinkType } from "./task-link";
+import { Resource } from "./resource";
+import { DateRange } from "../ganttchart-engine";
+import { TimelineKitLocale } from "../locale";
+export declare class TaskList {
+    #private;
+    taskAdded$: Subject<TaskEventArgs>;
+    taskChanged$: Subject<TaskEventArgs>;
+    taskRemoved$: Subject<TaskEventArgs>;
+    taskCollapsedChanged$: Subject<TaskEventArgs>;
+    taskTypeChanged$: Subject<TaskTypeChangeEventArgs>;
+    linkAdded$: Subject<TaskLinkEventArgs>;
+    linkRemoved$: Subject<TaskLinkEventArgs>;
+    resourceAdding$: Subject<TaskResourceAddingEventArgs>;
+    filterChanged$: Subject<void>;
+    constructor(calendar$: BehaviorSubject<WorkingCalendar>, projectTimeline$: BehaviorSubject<DateRange>, locale$?: BehaviorSubject<TimelineKitLocale>);
+    get length(): number;
+    get linksLength(): number;
+    get evaluatingDependencies(): boolean;
+    evaluatingDependenciesFinished$: Subject<void>;
+    complexOperationFinished$: Subject<void>;
+    get filter(): TaskFilterFn | null;
+    set filter(value: TaskFilterFn | null);
+    getTask(index: number): Task;
+    getTaskById(id: string): Task | null;
+    getLink(index: number): TaskLink;
+    indexOf(task: Task): number;
+    addEmptyTask(): Task;
+    insertEmptyTask(index: number): Task;
+    addTask(task: Task): Task;
+    insertTask(index: number, task: Task): Task;
+    getFirstTaskIndex(tasks: Task[]): number | null;
+    getLastNonEmpty(includeHidden?: boolean): Task | null;
+    getPreviousNonEmpty(task: Task, level: number | null): Task | null;
+    getNextVisible(task: Task): Task | null;
+    getPreviousVisible(task: Task): Task | null;
+    getNextNonEmpty(task: Task): Task | null;
+    indent(tasks: Task[]): void;
+    outdent(tasks: Task[]): void;
+    getTaskNumber(task: Task): number;
+    getNextSibling(task: Task): Task | null;
+    getNextSiblings(task: Task): Task[];
+    getNextAtLevel(task: Task, level: number): Task | null;
+    getLastDescendant(task: Task): Task;
+    existsLinkBetween(task1: Task, task2: Task): boolean;
+    isValidTypeForLink(task: Task): boolean;
+    wouldCreateCycle(from: Task, to: Task): boolean;
+    addLink(from: Task, to: Task, type: TaskLinkType, lag?: Lag): TaskLink;
+    removeTask(task: Task): void;
+    removeTasks(tasks: Task[]): void;
+    removeLink(link: TaskLink): void;
+    moveUp(tasks: Task[]): void;
+    moveDown(tasks: Task[]): void;
+    get minStartTime(): Date | null;
+    get maxEndTime(): Date | null;
+    clear(): void;
+    assign(tasks: Task[], links: TaskLink[]): void;
+    getTasksUsingResource(resource: Resource): Task[];
+    renameTaskProperty(oldName: string, newName: string): void;
+}
+export type TaskFilterFn = (task: Task) => boolean;

package/dist/ganttchart/model/task-part.d.ts

@@ -0,0 +1,39 @@
+import { Length } from "./length";
+import { Task } from "./task";
+import { BehaviorSubject, Subject } from "rxjs";
+import { WorkingCalendar } from "./working-calendar";
+export declare class TaskPart {
+    #private;
+    get startTime(): Date;
+    set startTime(value: Date);
+    get endTime(): Date;
+    set endTime(value: Date);
+    get length(): Length;
+    set length(value: Length);
+    get task(): Task | null;
+    set task(value: Task | null);
+    get calendar(): WorkingCalendar;
+    startTimeChanging: Subject<TaskPartDateEventArgs>;
+    endTimeChanging: Subject<TaskPartDateEventArgs>;
+    lengthChanging: Subject<TaskPartLengthEventArgs>;
+    startTimeChanged: Subject<void>;
+    endTimeChanged: Subject<void>;
+    lengthChanged: Subject<void>;
+    progressChanged: Subject<void>;
+    constructor(startTime: Date, length: Length, calendar$: BehaviorSubject<WorkingCalendar>);
+    get lengthInHours(): number;
+    get progress(): number | null;
+    toAny(): any;
+    static fromAny(obj: any, calendar$: BehaviorSubject<WorkingCalendar>): TaskPart;
+}
+export interface TaskPartDateEventArgs {
+    part: TaskPart;
+    value: Date;
+}
+export interface TaskPartLengthEventArgs {
+    part: TaskPart;
+    value: Length;
+}
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}

package/dist/ganttchart/model/task-resource.d.ts

@@ -0,0 +1,18 @@
+import { Subject } from "rxjs";
+import { Resource } from "./resource";
+import { ResourceList } from "./resource-list";
+export declare class TaskResource {
+    #private;
+    get id(): string;
+    get resource(): Resource;
+    get capacity(): number;
+    set capacity(value: number);
+    changed$: Subject<TaskResourceEventArgs>;
+    constructor(id: string | null, resource: Resource, capacity: number);
+    formatCapacity(): string;
+    toAny(): any;
+    static fromAny(obj: any, resources: ResourceList): TaskResource;
+}
+export interface TaskResourceEventArgs {
+    resource: TaskResource;
+}

package/dist/ganttchart/model/task-warnings.d.ts

@@ -0,0 +1,15 @@
+import { BehaviorSubject } from "rxjs";
+import { TimelineKitLocale } from "../locale";
+import { Task } from "./task";
+import { TaskList } from "./task-list";
+import { WorkingCalendar } from "./working-calendar";
+export declare class TaskWarnings {
+    #private;
+    get calendar(): WorkingCalendar;
+    constructor(list: TaskList, calendar: BehaviorSubject<WorkingCalendar>, locale: BehaviorSubject<TimelineKitLocale>);
+    private getTotalLength;
+    getProgressTime(task: Task): Date;
+    update(task: Task): void;
+    updateAll(): void;
+    private formatDelayedMessage;
+}

package/dist/ganttchart/model/task.d.ts

@@ -0,0 +1,131 @@
+import { TaskPart } from "./task-part";
+import { TaskList } from "./task-list";
+import { BehaviorSubject, Subject } from "rxjs";
+import { Length, LengthUnit } from "./length";
+import { WorkingCalendar } from "./working-calendar";
+import { TaskResource } from "./task-resource";
+import { Resource } from "./resource";
+import { Work } from "./work";
+import { ResourceList } from "./resource-list";
+import { CustomProperty } from "./custom-property";
+import { DateRange } from "../ganttchart-engine";
+export declare class Task {
+    #private;
+    get id(): string;
+    get color(): number;
+    set color(value: number);
+    get name(): string | null;
+    set name(value: string | null);
+    get startTime(): Date | null;
+    set startTime(value: Date);
+    get endTime(): Date | null;
+    set endTime(value: Date);
+    get number(): number;
+    get calendar(): WorkingCalendar;
+    get length(): Length | null;
+    set length(value: Length);
+    get customLengthUnit(): LengthUnit | null;
+    set customLengthUnit(value: LengthUnit | null);
+    get baseStartTime(): Date | null;
+    get lastPart(): TaskPart;
+    get type(): TaskType;
+    set type(value: TaskType);
+    get parent(): Task | null;
+    get list(): TaskList | null;
+    set list(value: TaskList | null);
+    get progress(): number | null;
+    set progress(value: number);
+    get collapsed(): boolean;
+    set collapsed(value: boolean);
+    get resourcesLength(): number;
+    getResource(i: number): TaskResource;
+    getResourceByResourceId(id: string): TaskResource | null;
+    getResourceById(id: string): TaskResource | null;
+    get work(): Work | null;
+    set work(value: Work | null);
+    get cost(): number | null;
+    set cost(value: number | null);
+    get note(): string | null;
+    set note(value: string | null);
+    warnings: string[];
+    get constraintType(): ConstraintType;
+    set constraintType(value: ConstraintType);
+    get constraintDate(): Date | null;
+    set constraintDate(value: Date | null);
+    get baselineStartTime(): Date | null;
+    set baselineStartTime(value: Date | null);
+    get baselineEndTime(): Date | null;
+    set baselineEndTime(value: Date | null);
+    /**
+     * Critical Path Method (CPM) computed values.
+     * Calculated by CriticalPathCalculator when showCriticalPath is enabled.
+     * These are not persisted — they are recalculated dynamically.
+     */
+    earlyStart: Date | null;
+    earlyFinish: Date | null;
+    lateStart: Date | null;
+    lateFinish: Date | null;
+    /** Total float in working hours. Zero means the task is on the critical path. */
+    totalFloat: number | null;
+    freeFloat: number | null;
+    isCritical: boolean;
+    changed$: Subject<TaskEventArgs>;
+    typeChanged$: Subject<TaskTypeChangeEventArgs>;
+    startTimeChanged$: Subject<TaskEventArgs>;
+    endTimeChanged$: Subject<TaskEventArgs>;
+    collapsedChanged$: Subject<TaskEventArgs>;
+    subtaskAdded$: Subject<TaskEventArgs>;
+    resourceAdding$: Subject<TaskResourceAddingEventArgs>;
+    constructor(id: string | null, calendar: BehaviorSubject<WorkingCalendar>, projectTimeline: BehaviorSubject<DateRange>);
+    addPart(startTime: Date, length: Length): TaskPart;
+    removePart(part: TaskPart): void;
+    get partsLength(): number;
+    getPart(i: number): TaskPart;
+    get subtasksLength(): number;
+    getSubtask(i: number): Task;
+    addSubtask(task: Task): void;
+    removeSubtask(task: Task): void;
+    get level(): number;
+    getNextSibling(): Task | null;
+    getNextAtLevel(level: number): Task | null;
+    get partsLengthInHours(): number;
+    indexOf(part: TaskPart): number;
+    isDescendantOf(task: Task): boolean;
+    toggleCollapsed(): void;
+    get filtered(): boolean;
+    set filtered(value: boolean);
+    get hidden(): boolean;
+    get isLengthEditable(): boolean;
+    get isStartTimeEditable(): boolean;
+    get isEndTimeEditable(): boolean;
+    get isProgressEditable(): boolean;
+    get isResourcesEditable(): boolean;
+    get isWorkEditable(): boolean;
+    get isCostEditable(): boolean;
+    serializeProperties(target: any): void;
+    deserializeProperties(source: any, resources: ResourceList): void;
+    deserializePropertiesHierarchy(source: any, allTasks: Task[]): void;
+    addResource(id: string | null, resource: Resource, capacity: number): TaskResource;
+    removeResource(resource: TaskResource): void;
+    addProperty(property: CustomProperty): void;
+    removeProperty(property: CustomProperty): void;
+    renameProperty(oldName: string, newName: string): void;
+    getPropertyByName(name: string): CustomProperty | null;
+    getPropertyValue(name: string): any;
+    setPropertyValue(name: string, value: any): void;
+    private arePartsOverlappingOrAdjacent;
+}
+export type TaskType = 'Task' | 'Milestone' | 'Summary' | 'Empty';
+export type ConstraintType = 'ASAP' | 'ALAP' | 'MSO' | 'MFO' | 'SNET' | 'SNLT' | 'FNET' | 'FNLT';
+export interface TaskEventArgs {
+    task: Task;
+}
+export interface TaskResourceAddingEventArgs {
+    task: Task;
+    resource: Resource;
+}
+export interface TaskTypeChangeEventArgs {
+    task: Task;
+    oldType: TaskType;
+    newType: TaskType;
+}

package/dist/ganttchart/model/work.d.ts

@@ -0,0 +1,17 @@
+import { WorkingCalendar } from "./working-calendar";
+export declare class Work {
+    #private;
+    get unit(): WorkUnit;
+    get value(): number;
+    constructor(unit: WorkUnit, value: number);
+    static tryParse(value: string): Work | null;
+    toString(): string;
+    toHours(calendar: WorkingCalendar): number;
+    static maxUnit(unit1: WorkUnit, unit2: WorkUnit): WorkUnit;
+    static fromHours(hours: number, unit: WorkUnit, calendar: WorkingCalendar): Work;
+    static sum(work1: Work, work2: Work): Work;
+    toAny(): any;
+    static fromAny(obj: any): Work;
+    clone(): Work;
+}
+export type WorkUnit = 'Minute' | 'Hour' | 'Day';

package/dist/ganttchart/model/working-calendar.d.ts

@@ -0,0 +1,32 @@
+import { LengthUnit } from "./length";
+export declare class WorkingCalendar {
+    #private;
+    workingDays: DayOfWeek[];
+    nationalHolidays: Date[];
+    shifts: WorkingShift[];
+    startOfWeek: DayOfWeek;
+    defaultLengthUnit: LengthUnit;
+    constructor();
+    isWorkingDay(current: Date): boolean;
+    moveToStartShift(current: Date, keepTimeIfInsideShift: boolean): Date;
+    moveToEndShift(current: Date, keepTimeIfInsideShift: boolean): Date;
+    getHoursPerDay(): number;
+    isEndOfDay(current: Date): boolean;
+    getEndOfWorkingDay(current: Date): Date;
+    getHoursBetween(time1: Date, time2: Date): number;
+    getStartOfWeek(current: Date): Date;
+    addHours(current: Date, hours: number, moveToNextIfHoursZero?: boolean): Date;
+}
+export type DayOfWeek = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday';
+export declare class WorkingShift {
+    start: TimeOfDay;
+    end: TimeOfDay;
+    constructor(start: TimeOfDay, end: TimeOfDay);
+    contains(current: Date, excludeStart?: boolean): boolean;
+    getLengthInMinutes(): number;
+}
+export declare class TimeOfDay {
+    hour: number;
+    minute: number;
+    constructor(hour: number, minute: number);
+}

package/dist/ganttchart/recalculator.d.ts

@@ -0,0 +1,6 @@
+import { GanttChartEngine } from "./ganttchart-engine";
+export declare class Recalculator {
+    #private;
+    constructor(ganttchart: GanttChartEngine);
+    recalculate(): void;
+}

package/dist/ganttchart/sheet/editors/cell-editor.d.ts

@@ -0,0 +1,23 @@
+import { SheetColumn } from "../../model/sheet-column";
+import { Task } from "../../model/task";
+import { GanttChartContext } from "../../ganttchart-engine";
+import { Subject } from "rxjs";
+export type SheetCellEditEndDirection = 'none' | 'down' | 'up' | 'right' | 'left';
+export declare abstract class SheetCellEditor {
+    #private;
+    protected gc: GanttChartContext | null;
+    invalidValue$: Subject<void>;
+    editEnded$: Subject<SheetCellEditEndDirection>;
+    protected cell: any;
+    protected task: Task | null;
+    get columnCode(): string | null;
+    constructor(getter: SheetCellEditorValueGetter, setter: SheetCellEditorValueSetter);
+    init(gc: GanttChartContext): void;
+    beginEdit(column: SheetColumn, cell: any, task: Task): void;
+    protected abstract beginEditInternal(cell: any, task: Task, value: any): void;
+    endEdit(newParsedValue: any, direction?: SheetCellEditEndDirection): void;
+    cancelEdit(): void;
+    abstract endEditIfModifiedElseCancel(): void;
+}
+export type SheetCellEditorValueGetter = (task: Task) => any;
+export type SheetCellEditorValueSetter = (task: Task, newValue: any) => void;

package/dist/ganttchart/sheet/editors/currency-editor.d.ts

@@ -0,0 +1,6 @@
+import { SheetInputCellEditor } from "./input-editor";
+export declare class SheetCurrencyCellEditor extends SheetInputCellEditor {
+    protected onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/ganttchart/sheet/editors/date-editor.d.ts

@@ -0,0 +1,6 @@
+import { SheetInputCellEditor } from "./input-editor";
+export declare class SheetDateCellEditor extends SheetInputCellEditor {
+    onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/ganttchart/sheet/editors/decimal-editor.d.ts

@@ -0,0 +1,6 @@
+import { SheetInputCellEditor } from "./input-editor";
+export declare class SheetDecimalCellEditor extends SheetInputCellEditor {
+    protected onInputCreated(input: any): void;
+    formatValue(value: any): string;
+    tryParseValue(value: any): any | null;
+}

package/dist/ganttchart/sheet/editors/dialog-editor.d.ts

@@ -0,0 +1,17 @@
+import { SheetCellEditor } from "./cell-editor";
+import { Task } from "../../model/task";
+import { Subject } from "rxjs";
+export declare class SheetDialogCellEditor extends SheetCellEditor {
+    beginEdit$: Subject<SheetCellDialogEditorArgs>;
+    cancelEdit$: Subject<void>;
+    endEdit$: Subject<void>;
+    constructor();
+    protected beginEditInternal(cell: any, task: Task, value: any): void;
+    endEditIfModifiedElseCancel(): void;
+}
+export interface SheetCellDialogEditorArgs {
+    task: Task;
+    columnCode: string;
+    cancelEdit$: Subject<void>;
+    endEdit$: Subject<void>;
+}