@timelinekit/core 1.0.0 → 1.0.3

package/dist/resourcescheduler/export/scheduler-export-common.d.ts

@@ -1,15 +1,20 @@
-import { BaseExportDimensions } from "../../common/export-utils";
+import { SheetExportDimensions } from "../../common/export-utils";
+import { BaseExportRenderer } from "../../common/base-export-renderer";
 import { ResourceSchedulerContext } from "../resourcescheduler-engine";
-import { GanttChartTheme } from "../../ganttchart/themes/theme";
-export interface SchedulerExportDimensions extends BaseExportDimensions {
+import { SchedulerSheet } from "../sheet/scheduler-sheet";
+import { BaseTheme } from "../../common/base-theme";
+/** Computed dimensions used for scheduler export rendering and pagination. */
+export interface SchedulerExportDimensions extends SheetExportDimensions {
     /** Heights of individual resource rows in display order (for pagination) */
     rowHeights: number[];
 }
-export declare class SchedulerExportRenderer {
+/** Renders the scheduler sheet and chart regions onto a canvas for export. */
+export declare class SchedulerExportRenderer extends BaseExportRenderer<SchedulerExportDimensions> {
     #private;
-    constructor(ctx: ResourceSchedulerContext);
-    get theme(): GanttChartTheme;
+    constructor(ctx: ResourceSchedulerContext, sheet: SchedulerSheet);
+    get theme(): BaseTheme;
+    preload(): Promise<void>;
     calculateDimensions(): SchedulerExportDimensions;
-    renderSheet(ctx: any, dims: SchedulerExportDimensions): void;
+    protected renderSheetRows(ctx: any, dims: SchedulerExportDimensions): void;
     renderChart(ctx: any, sheetWidth: number, dims: SchedulerExportDimensions, scale?: number): void;
 }

package/dist/resourcescheduler/export/scheduler-image-exporter.d.ts

@@ -1,6 +1,7 @@
 import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+import { SchedulerSheet } from "../sheet/scheduler-sheet";
 import { SchedulerExportDimensions } from "./scheduler-export-common";
 import { BaseImageExporter } from "../../common/base-image-exporter";
 export declare class SchedulerImageExporter extends BaseImageExporter<SchedulerExportDimensions> {
-    constructor(ctx: ResourceSchedulerContext);
+    constructor(ctx: ResourceSchedulerContext, sheet: SchedulerSheet);
 }

package/dist/resourcescheduler/export/scheduler-pdf-exporter.d.ts

@@ -1,10 +1,12 @@
 import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+import { SchedulerSheet } from "../sheet/scheduler-sheet";
 import { SchedulerExportDimensions } from "./scheduler-export-common";
 import { BasePdfExporter } from "../../common/base-pdf-exporter";
 export type { BasePdfExportOptions as SchedulerPdfExportOptions } from "../../common/export-utils";
+/** Exports the scheduler view to a multi-page PDF document. Requires the `jspdf` package. */
 export declare class SchedulerPdfExporter extends BasePdfExporter<SchedulerExportDimensions> {
     #private;
-    constructor(ctx: ResourceSchedulerContext);
+    constructor(ctx: ResourceSchedulerContext, sheet: SchedulerSheet);
     protected computeVerticalPageBreaks(dims: SchedulerExportDimensions, contentHeightPx: number, headerHeight: number): {
         srcY: number;
         height: number;

package/dist/resourcescheduler/model/scheduler-data-adapter.d.ts

@@ -8,6 +8,7 @@ export declare class SchedulerDataAdapter implements TableDataSource<SchedulerRe
     itemRemoved$: Subject<TableItemEventArgs<SchedulerResource>>;
     complexOperationFinished$: Subject<void>;
     constructor(data: SchedulerData);
+    destroy(): void;
     get length(): number;
     getItem(index: number): SchedulerResource;
     getItemById(id: string): SchedulerResource | null;

package/dist/resourcescheduler/model/scheduler-data.d.ts

@@ -1,52 +1,95 @@
 import { Subject } from "rxjs";
 import { SchedulerResource, SchedulerResourceEventArgs } from "./scheduler-resource";
 import { SchedulerEvent, SchedulerEventEventArgs } from "./scheduler-event";
+import { ColorValue } from "../../common/base-theme";
+/** Central data store holding all resources and events for the scheduler. */
 export declare class SchedulerData {
     #private;
+    /** Emitted when a resource is added. */
     resourceAdded$: Subject<SchedulerResourceEventArgs>;
+    /** Emitted when a resource property changes. */
     resourceChanged$: Subject<SchedulerResourceEventArgs>;
+    /** Emitted when a resource is removed. */
     resourceRemoved$: Subject<SchedulerResourceEventArgs>;
+    /** Emitted when an event is added. */
     eventAdded$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when an event property changes. */
     eventChanged$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when an event is removed. */
     eventRemoved$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when frozen resource set changes. */
     frozenChanged$: Subject<void>;
+    /** Emitted when the resource filter changes. */
     filterChanged$: Subject<void>;
+    /** Emitted after a bulk operation completes (e.g. assign, move, remove multiple). */
     complexOperationFinished$: Subject<void>;
+    /** Total number of resources. */
     get resourcesLength(): number;
+    /** Get a resource by index. */
     getResource(index: number): SchedulerResource;
+    /** Find a resource by ID, or null if not found. */
     getResourceById(id: string): SchedulerResource | null;
+    /** Get the index of a resource in the internal array. */
     indexOfResource(resource: SchedulerResource): number;
+    /** Active resource filter function. Set to null to show all resources. */
     get filter(): SchedulerResourceFilterFn | null;
     set filter(value: SchedulerResourceFilterFn | null);
+    /** Add a resource. Throws if a resource with the same ID already exists. */
     addResource(resource: SchedulerResource): void;
+    /** Insert a resource at a specific index. */
     insertResource(index: number, resource: SchedulerResource): void;
+    /** Remove a resource and all its events. */
     removeResource(resource: SchedulerResource): void;
+    /** Move a resource to a new index position. */
     moveResource(resource: SchedulerResource, toIndex: number): void;
+    /** Remove multiple resources and their events. */
     removeResources(resources: SchedulerResource[]): void;
+    /** Sort resources using a comparison function. */
+    sortResources(compareFn: (a: SchedulerResource, b: SchedulerResource) => number): void;
+    /** Replace all resources with a new set. Clears frozen state. */
     assignResources(resources: SchedulerResource[]): void;
+    /** Pin a resource to the top of the view. */
     freezeResource(resource: SchedulerResource): void;
+    /** Unpin a resource from the top of the view. */
     unfreezeResource(resource: SchedulerResource): void;
+    /** Check whether a resource is pinned to the top. */
     isResourceFrozen(resource: SchedulerResource): boolean;
+    /** Set of IDs of all frozen (pinned) resources. */
     get frozenResourceIds(): ReadonlySet<string>;
+    /** Number of currently frozen resources. */
     get frozenResourcesCount(): number;
     /** Returns visible resources in display order: frozen first (preserving original order), then non-frozen. Filtered resources are excluded. */
     get orderedResources(): SchedulerResource[];
     /** Returns the display index of a resource (in ordered view). */
     orderedIndexOf(resource: SchedulerResource): number;
+    /** Total number of events. */
     get eventsLength(): number;
+    /** Get an event by index. */
     getEvent(index: number): SchedulerEvent;
+    /** Find an event by ID, or null if not found. */
     getEventById(id: string): SchedulerEvent | null;
+    /** Get all events assigned to a resource. */
     getEventsForResource(resourceId: string): SchedulerEvent[];
+    /** Add an event. The event's resource must already exist. */
     addEvent(event: SchedulerEvent): void;
+    /** Remove an event. */
     removeEvent(event: SchedulerEvent): void;
+    /** Replace all events with a new set. */
     assignEvents(events: SchedulerEvent[]): void;
-    /** Resolves the effective color index for an event: event.color → resource.color → resource ordered index. */
-    getEventColorIndex(event: SchedulerEvent): number;
+    /** Resolves the effective color for an event: event.color → resource.color → resource ordered index. */
+    getEventColor(event: SchedulerEvent): ColorValue;
+    /** Get the number of parallel lanes needed for a resource's events. */
     getLaneCount(resourceId: string): number;
+    /** Get the 0-based lane index an event is placed in. */
     getEventLane(event: SchedulerEvent): number;
+    /** Get all events that overlap with a given time range on a resource. */
     getOverlappingEvents(resourceId: string, startTime: Date, endTime: Date, excludeEventId?: string): SchedulerEvent[];
+    /** Check whether an event overlaps with any other event on the same resource. */
     hasConflict(event: SchedulerEvent): boolean;
+    /** Earliest start time across all events, or null if no events exist. */
     get minStartTime(): Date | null;
+    /** Latest end time across all events, or null if no events exist. */
     get maxEndTime(): Date | null;
 }
+/** Filter function that determines which resources are visible. Return true to show, false to hide. */
 export type SchedulerResourceFilterFn = (resource: SchedulerResource) => boolean;

package/dist/resourcescheduler/model/scheduler-event.d.ts

@@ -1,31 +1,51 @@
 import { Subject } from "rxjs";
 import { CustomProperty } from "../../common/custom-property";
+import { ColorValue } from "../../common/base-theme";
+/** A time block assigned to a resource. Each event has a start time, end time, and belongs to exactly one resource. */
 export declare class SchedulerEvent {
     #private;
+    /** Unique identifier (read-only). Auto-generated if not provided in constructor. */
     get id(): string;
+    /** ID of the resource this event belongs to. Changing this moves the event to a different resource. */
     get resourceId(): string;
     set resourceId(value: string);
+    /** Display name of the event. */
     get name(): string;
     set name(value: string);
+    /** Start date/time of the event. */
     get startTime(): Date;
     set startTime(value: Date);
+    /** End date/time of the event. */
     get endTime(): Date;
     set endTime(value: Date);
-    get color(): number | null;
-    set color(value: number | null);
+    /** Color override. When set, overrides the resource's color. Can be a theme index or custom color definition. */
+    get color(): ColorValue | null;
+    set color(value: ColorValue | null);
+    /** Arbitrary user data attached to the event. Not serialized. */
     data: any;
+    /** Emitted when any property of this event changes. */
     changed$: Subject<SchedulerEventEventArgs>;
     constructor(id: string | null, resourceId: string, name: string, startTime: Date, endTime: Date);
+    /** Duration of the event in milliseconds (read-only). */
     get durationMs(): number;
+    /** Duration of the event in hours (read-only). */
     get durationHours(): number;
+    /** Add a custom property to this event. */
     addProperty(property: CustomProperty): void;
+    /** Remove a custom property from this event. */
     removeProperty(property: CustomProperty): void;
+    /** Get a custom property by name, or null if not found. */
     getPropertyByName(name: string): CustomProperty | null;
+    /** Get the value of a custom property by name. */
     getPropertyValue(name: string): any;
+    /** Set the value of a custom property by name. */
     setPropertyValue(name: string, value: any): void;
+    /** Serialize this event to a plain object. */
     toAny(): any;
+    /** Create a SchedulerEvent from a plain object (e.g. parsed JSON). */
     static fromAny(obj: any): SchedulerEvent;
 }
+/** Event args emitted when an event changes. */
 export interface SchedulerEventEventArgs {
     event: SchedulerEvent;
 }

package/dist/resourcescheduler/model/scheduler-layout-calculator.d.ts

@@ -0,0 +1,18 @@
+import { SchedulerData } from "./scheduler-data";
+import { SchedulerResource } from "./scheduler-resource";
+import { SchedulerEvent } from "./scheduler-event";
+import { BaseTheme } from "../../common/base-theme";
+/** Calculates row heights, row positions, and event Y coordinates for the scheduler layout. */
+export declare class SchedulerLayoutCalculator {
+    #private;
+    constructor(data: SchedulerData, theme$: {
+        getValue(): BaseTheme;
+    }, scrollTop$: {
+        getValue(): number;
+    });
+    getRowHeight(resource: SchedulerResource): number;
+    getEventY(resource: SchedulerResource, event: SchedulerEvent): number;
+    getRowY(resource: SchedulerResource): number;
+    getTotalContentHeight(): number;
+    get frozenSectionBottom(): number;
+}

package/dist/resourcescheduler/model/scheduler-resource.d.ts

@@ -1,35 +1,54 @@
 import { Subject } from "rxjs";
 import { CustomProperty } from "../../common/custom-property";
+import { ColorValue } from "../../common/base-theme";
+/** Built-in resource type constants. */
 export declare const ResourceType: {
     readonly Person: "person";
     readonly Room: "room";
     readonly Equipment: "equipment";
     readonly Vehicle: "vehicle";
 };
+/** Union of built-in resource type string values. */
 export type ResourceTypeValue = typeof ResourceType[keyof typeof ResourceType];
+/** A schedulable resource (person, room, equipment, etc.) displayed as a row in the scheduler. */
 export declare class SchedulerResource {
     #private;
+    /** Unique identifier (read-only). Auto-generated if not provided in constructor. */
     get id(): string;
+    /** Display name of the resource. */
     get name(): string;
     set name(value: string);
-    get color(): number | null;
-    set color(value: number | null);
+    /** Color index into the theme's taskColors array, or a custom color definition. When set, all events for this resource inherit this color unless overridden by event.color. */
+    get color(): ColorValue | null;
+    set color(value: ColorValue | null);
+    /** URL to an avatar image displayed in the sheet row. */
     get avatarUrl(): string | null;
     set avatarUrl(value: string | null);
+    /** Resource type (e.g. 'person', 'room', 'equipment', 'vehicle', or a custom string). */
     get type(): string | null;
     set type(value: string | null);
+    /** Whether this resource is excluded by the active filter. */
     get filtered(): boolean;
     set filtered(value: boolean);
+    /** Emitted when any property of this resource changes. */
     changed$: Subject<SchedulerResourceEventArgs>;
     constructor(id: string | null, name: string);
+    /** Add a custom property to this resource. */
     addProperty(property: CustomProperty): void;
+    /** Remove a custom property from this resource. */
     removeProperty(property: CustomProperty): void;
+    /** Get a custom property by name, or null if not found. */
     getPropertyByName(name: string): CustomProperty | null;
+    /** Get the value of a custom property by name. */
     getPropertyValue(name: string): any;
+    /** Set the value of a custom property by name. */
     setPropertyValue(name: string, value: any): void;
+    /** Serialize this resource to a plain object. */
     toAny(): any;
+    /** Create a SchedulerResource from a plain object (e.g. parsed JSON). */
     static fromAny(obj: any): SchedulerResource;
 }
+/** Event args emitted when a resource changes. */
 export interface SchedulerResourceEventArgs {
     resource: SchedulerResource;
 }

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

@@ -1,11 +1,10 @@
-import { BehaviorSubject, Subject } from "rxjs";
-import { ChartTimeline } from "../ganttchart/chart/chart-time-axis";
-import { TimelineKitLocale } from "../ganttchart/locale";
-import { WorkingCalendar } from "../ganttchart/model/working-calendar";
-import { GanttChartTheme } from "../ganttchart/themes/theme";
-import { DateRange } from "../ganttchart/ganttchart-engine";
-import { Cursor, Rect } from "../common/common";
-import type { Marker } from "../ganttchart/model/marker";
+import { BehaviorSubject, Subject, Subscription } from "rxjs";
+import { ChartTimeline } from "../common/chart-time-axis";
+import { TimelineKitLocale } from "../common/locale";
+import { WorkingCalendar } from "../common/working-calendar";
+import { BaseTheme, ColorValue } from "../common/base-theme";
+import { Cursor, DateRange, Rect } from "../common/common";
+import type { Marker } from "../common/marker";
 import { SchedulerData, SchedulerResourceFilterFn } from "./model/scheduler-data";
 import { SchedulerDataAdapter } from "./model/scheduler-data-adapter";
 import { TableContext } from "../table/table-context";
@@ -13,37 +12,55 @@ import type { SchedulerCsvExportOptions, SchedulerExcelExportOptions } from "./e
 import type { SchedulerPdfExportOptions } from "./export/scheduler-pdf-exporter";
 import { SchedulerResource, SchedulerResourceEventArgs } from "./model/scheduler-resource";
 import { SchedulerEvent, SchedulerEventEventArgs } from "./model/scheduler-event";
+/** Arguments passed to the custom event rendering callback. */
 export interface SchedulerEventRenderArgs {
+    /** The event being rendered. */
     event: SchedulerEvent;
+    /** The resource the event belongs to. */
     resource: SchedulerResource;
+    /** Position and size of the event bar in canvas pixels. */
     rect: Rect;
+    /** The canvas 2D rendering context. */
     ctx: CanvasRenderingContext2D;
+    /** Whether the event is currently selected. */
     isSelected: boolean;
-    colorIndex: number;
+    /** Resolved color for the event (theme index or custom definition). */
+    color: ColorValue;
 }
+/** Custom event rendering function. Return true if you handled the rendering, false to fall back to default. */
 export type SchedulerEventRenderFn = (args: SchedulerEventRenderArgs) => boolean;
+/** Arguments passed to the custom tooltip callback. */
 export interface SchedulerEventTooltipArgs {
+    /** The event being hovered. */
     event: SchedulerEvent;
+    /** The resource the event belongs to. */
     resource: SchedulerResource;
 }
+/** Content to display in an event tooltip. */
 export interface SchedulerEventTooltipContent {
+    /** Tooltip title (typically the event name). */
     title: string;
+    /** Key-value lines displayed below the title. */
     lines: {
         name: string;
         value: string;
     }[];
 }
+/** Custom tooltip function. Return content to display, or null to hide the tooltip. */
 export type SchedulerEventTooltipFn = (args: SchedulerEventTooltipArgs) => SchedulerEventTooltipContent | null;
+import { SchedulerLayoutCalculator } from "./model/scheduler-layout-calculator";
 import { SchedulerSheet } from "./sheet/scheduler-sheet";
+import type { ColumnState } from "../table/table";
 import type { SchedulerEventsPastedEventArgs } from "./clipboard";
-export declare class ResourceSchedulerContext {
+import { BaseTimelineEngine, BaseEngineContext } from "../common/base-engine";
+export declare class ResourceSchedulerContext implements BaseEngineContext {
     data: SchedulerData;
     dataAdapter: SchedulerDataAdapter;
     table: TableContext<SchedulerResource>;
     timeline: ChartTimeline;
     locale$: BehaviorSubject<TimelineKitLocale>;
     calendar$: BehaviorSubject<WorkingCalendar>;
-    theme$: BehaviorSubject<GanttChartTheme>;
+    theme$: BehaviorSubject<BaseTheme>;
     projectTimeline$: BehaviorSubject<DateRange>;
     settings: ResourceSchedulerSettings;
     get scrollTop$(): BehaviorSubject<number>;
@@ -70,6 +87,7 @@ export declare class ResourceSchedulerContext {
     eventDeleting$: Subject<SchedulerEventDeletingArgs>;
     eventRendering$: BehaviorSubject<SchedulerEventRenderFn | null>;
     eventTooltip$: BehaviorSubject<SchedulerEventTooltipFn | null>;
+    layout: SchedulerLayoutCalculator;
     constructor();
     get calendar(): WorkingCalendar;
     getRowHeight(resource: SchedulerResource): number;
@@ -78,134 +96,208 @@ export declare class ResourceSchedulerContext {
     getTotalContentHeight(): number;
     get frozenSectionBottom(): number;
 }
-export declare class ResourceSchedulerEngine {
+/** The Resource Scheduler component engine. Manages resources, events, rendering, and user interaction. */
+export declare class ResourceSchedulerEngine extends BaseTimelineEngine {
     #private;
+    protected get ctx(): BaseEngineContext;
+    protected get engineEvents(): ResourceSchedulerEvents;
+    protected getChartWidth(): number;
+    protected getChartElement(): HTMLElement;
+    protected getTheme(): BaseTheme;
+    protected subscribeThemeChange(cb: () => void): Subscription;
+    protected isCellEditing(): boolean;
+    protected saveColumnsImpl(): ColumnState[];
+    protected loadColumnsImpl(states: ColumnState[]): void;
+    protected hasData(): boolean;
+    protected destroyComponents(): void;
+    protected addWrapperClasses(wrapperElement: HTMLElement): void;
+    /** All resources and events (read-only). */
     get data(): SchedulerData;
+    /** The sheet (table) component (read-only). */
     get sheet(): SchedulerSheet;
-    get calendar$(): BehaviorSubject<WorkingCalendar>;
-    set calendar$(value: WorkingCalendar);
+    /** Event emitters for subscribing to scheduler events (read-only). */
     get events(): ResourceSchedulerEvents;
+    /** Currently selected resources in the sheet (read-only). */
     get selectedResources(): SchedulerResource[];
+    /** Currently selected events. */
     get selectedEvents(): SchedulerEvent[];
     set selectedEvents(value: SchedulerEvent[]);
+    /** Last selected event, or null if no events are selected. */
     get selectedEvent(): SchedulerEvent | null;
     set selectedEvent(value: SchedulerEvent | null);
-    get canEdit(): boolean;
-    set canEdit(value: boolean);
-    get canUndo$(): BehaviorSubject<boolean>;
-    get canRedo$(): BehaviorSubject<boolean>;
-    undo(): void;
-    redo(): void;
-    get showGridLines(): boolean;
-    set showGridLines(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;
+    /** Custom event rendering function. Set to override default event bar rendering, or null for default. */
     get eventRendering(): SchedulerEventRenderFn | null;
     set eventRendering(value: SchedulerEventRenderFn | null);
+    /** Custom tooltip content function. Set to override default tooltip, or null for default. */
     get eventTooltip(): SchedulerEventTooltipFn | null;
     set eventTooltip(value: SchedulerEventTooltipFn | null);
+    /** Active resource filter function. Set to null to show all resources. */
     get filter(): SchedulerResourceFilterFn | null;
     set filter(value: SchedulerResourceFilterFn | null);
+    /** Clear the active resource filter (show all resources). */
     clearFilter(): void;
-    get projectTimeline(): DateRange;
-    set projectTimeline(value: DateRange);
+    /** Settings object — access theme and locale (read-only). */
     get settings(): ResourceSchedulerSettings;
-    constructor(hostElement: any);
-    destroy(): void;
+    constructor(hostElement: HTMLElement);
+    /** Copy selected events to clipboard. */
     copy(): Promise<void>;
+    /** Cut selected events to clipboard (copy + remove). */
     cut(): Promise<void>;
+    /** Paste events from clipboard. Returns the pasted events, or null if nothing to paste. */
     paste(): Promise<SchedulerEventsPastedEventArgs | null>;
-    zoomIn(): boolean;
-    zoomOut(): boolean;
-    scrollToDate(date: Date): void;
+    /** Scroll to make a resource row visible. */
     scrollToResource(resource: SchedulerResource): void;
-    goToProjectStart(): void;
+    /** Scroll to make an event visible (both horizontally and vertically). */
+    scrollToEvent(event: SchedulerEvent): void;
+    /** Fit the view to show all events, or a specific subset. */
     zoomToFit(events?: SchedulerEvent[]): void;
+    /** Export the scheduler as a PNG image. */
     exportToImage(): Promise<Blob>;
+    /** Export as a CSV string. */
     exportToCsv(options?: SchedulerCsvExportOptions): string;
+    /** Export as an Excel file (requires exceljs). */
     exportToExcel(options?: SchedulerExcelExportOptions): Promise<Blob>;
+    /** Export as a PDF file (requires jspdf). */
     exportToPdf(options?: SchedulerPdfExportOptions): Promise<Blob>;
+    /** Sort resources using a comparison function. */
+    sortResources(compareFn: (a: SchedulerResource, b: SchedulerResource) => number): void;
+    /** Pin a resource row to the top of the view. Frozen resources stay visible while scrolling. */
     freezeResource(resource: SchedulerResource): void;
+    /** Unpin a resource row from the top of the view. */
     unfreezeResource(resource: SchedulerResource): void;
+    /** Check whether a resource is pinned to the top. */
     isResourceFrozen(resource: SchedulerResource): boolean;
+    /** Serialize the complete scheduler state to a JSON string. */
     save(): string;
-    load(text: string): void;
+    protected restoreState(text: string): void;
 }
+/** Event emitters for subscribing to scheduler lifecycle and interaction events. */
 export declare class ResourceSchedulerEvents {
+    #private;
+    /** Emitted when a resource is added. */
     resourceAdded$: Subject<SchedulerResourceEventArgs>;
+    /** Emitted when a resource property changes. */
     resourceChanged$: Subject<SchedulerResourceEventArgs>;
+    /** Emitted when a resource is removed. */
     resourceRemoved$: Subject<SchedulerResourceEventArgs>;
+    /** Emitted when an event is added. */
     eventAdded$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when an event property changes. */
     eventChanged$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when an event is removed. */
     eventRemoved$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when event selection changes. Payload is the selected event, or null. */
     eventSelected$: Subject<SchedulerEventEventArgs | null>;
+    /** Emitted when an event bar is double-clicked. */
     eventDblClick$: Subject<SchedulerEventEventArgs>;
+    /** Emitted when an event is about to be deleted. Set cancel to true to prevent. */
     eventDeleting$: Subject<SchedulerEventDeletingArgs>;
+    /** Emitted when events are pasted from clipboard. */
     eventsPasted$: Subject<SchedulerEventsPastedEventArgs>;
+    /** Emitted on right-click on the chart area. */
     chartContextMenu$: Subject<SchedulerChartContextMenuArgs>;
+    /** Emitted when an event is being moved. Set cancel to true to prevent, or set adjusted times to snap. */
     eventMoving$: Subject<SchedulerEventMovingArgs>;
+    /** Emitted when an event is being resized. Set cancel to true to prevent, or set adjusted times to snap. */
     eventResizing$: Subject<SchedulerEventResizingArgs>;
+    /** Emitted when a new event is being created by dragging. Set cancel to true to prevent. */
     eventCreating$: Subject<SchedulerEventCreatingArgs>;
+    /** Emitted on right-click on a sheet row. */
     sheetRowContextMenu$: Subject<SchedulerRowContextMenuEventArgs>;
+    /** Emitted when cell editing starts (true) or ends (false). */
     sheetCellEditing$: Subject<boolean>;
+    /** Emitted when the project timeline bounds change. */
     projectTimeline$: Subject<DateRange>;
+    /** Emitted when an undo is performed. */
     undone$: Subject<void>;
+    /** Emitted when a redo is performed. */
     redone$: Subject<void>;
     constructor(ctx: ResourceSchedulerContext, sheet: SchedulerSheet);
     /** Called by engine to wire chart handler events */
     _bindChartHandlers(chart: import("./chart/scheduler-chart").SchedulerChart): void;
+    destroy(): void;
 }
+/** Right-click on a sheet row event args. */
 export interface SchedulerRowContextMenuEventArgs {
     selectedResources: SchedulerResource[];
-    mouseEvent: any;
+    mouseEvent: MouseEvent;
 }
+/** Right-click on the chart area event args. */
 export interface SchedulerChartContextMenuArgs {
+    /** Date at the click position. */
     date: Date;
+    /** Resource at the click position. */
     resource: SchedulerResource;
+    /** Event at the click position, or null if clicking empty space. */
     event: SchedulerEvent | null;
-    mouseEvent: any;
+    mouseEvent: MouseEvent;
 }
+/** Cancelable event args emitted when an event is being moved. */
 export interface SchedulerEventMovingArgs {
+    /** The event being moved. */
     event: SchedulerEvent;
+    /** Proposed new start time. */
     newStartTime: Date;
+    /** Proposed new end time. */
     newEndTime: Date;
+    /** Proposed target resource. */
     newResource: SchedulerResource;
+    /** Set to true to cancel the move. */
     cancel: boolean;
+    /** Set to override the start time (e.g. for snapping). */
     adjustedStartTime?: Date;
+    /** Set to override the end time (e.g. for snapping). */
     adjustedEndTime?: Date;
 }
+/** Cancelable event args emitted when an event is being resized. */
 export interface SchedulerEventResizingArgs {
+    /** The event being resized. */
     event: SchedulerEvent;
+    /** Which edge is being dragged. */
     edge: 'left' | 'right';
+    /** Proposed new start time. */
     newStartTime: Date;
+    /** Proposed new end time. */
     newEndTime: Date;
+    /** Set to true to cancel the resize. */
     cancel: boolean;
+    /** Set to override the start time (e.g. for snapping). */
     adjustedStartTime?: Date;
+    /** Set to override the end time (e.g. for snapping). */
     adjustedEndTime?: Date;
 }
+/** Cancelable event args emitted when an event is about to be deleted. */
 export interface SchedulerEventDeletingArgs {
+    /** The event being deleted. */
     event: SchedulerEvent;
+    /** Set to true to cancel the deletion. */
     cancel: boolean;
 }
+/** Cancelable event args emitted when a new event is being created by dragging. */
 export interface SchedulerEventCreatingArgs {
+    /** The target resource. */
     resource: SchedulerResource;
+    /** Proposed start time. */
     startTime: Date;
+    /** Proposed end time. */
     endTime: Date;
+    /** Set to true to cancel creation. */
     cancel: boolean;
+    /** Set to override the start time (e.g. for snapping). */
     adjustedStartTime?: Date;
+    /** Set to override the end time (e.g. for snapping). */
     adjustedEndTime?: Date;
 }
+/** Scheduler settings — theme and locale configuration. */
 export declare class ResourceSchedulerSettings {
     #private;
+    /** Current locale. */
     get locale(): TimelineKitLocale;
     set locale(value: TimelineKitLocale);
-    get theme(): GanttChartTheme;
-    set theme(value: GanttChartTheme);
+    /** Current theme. */
+    get theme(): BaseTheme;
+    set theme(value: BaseTheme);
+    /** Emitted when settings change. */
     changed$: Subject<void>;
     constructor(ctx: ResourceSchedulerContext);
 }

package/dist/resourcescheduler/sheet/renderers/scheduler-icon-cell-renderer.d.ts

@@ -4,3 +4,5 @@ import { SchedulerResource } from "../../model/scheduler-resource";
 export declare class SchedulerIconCellRenderer extends TableCellRenderer<SchedulerResource> {
     redraw(cell: any, valueFormatter: TableCellValueFormatter<SchedulerResource>, item: SchedulerResource): void;
 }
+export declare function preloadAvatars(resources: SchedulerResource[]): Promise<void>;
+export declare function drawSchedulerIconExportCell(ctx: CanvasRenderingContext2D, resource: SchedulerResource, x: number, y: number, width: number, height: number): void;