@timelinekit/core 1.0.0 → 1.0.3

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

@@ -1,8 +1,8 @@
-import { BehaviorSubject, Subject } from "rxjs";
+import { BehaviorSubject, Subject, Subscription } 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 { GanttSheet } from "./sheet/sheet";
 import { GanttChartTheme } from "./themes/theme";
 import { Task, TaskEventArgs } from "./model/task";
 import { ResourceList } from "./model/resource-list";
@@ -10,8 +10,8 @@ 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 { GanttCsvExportOptions, GanttExcelExportOptions } from "./export/data-exporter";
+import type { GanttPdfExportOptions } 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";
@@ -19,154 +19,248 @@ 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 {
+import { BaseTimelineEngine, BaseEngineContext } from "../common/base-engine";
+/** Central engine for the Gantt chart component managing tasks, resources, rendering, and user interaction. */
+export declare class GanttChartEngine extends BaseTimelineEngine {
     #private;
+    protected get ctx(): BaseEngineContext;
+    protected get engineEvents(): GanttChartEvents;
+    protected getChartWidth(): number;
+    protected getChartElement(): HTMLElement;
+    protected getTheme(): GanttChartTheme;
+    protected subscribeThemeChange(cb: () => void): Subscription;
+    protected isCellEditing(): boolean;
+    protected saveColumnsImpl(): ColumnState[];
+    protected loadColumnsImpl(states: ColumnState[]): void;
+    protected hasData(): boolean;
+    protected destroyComponents(): void;
+    /** The task list containing all tasks and links. */
     get list(): TaskList;
+    /** The resource list containing all available resources. */
     get resources(): ResourceList;
-    get calendar$(): BehaviorSubject<WorkingCalendar>;
-    set calendar$(value: WorkingCalendar);
+    /** Event emitters for subscribing to chart events. */
     get events(): GanttChartEvents;
-    get sheet(): Sheet;
+    /** The sheet (table) component. */
+    get sheet(): GanttSheet;
+    /** Currently selected tasks in the sheet. */
     get selectedTasks(): Task[];
-    get canEdit(): boolean;
-    set canEdit(value: boolean);
-    get showGridLines(): boolean;
-    set showGridLines(value: boolean);
+    /** Show or hide the critical path highlighting. */
     get showCriticalPath(): boolean;
     set showCriticalPath(value: boolean);
+    /** Show or hide baseline bars on the chart. */
     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;
+    /** Active task filter function. Set to null to show all tasks. */
     get filter(): TaskFilterFn | null;
     set filter(value: TaskFilterFn | null);
+    /** Clear the active task filter (show all tasks). */
     clearFilter(): void;
+    /** Whether any task has baseline data set. */
     get hasBaseline(): boolean;
+    /** Capture current task dates as baseline and enable baseline display. */
     saveBaseline(): void;
+    /** Remove baseline data from all tasks and hide baseline display. */
     clearBaseline(): void;
-    constructor(hostElement: any);
-    destroy(): void;
-    get canUndo$(): BehaviorSubject<boolean>;
-    get canRedo$(): BehaviorSubject<boolean>;
-    undo(): void;
-    redo(): void;
-    zoomIn(): boolean;
-    zoomOut(): boolean;
+    /** @param hostElement DOM element that will host the Gantt chart. */
+    constructor(hostElement: HTMLElement);
+    /** Indent the selected tasks one level deeper in the hierarchy. */
     indent(): false | void;
+    /** Outdent the selected tasks one level up in the hierarchy. */
     outdent(): false | void;
+    /** Move the selected tasks one position up in the list. */
     moveUp(): false | void;
+    /** Move the selected tasks one position down in the list. */
     moveDown(): false | void;
+    /** Copy selected tasks to clipboard. */
     copy(): Promise<void>;
+    /** Cut selected tasks to clipboard (copy + remove). */
     cut(): Promise<void>;
+    /** Paste tasks from clipboard. Returns the pasted tasks, or null if nothing to paste. */
     paste(): Promise<TasksPastedEventArgs | null>;
-    goToProjectStart(): void;
-    scrollToDate(date: Date): void;
+    /** Scroll horizontally and vertically to make a task visible, expanding collapsed parents if needed. */
     scrollToTask(task: Task): void;
+    /** Fit the view to show all tasks, or a specific subset. */
     zoomToFit(tasks?: Task[]): void;
-    saveColumns(): ColumnState[];
-    loadColumns(states: ColumnState[]): void;
-    get projectTimeline(): DateRange;
-    set projectTimeline(value: DateRange);
+    /** Settings object -- access theme, locale, and currency configuration. */
     get settings(): GanttChartSettings;
+    /** Serialize the complete chart state to a JSON string. */
     save(): string;
-    load(text: string): void;
+    protected restoreState(text: string): void;
+    /** Export the chart as a PNG image. */
     exportToImage(): Promise<Blob>;
-    exportToCsv(options?: CsvExportOptions): string;
-    exportToPdf(options?: PdfExportOptions): Promise<Blob>;
-    exportToExcel(options?: ExcelExportOptions): Promise<Blob>;
+    /** Export as a CSV string. */
+    exportToCsv(options?: GanttCsvExportOptions): string;
+    /** Export as a PDF file (requires jspdf). */
+    exportToPdf(options?: GanttPdfExportOptions): Promise<Blob>;
+    /** Export as an Excel file (requires exceljs). */
+    exportToExcel(options?: GanttExcelExportOptions): Promise<Blob>;
 }
-export declare class GanttChartContext {
+/** Internal shared state for the Gantt chart engine, sheet, and chart components. */
+export declare class GanttChartContext implements BaseEngineContext {
     #private;
+    /** Table context managing rows, selection, and cell editing. */
     table: TableContext<Task>;
+    /** Chart settings (theme, locale, currency). */
     settings: GanttChartSettings;
+    /** Current locale observable. */
     locale$: BehaviorSubject<TimelineKitLocale>;
+    /** Working calendar observable. */
     calendar$: BehaviorSubject<WorkingCalendar>;
+    /** Task list containing all tasks and links. */
     list: TaskList;
+    /** Resource list containing all available resources. */
     resources: ResourceList;
+    /** Timeline zoom and visible range manager. */
     timeline: ChartTimeline;
+    /** Sheet vertical scroll offset observable. */
     get sheetScrollTop$(): BehaviorSubject<number>;
+    /** Emitted when a new row is added to the sheet. */
     get sheetRowAdded$(): Subject<TableRowEventArgs<Task>>;
+    /** Currently selected tasks observable. */
     get sheetSelectedTasks$(): BehaviorSubject<Task[]>;
+    /** Currently focused cell observable. */
     get sheetFocusedCell$(): BehaviorSubject<TableFocusedCell<Task> | null>;
+    /** Cell editing state observable. */
     get sheetCellEditing$(): BehaviorSubject<TableCellEditing<Task> | null>;
+    /** Emitted when a cell requests a dialog editor. */
     get sheetCellDialogEdit$(): Subject<DialogEditorArgs<Task>>;
+    /** Emitted when a cell requests an input editor. */
     get sheetCellInputEdit$(): Subject<InputEditorArgs<Task>>;
+    /** Emitted when a cell value is rejected as invalid. */
     get sheetCellInvalidValue$(): Subject<void>;
+    /** Emitted on right-click on a sheet row. */
     get sheetRowContextMenu$(): Subject<TableRowContextMenuEventArgs<Task>>;
+    /** Emitted on right-click on a column header. */
     get sheetColumnHeaderContextMenu$(): Subject<TableColumnHeaderEventArgs<Task>>;
+    /** Emitted when a column is resized. */
     get sheetColumnResized$(): Subject<TableColumnEventArgs<Task>>;
+    /** Emitted when a column is reordered. */
     get sheetColumnReordered$(): Subject<TableColumnEventArgs<Task>>;
+    /** Whether editing is enabled (observable). */
     get canEdit$(): BehaviorSubject<boolean>;
+    /** Whether editing is currently enabled. */
     get canEdit(): boolean;
+    /** Emitted when the mouse hovers over a sheet row. */
     sheetRowMouseOver$: BehaviorSubject<TaskEventArgs | null>;
+    /** Whether the chart is currently auto-scrolling during a drag operation. */
     autoScrolling: boolean;
-    chartMouseWheel$: Subject<any>;
+    /** Emitted on mouse wheel over the chart area. */
+    chartMouseWheel$: Subject<WheelEvent>;
+    /** Emitted after the chart content is redrawn. */
     chartRedrawn$: Subject<void>;
+    /** Emitted after the chart background is redrawn. */
     chartBackgroundRedrawn$: Subject<void>;
+    /** Emitted when the chart cursor style should change. */
     chartCursor$: Subject<Cursor>;
+    /** Task currently hovered in the chart, or null. */
     chartTaskHover$: BehaviorSubject<Task | null>;
+    /** Current theme observable. */
     theme$: BehaviorSubject<GanttChartTheme>;
+    /** Whether grid lines are visible. */
     showGridLines$: BehaviorSubject<boolean>;
+    /** Whether critical path highlighting is enabled. */
     showCriticalPath$: BehaviorSubject<boolean>;
+    /** Whether baseline bars are visible. */
     showBaseline$: BehaviorSubject<boolean>;
+    /** Whether the today indicator line is visible. */
     showTodayLine$: BehaviorSubject<boolean>;
+    /** Timeline markers (vertical indicator lines). */
     markers$: BehaviorSubject<Marker[]>;
+    /** Emitted when a task bar is double-clicked. */
     taskDblClick$: Subject<TaskEventArgs>;
+    /** Emitted on right-click on a task bar. */
     taskContextMenu$: Subject<TaskContextMenuArgs>;
+    /** Emitted on right-click on the chart area. */
     chartContextMenu$: Subject<ChartContextMenuArgs>;
+    /** Project start/end date bounds observable. */
     projectTimeline$: BehaviorSubject<DateRange>;
+    /** Emitted when the sheet/chart divider position changes. */
     dividerPositionChanged$: Subject<void>;
+    /** Whether the divider is currently being resized. */
     dividerResizing$: BehaviorSubject<boolean>;
     constructor();
+    /** Calculate the bottom Y coordinate of visible content in the chart canvas. */
+    getContentBottom(canvasHeight: number): number;
+    /** Calculate the Y pixel coordinate of a task row in the chart canvas. */
     getRowY(task: Task): number;
+    /** Current working calendar snapshot. */
     get calendar(): WorkingCalendar;
 }
+/** Event emitters for subscribing to Gantt chart lifecycle and interaction events. */
 export declare class GanttChartEvents {
+    #private;
+    /** Emitted when a task is added. */
     taskAdded$: Subject<TaskEventArgs>;
+    /** Emitted when a task property changes. */
     taskChanged$: Subject<TaskEventArgs>;
+    /** Emitted when a task is removed. */
     taskRemoved$: Subject<TaskEventArgs>;
+    /** Emitted when a task bar is double-clicked. */
     taskDblClick$: Subject<TaskEventArgs>;
+    /** Emitted on right-click on a task bar. */
     taskContextMenu$: Subject<TaskContextMenuArgs>;
+    /** Emitted on right-click on the chart area. */
     chartContextMenu$: Subject<ChartContextMenuArgs>;
+    /** Emitted on right-click on a sheet row. */
     sheetRowContextMenu$: Subject<TableRowContextMenuEventArgs<Task>>;
+    /** Emitted on right-click on a column header. */
     sheetColumnHeaderContextMenu$: Subject<TableColumnHeaderEventArgs<Task>>;
+    /** Emitted when a sheet column is resized. */
     sheetColumnResized$: Subject<TableColumnEventArgs<Task>>;
+    /** Emitted when a sheet column is reordered. */
     sheetColumnReordered$: Subject<TableColumnEventArgs<Task>>;
+    /** Emitted when a cell requests a dialog editor. */
     sheetCellDialogEdit$: Subject<DialogEditorArgs<Task>>;
+    /** Emitted when a cell requests an input editor. */
     sheetCellInputEdit$: Subject<InputEditorArgs<Task>>;
+    /** Emitted when cell editing starts or ends. */
     sheetCellEditing$: Subject<TableCellEditing<Task> | null>;
+    /** Emitted when a cell value is rejected as invalid. */
     sheetCellInvalidValue$: Subject<void>;
+    /** Emitted when the project timeline bounds change. */
     projectTimeline$: Subject<DateRange>;
+    /** Emitted when a task link is added. */
     linkAdded$: Subject<TaskLinkEventArgs>;
+    /** Emitted when a task link is removed. */
     linkRemoved$: Subject<TaskLinkEventArgs>;
+    /** Emitted when tasks are pasted from clipboard. */
     tasksPasted$: Subject<TasksPastedEventArgs>;
+    /** Emitted when an undo is performed. */
     undone$: Subject<void>;
+    /** Emitted when a redo is performed. */
     redone$: Subject<void>;
     constructor(gc: GanttChartContext);
+    destroy(): void;
 }
 export { DateRange } from "../common/common";
+/** Arguments passed when the chart area is right-clicked. */
 export interface ChartContextMenuArgs {
+    /** Date at the click position. */
     date: Date;
+    /** Whether the click was on the header or on the content area. */
     area: 'header' | 'content';
+    /** Task at the click position, or null if clicking empty space. */
     task: Task | null;
-    mouseEvent: any;
+    /** The native mouse event. */
+    mouseEvent: MouseEvent;
 }
+/** Gantt chart settings -- theme, locale, and currency configuration. */
 export declare class GanttChartSettings {
     #private;
     private ctx;
+    /** Currency symbol used in cost columns. */
     get currencySymbol(): string;
     set currencySymbol(value: string);
+    /** How the currency symbol is positioned relative to the amount. */
     get currencySymbolDisplayMode(): CurrencySymbolDisplayMode;
     set currencySymbolDisplayMode(value: CurrencySymbolDisplayMode);
+    /** Current locale. */
     get locale(): TimelineKitLocale;
     set locale(value: TimelineKitLocale);
+    /** Current theme. */
     get theme(): GanttChartTheme;
     set theme(value: GanttChartTheme);
+    /** Emitted when any setting changes. */
     changed$: Subject<void>;
     constructor(ctx: GanttChartContext);
 }

package/dist/ganttchart/locale.d.ts

@@ -1,66 +1,2 @@
-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;
+export { defaultLocale } from "../common/locale";
+export type { TimelineKitLocale, ConstraintType, TaskLinkType } from "../common/locale";

package/dist/ganttchart/model/dependency-evaluator.d.ts

@@ -0,0 +1,16 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { Task } from "./task";
+import { TaskLink } from "./task-link";
+import { WorkingCalendar } from "./working-calendar";
+/** Evaluates link dependencies and constraint propagation between tasks. */
+export declare class DependencyEvaluator {
+    #private;
+    /** Whether link dependencies are currently being evaluated (prevents re-entrant updates). */
+    get evaluatingDependencies(): boolean;
+    /** Emitted after dependency evaluation completes. */
+    evaluatingDependenciesFinished$: Subject<void>;
+    constructor(getLinks: () => TaskLink[], calendar: BehaviorSubject<WorkingCalendar>);
+    onTaskStartTimeChanged(task: Task): void;
+    onTaskEndTimeChanged(task: Task): void;
+    evaluateLinkDependency(link: TaskLink): void;
+}

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

@@ -1,16 +1,27 @@
 import { LengthUnit } from "./length";
 import { WorkingCalendar } from "./working-calendar";
+/** Time offset (positive or negative) applied to a dependency link. */
 export declare class Lag {
     #private;
+    /** Time unit of the lag. */
     get unit(): LengthUnit;
+    /** Numeric amount (positive = lag, negative = lead). */
     get value(): number;
     constructor(unit: LengthUnit, value: number);
+    /** Convert to hours using the given calendar. */
     toHours(calendar: WorkingCalendar): number;
+    /** Format as a display string (e.g. '+2d', '-1h'). */
     toString(): string;
+    /** Check equality (same unit and value). */
     equals(other: Lag): boolean;
+    /** Create a zero lag (0 days). */
     static zero(): Lag;
+    /** Parse a lag string (e.g. '+2d', '-1h'). Returns null if invalid. */
     static tryParse(value: string): Lag | null;
+    /** Parse a lag string, throwing on invalid input. */
     static parse(value: string): Lag;
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Create a Lag from a plain object. */
     static fromAny(obj: any): Lag;
 }

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

@@ -1,16 +1,27 @@
-import { WorkingCalendar } from "./working-calendar";
+import { WorkingCalendar, LengthUnit } from "../../common/working-calendar";
+/** Represents a task duration with a time unit. */
 export declare class Length {
     #private;
+    /** Time unit of the duration. */
     get unit(): LengthUnit;
+    /** Numeric amount of the duration. */
     get value(): number;
     constructor(unit: LengthUnit, value: number);
+    /** Calculate the end time by adding this duration to a start time, respecting working hours. */
     getEndTime(startTime: Date, calendar: WorkingCalendar): Date;
+    /** Calculate the duration between two dates in the specified unit, respecting working hours. */
     static getLength(startTime: Date, endTime: Date, unit: LengthUnit, calendar: WorkingCalendar): Length;
+    /** Check equality (same unit and value). */
     equals(length: Length): boolean;
+    /** Format as a display string (e.g. '5d', '2w', '1M'). */
     toString(): string;
+    /** Parse a length string (e.g. '5d', '2w', '1M'). Returns null if invalid. */
     static tryParse(value: string): Length | null;
+    /** Parse a length string, throwing on invalid input. */
     static parse(value: string): Length;
+    /** Create a Length from a plain object. */
     static fromAny(obj: any): Length;
+    /** Serialize to a plain object. */
     toAny(): any;
 }
-export type LengthUnit = 'Minute' | 'Hour' | 'Day' | 'Week' | 'Month';
+export type { LengthUnit } from "../../common/working-calendar";

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

@@ -1,7 +1 @@
-export interface Marker {
-    date: Date;
-    label?: string;
-    color?: string;
-    lineWidth?: number;
-    lineStyle?: 'solid' | 'dashed' | 'dotted';
-}
+export type { Marker } from "../../common/marker";

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

@@ -1,9 +1,15 @@
+/** Cost rate associated with a resource. */
 export declare class Rate {
     #private;
+    /** Monetary value of the rate. */
     get value(): number;
+    /** Whether the rate is per-day or per-hour. */
     get type(): RateType;
     constructor(value: number, type: RateType);
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Create a Rate from a plain object. */
     static fromAny(obj: any): Rate;
 }
-export type RateType = 'PerDay' | 'PerHour';
+/** Time basis for a resource cost rate. */
+export type RateType = 'perDay' | 'perHour';

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

@@ -1,16 +1,27 @@
 import { Subject } from "rxjs";
 import { Resource, ResourceEventArgs } from "./resource";
+/** Collection of project resources with change tracking. */
 export declare class ResourceList {
     #private;
+    /** Emitted when a resource property changes. */
     resourceChanged$: Subject<ResourceEventArgs>;
+    /** Emitted after a resource is removed. */
     resourceRemoved$: Subject<ResourceEventArgs>;
+    /** Emitted before a resource is removed (allows validation). */
     resourceRemoving$: Subject<ResourceEventArgs>;
     constructor();
+    /** Number of resources. */
     get length(): number;
+    /** Get the index of a resource. */
     indexOf(resource: Resource): number;
+    /** Get a resource by index. */
     getResource(index: number): Resource;
+    /** Find a resource by ID, or null if not found. */
     getResourceById(id: string): Resource | null;
+    /** Add a resource to the list. */
     addResource(resource: Resource): Resource;
+    /** Replace all resources with a new set. */
     assign(resources: Resource[]): void;
+    /** Remove a resource from the list. */
     removeResource(resource: Resource): void;
 }

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

@@ -1,29 +1,43 @@
 import { Subject } from "rxjs";
 import { ResourceList } from "./resource-list";
 import { Rate } from "./rate";
+/** A named resource (person, equipment, etc.) that can be assigned to tasks. */
 export declare class Resource {
     #private;
+    /** Unique identifier (read-only). */
     get id(): string;
+    /** Display name. */
     get name(): string;
     set name(value: string);
+    /** Whether the resource is Unique or Generic. */
     get type(): ResourceType;
     set type(value: ResourceType);
+    /** Fixed cost charged each time this resource is used on a task. */
     get fixedCostPerUse(): number;
     set fixedCostPerUse(value: number);
+    /** Fixed cost per resource assignment. */
     get fixedCostPerResource(): number;
     set fixedCostPerResource(value: number);
+    /** URL to an avatar image. */
     get avatarIconUrl(): string | null;
     set avatarIconUrl(value: string | null);
+    /** The owning resource list (assigned once). */
     get list(): ResourceList | null;
     set list(value: ResourceList | null);
+    /** Hourly or daily cost rate. */
     get rate(): Rate | null;
     set rate(value: Rate | null);
+    /** Emitted when any property changes. */
     changed$: Subject<ResourceEventArgs>;
     constructor(id: string | null, name: string, type: ResourceType);
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Deserialize from a plain object. */
     static fromAny(obj: any): Resource;
 }
-export type ResourceType = 'Unique' | 'Generic';
+/** Whether a resource is Unique or Generic. */
+export type ResourceType = 'unique' | 'generic';
+/** Event args emitted when a resource changes. */
 export interface ResourceEventArgs {
     resource: Resource;
 }

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

@@ -1,14 +1,24 @@
 import { Task } from "./task";
 import { Resource } from "./resource";
 import { TaskFilterFn } from "./task-list";
+/** Built-in filter functions for common task queries. */
 export declare const TaskFilters: {
+    /** Tasks on the critical path. */
     criticalPath: (task: Task) => boolean;
+    /** Tasks with progress below 100%. */
     incomplete: (task: Task) => boolean;
+    /** Tasks with 100% progress. */
     complete: (task: Task) => boolean;
+    /** Tasks past their end date with incomplete progress. */
     behindSchedule: (task: Task) => boolean;
+    /** Milestone tasks only. */
     milestones: (task: Task) => boolean;
+    /** Tasks assigned to a specific resource. */
     byResource: (resource: Resource) => TaskFilterFn;
+    /** Tasks overlapping a date range. */
     byDateRange: (start: Date, end: Date) => TaskFilterFn;
+    /** Tasks whose name contains the search string (case-insensitive). */
     byName: (search: string) => TaskFilterFn;
+    /** Combines multiple filters with AND logic. */
     combine: (...filters: TaskFilterFn[]) => TaskFilterFn;
 };

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

@@ -1,22 +1,35 @@
+import type { TaskLinkType } from "../../common/locale";
 import { Lag } from "./lag";
 import { Task } from "./task";
 import { TaskList } from "./task-list";
+/** A dependency link between two tasks. */
 export declare class TaskLink {
     #private;
+    /** Unique identifier (read-only). */
     get id(): string;
+    /** Predecessor task. */
     get from(): Task;
+    /** Successor task. */
     get to(): Task;
+    /** Dependency type (e.g. FinishToStart). */
     get type(): TaskLinkType;
+    /** Time offset applied to the dependency. */
     get lag(): Lag;
+    /** The owning task list (assigned once). */
     get list(): TaskList | null;
     set list(value: TaskList | null);
     constructor(id: string | null, from: Task, to: Task, type: TaskLinkType, lag?: Lag);
+    /** Serialize to a plain object. */
     toAny(): any;
+    /** Create a TaskLink from a plain object, resolving task references from the given array. */
     static fromAny(obj: any, tasks: Task[]): TaskLink;
 }
-export type TaskLinkType = 'FinishToStart' | 'StartToStart' | 'FinishToFinish' | 'StartToFinish';
-export type ConnectorSide = 'Start' | 'Finish';
+export type { TaskLinkType } from "../../common/locale";
+/** Which end of a task a link connects to. */
+export type ConnectorSide = 'start' | 'finish';
+/** Determine the link type from which sides of the tasks are connected. */
 export declare function getLinkType(fromSide: ConnectorSide, toSide: ConnectorSide): TaskLinkType;
+/** Event args emitted when a link is added or removed. */
 export interface TaskLinkEventArgs {
     link: TaskLink;
 }