@timelinekit/core 1.0.0

package/dist/licensing/features.d.ts

@@ -0,0 +1,21 @@
+export declare enum LicenseTier {
+    Free = 0,
+    Pro = 1
+}
+export declare enum Feature {
+    CriticalPath = 0,
+    Baseline = 1,
+    Resources = 2,
+    WorkingCalendar = 3,
+    Markers = 4,
+    Filtering = 5,
+    UndoRedo = 6,
+    Clipboard = 7,
+    Constraints = 8,
+    CustomProperties = 9,
+    ResourceScheduler = 10,
+    Export = 11,
+    AdditionalThemes = 12,
+    AdditionalLocales = 13
+}
+export declare function isFeatureAvailable(feature: Feature, tier: LicenseTier): boolean;

package/dist/licensing/license-key.d.ts

@@ -0,0 +1,7 @@
+export interface LicensePayload {
+    t: number;
+    e: number;
+    v: string;
+    h: string;
+}
+export declare function decodeLicenseKey(key: string): LicensePayload | null;

package/dist/licensing/license-manager.d.ts

@@ -0,0 +1,13 @@
+import { LicenseTier, Feature } from "./features";
+declare class LicenseManager {
+    #private;
+    static get(): LicenseManager;
+    setLicenseKey(key: string): void;
+    isAvailable(feature: Feature): boolean;
+    get currentTier(): LicenseTier;
+    get isValid(): boolean;
+    get showWatermark(): boolean;
+}
+export declare function setLicense(key: string): void;
+export declare function getLicenseManager(): LicenseManager;
+export {};

package/dist/licensing/watermark.d.ts

@@ -0,0 +1 @@
+export declare function renderWatermark(ctx: any, width: number, height: number): void;

package/dist/locales/cs.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const csLocale: TimelineKitLocale;

package/dist/locales/de.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const deLocale: TimelineKitLocale;

package/dist/locales/en.d.ts

@@ -0,0 +1 @@
+export declare const enLocale: import("..").TimelineKitLocale;

package/dist/locales/es.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const esLocale: TimelineKitLocale;

package/dist/locales/fr.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const frLocale: TimelineKitLocale;

package/dist/locales/it.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const itLocale: TimelineKitLocale;

package/dist/locales/ja.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const jaLocale: TimelineKitLocale;

package/dist/locales/ko.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const koLocale: TimelineKitLocale;

package/dist/locales/nl.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const nlLocale: TimelineKitLocale;

package/dist/locales/pl.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const plLocale: TimelineKitLocale;

package/dist/locales/pt.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const ptLocale: TimelineKitLocale;

package/dist/locales/ru.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const ruLocale: TimelineKitLocale;

package/dist/locales/sv.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const svLocale: TimelineKitLocale;

package/dist/locales/zh.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineKitLocale } from "../ganttchart/locale";
+export declare const zhLocale: TimelineKitLocale;

package/dist/resourcescheduler/chart/handlers/add-event.d.ts

@@ -0,0 +1,12 @@
+import { Point } from "../../../common/common";
+import { ChartHandlerResult } from "../../../common/handler-result";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerChartHandler } from "./scheduler-handler";
+export declare class AddEventHandler extends SchedulerChartHandler {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    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/resourcescheduler/chart/handlers/move-event.d.ts

@@ -0,0 +1,12 @@
+import { Point } from "../../../common/common";
+import { ChartHandlerResult } from "../../../common/handler-result";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerChartHandler } from "./scheduler-handler";
+export declare class MoveEventHandler extends SchedulerChartHandler {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    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/resourcescheduler/chart/handlers/resize-event.d.ts

@@ -0,0 +1,12 @@
+import { Point } from "../../../common/common";
+import { ChartHandlerResult } from "../../../common/handler-result";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerChartHandler } from "./scheduler-handler";
+export declare class ResizeEventHandler extends SchedulerChartHandler {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    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/resourcescheduler/chart/handlers/scheduler-handler.d.ts

@@ -0,0 +1,23 @@
+import { Point } from "../../../common/common";
+import { BaseChartHandlerBase } from "../../../common/base-chart-handler";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerResource } from "../../model/scheduler-resource";
+import { SchedulerEvent } from "../../model/scheduler-event";
+import { SchedulerTooltipLine } from "../tooltip/scheduler-tooltip-renderer";
+export declare abstract class SchedulerChartHandler extends BaseChartHandlerBase {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    protected getResourceRowAt(p: Point): SchedulerResource | null;
+    protected getEventAt(p: Point): EventAt | null;
+    protected drawEventHighlight(event: SchedulerEvent, x1: number, x2: number): void;
+    protected drawTooltip(event: SchedulerEvent, startX: number, title: string, lines: SchedulerTooltipLine[]): void;
+    protected drawHighlightForResource(resource: SchedulerResource, x1: number, x2: number, colorIndex?: number): void;
+    protected drawTooltipForResource(resource: SchedulerResource, startX: number, title: string, lines: SchedulerTooltipLine[]): void;
+}
+export { ChartHandlerResult } from "../../../common/handler-result";
+export interface EventAt {
+    event: SchedulerEvent;
+    resource: SchedulerResource;
+    x1: number;
+    x2: number;
+}

package/dist/resourcescheduler/chart/handlers/scheduler-handlers.d.ts

@@ -0,0 +1,18 @@
+import { Subject } from "rxjs";
+import { Point } from "../../../common/common";
+import { ClassWithListeners } from "../../../common/class-with-listeners";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { ChartContextMenuArgs } from "./select-event";
+import { SchedulerEvent } from "../../model/scheduler-event";
+export declare class SchedulerChartHandlers extends ClassWithListeners {
+    #private;
+    operationComplete$: Subject<void>;
+    redraw$: Subject<void>;
+    eventDblClick$: Subject<SchedulerEvent>;
+    eventContextMenu$: Subject<ChartContextMenuArgs>;
+    constructor(ctx: ResourceSchedulerContext, chartElement: any);
+    getMousePosition(event: any): Point;
+    init(chartElement: any, canvas: any): void;
+    clear(): void;
+    private isWithinScrollbar;
+}

package/dist/resourcescheduler/chart/handlers/select-event.d.ts

@@ -0,0 +1,26 @@
+import { Subject } from "rxjs";
+import { Point } from "../../../common/common";
+import { ChartHandlerResult } from "../../../common/handler-result";
+import { SchedulerEvent } from "../../model/scheduler-event";
+import { SchedulerResource } from "../../model/scheduler-resource";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerChartHandler } from "./scheduler-handler";
+export declare class SelectEventHandler extends SchedulerChartHandler {
+    #private;
+    dblClick$: Subject<SchedulerEvent>;
+    contextMenu$: Subject<ChartContextMenuArgs>;
+    constructor(ctx: ResourceSchedulerContext);
+    onMouseDown(p: Point, ctrl: boolean, event: any): Promise<ChartHandlerResult>;
+    onMouseMove(p: Point, event: any): Promise<ChartHandlerResult>;
+    onMouseLeave(p: Point, event: any): Promise<ChartHandlerResult>;
+    onKeyDown(key: string, event: any): Promise<ChartHandlerResult>;
+    onRedrawn(): void;
+    onContextMenu(p: Point, event: any): ChartHandlerResult;
+    onDblClick(p: Point, event: any): ChartHandlerResult;
+}
+export interface ChartContextMenuArgs {
+    date: Date;
+    resource: SchedulerResource;
+    event: SchedulerEvent | null;
+    mouseEvent: any;
+}

package/dist/resourcescheduler/chart/renderers/scheduler-background-renderer.d.ts

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

package/dist/resourcescheduler/chart/renderers/scheduler-events-renderer.d.ts

@@ -0,0 +1,7 @@
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerRendererBase } from "./scheduler-renderer-base";
+export declare class SchedulerEventsRenderer extends SchedulerRendererBase {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    render(canvas: any): void;
+}

package/dist/resourcescheduler/chart/renderers/scheduler-header-renderer.d.ts

@@ -0,0 +1,7 @@
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerRendererBase } from "./scheduler-renderer-base";
+export declare class SchedulerHeaderRenderer extends SchedulerRendererBase {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    render(canvas: any): void;
+}

package/dist/resourcescheduler/chart/renderers/scheduler-markers-renderer.d.ts

@@ -0,0 +1,7 @@
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+import { SchedulerRendererBase } from "./scheduler-renderer-base";
+export declare class SchedulerMarkersRenderer extends SchedulerRendererBase {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    render(canvas: any): void;
+}

package/dist/resourcescheduler/chart/renderers/scheduler-renderer-base.d.ts

@@ -0,0 +1,9 @@
+import { SchedulerResource } from "../../model/scheduler-resource";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+export declare class SchedulerRendererBase {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    protected get ctx(): ResourceSchedulerContext;
+    protected getRowY(resource: SchedulerResource): number;
+    protected getContentBottom(canvasHeight: number): number;
+}

package/dist/resourcescheduler/chart/scheduler-chart-scroll-handler.d.ts

@@ -0,0 +1,5 @@
+import { BaseChartScrollHandler } from "../../common/base-chart-scroll-handler";
+import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+export declare class SchedulerChartScrollHandler extends BaseChartScrollHandler {
+    constructor(ctx: ResourceSchedulerContext, chartElement: any, canvas: any, inner: any);
+}

package/dist/resourcescheduler/chart/scheduler-chart.d.ts

@@ -0,0 +1,9 @@
+import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+import { SchedulerChartHandlers } from "./handlers/scheduler-handlers";
+export declare class SchedulerChart {
+    #private;
+    constructor(ctx: ResourceSchedulerContext, chartElement: any);
+    get chartWidth(): number;
+    get handlers(): SchedulerChartHandlers;
+    destroy(): void;
+}

package/dist/resourcescheduler/chart/tooltip/scheduler-tooltip-renderer.d.ts

@@ -0,0 +1,13 @@
+import { SchedulerEvent } from "../../model/scheduler-event";
+import { SchedulerResource } from "../../model/scheduler-resource";
+import { ResourceSchedulerContext } from "../../resourcescheduler-engine";
+export declare class SchedulerTooltipRenderer {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    drawTooltipForResource(canvas: any, resource: SchedulerResource, startX: number, title: string, lines: SchedulerTooltipLine[]): void;
+    drawTooltip(canvas: any, event: SchedulerEvent, startX: number, title: string, lines: SchedulerTooltipLine[]): void;
+}
+export interface SchedulerTooltipLine {
+    name: string;
+    value: string;
+}

package/dist/resourcescheduler/clipboard.d.ts

@@ -0,0 +1,18 @@
+import { BehaviorSubject } from "rxjs";
+import { SchedulerData } from "./model/scheduler-data";
+import { SchedulerEvent } from "./model/scheduler-event";
+export interface SchedulerClipboardContext {
+    data: SchedulerData;
+    selectedEvents$: BehaviorSubject<SchedulerEvent[]>;
+}
+export interface SchedulerEventsPastedEventArgs {
+    events: SchedulerEvent[];
+    eventIdMap: Map<string, SchedulerEvent>;
+}
+export declare class SchedulerClipboardManager {
+    #private;
+    constructor(ctx: SchedulerClipboardContext);
+    copy(events: SchedulerEvent[]): Promise<void>;
+    cut(events: SchedulerEvent[]): Promise<void>;
+    paste(): Promise<SchedulerEventsPastedEventArgs | null>;
+}

package/dist/resourcescheduler/divider/scheduler-divider.d.ts

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

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

@@ -0,0 +1,23 @@
+import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+export interface SchedulerCsvExportOptions {
+    /** Column delimiter. Default: ',' */
+    delimiter?: ',' | ';' | '\t';
+    /** Include column headers? Default: true */
+    includeHeaders?: boolean;
+    /** Include a separate resources section? Default: false */
+    includeResources?: boolean;
+}
+export interface SchedulerExcelExportOptions {
+    /** Name of the events sheet. Default: locale-dependent ('Events') */
+    eventsSheetName?: string;
+    /** Include a sheet with resources? Default: true */
+    includeResourcesSheet?: boolean;
+    /** Apply cell formatting (bold headers, column widths, frozen header row)? Default: true */
+    includeFormatting?: boolean;
+}
+export declare class SchedulerDataExporter {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    exportToCsv(options?: SchedulerCsvExportOptions): string;
+    exportToExcel(options?: SchedulerExcelExportOptions): Promise<Blob>;
+}

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

@@ -0,0 +1,15 @@
+import { BaseExportDimensions } from "../../common/export-utils";
+import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+import { GanttChartTheme } from "../../ganttchart/themes/theme";
+export interface SchedulerExportDimensions extends BaseExportDimensions {
+    /** Heights of individual resource rows in display order (for pagination) */
+    rowHeights: number[];
+}
+export declare class SchedulerExportRenderer {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    get theme(): GanttChartTheme;
+    calculateDimensions(): SchedulerExportDimensions;
+    renderSheet(ctx: any, dims: SchedulerExportDimensions): void;
+    renderChart(ctx: any, sheetWidth: number, dims: SchedulerExportDimensions, scale?: number): void;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { ResourceSchedulerContext } from "../resourcescheduler-engine";
+import { SchedulerExportDimensions } from "./scheduler-export-common";
+import { BasePdfExporter } from "../../common/base-pdf-exporter";
+export type { BasePdfExportOptions as SchedulerPdfExportOptions } from "../../common/export-utils";
+export declare class SchedulerPdfExporter extends BasePdfExporter<SchedulerExportDimensions> {
+    #private;
+    constructor(ctx: ResourceSchedulerContext);
+    protected computeVerticalPageBreaks(dims: SchedulerExportDimensions, contentHeightPx: number, headerHeight: number): {
+        srcY: number;
+        height: number;
+    }[];
+}

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

@@ -0,0 +1,21 @@
+import { Subject } from "rxjs";
+import { TableDataSource, TableItemEventArgs } from "../../table/table-data-source";
+import { SchedulerData } from "./scheduler-data";
+import { SchedulerResource } from "./scheduler-resource";
+export declare class SchedulerDataAdapter implements TableDataSource<SchedulerResource> {
+    #private;
+    itemChanged$: Subject<TableItemEventArgs<SchedulerResource>>;
+    itemRemoved$: Subject<TableItemEventArgs<SchedulerResource>>;
+    complexOperationFinished$: Subject<void>;
+    constructor(data: SchedulerData);
+    get length(): number;
+    getItem(index: number): SchedulerResource;
+    getItemById(id: string): SchedulerResource | null;
+    indexOf(item: SchedulerResource): number;
+    getItemLabel(item: SchedulerResource): string;
+    getNextVisible(item: SchedulerResource): SchedulerResource | null;
+    getPreviousVisible(item: SchedulerResource): SchedulerResource | null;
+    addEmptyItem(): SchedulerResource;
+    insertEmptyItem(index: number): SchedulerResource;
+    removeItems(items: SchedulerResource[]): void;
+}

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

@@ -0,0 +1,52 @@
+import { Subject } from "rxjs";
+import { SchedulerResource, SchedulerResourceEventArgs } from "./scheduler-resource";
+import { SchedulerEvent, SchedulerEventEventArgs } from "./scheduler-event";
+export declare class SchedulerData {
+    #private;
+    resourceAdded$: Subject<SchedulerResourceEventArgs>;
+    resourceChanged$: Subject<SchedulerResourceEventArgs>;
+    resourceRemoved$: Subject<SchedulerResourceEventArgs>;
+    eventAdded$: Subject<SchedulerEventEventArgs>;
+    eventChanged$: Subject<SchedulerEventEventArgs>;
+    eventRemoved$: Subject<SchedulerEventEventArgs>;
+    frozenChanged$: Subject<void>;
+    filterChanged$: Subject<void>;
+    complexOperationFinished$: Subject<void>;
+    get resourcesLength(): number;
+    getResource(index: number): SchedulerResource;
+    getResourceById(id: string): SchedulerResource | null;
+    indexOfResource(resource: SchedulerResource): number;
+    get filter(): SchedulerResourceFilterFn | null;
+    set filter(value: SchedulerResourceFilterFn | null);
+    addResource(resource: SchedulerResource): void;
+    insertResource(index: number, resource: SchedulerResource): void;
+    removeResource(resource: SchedulerResource): void;
+    moveResource(resource: SchedulerResource, toIndex: number): void;
+    removeResources(resources: SchedulerResource[]): void;
+    assignResources(resources: SchedulerResource[]): void;
+    freezeResource(resource: SchedulerResource): void;
+    unfreezeResource(resource: SchedulerResource): void;
+    isResourceFrozen(resource: SchedulerResource): boolean;
+    get frozenResourceIds(): ReadonlySet<string>;
+    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;
+    get eventsLength(): number;
+    getEvent(index: number): SchedulerEvent;
+    getEventById(id: string): SchedulerEvent | null;
+    getEventsForResource(resourceId: string): SchedulerEvent[];
+    addEvent(event: SchedulerEvent): void;
+    removeEvent(event: SchedulerEvent): void;
+    assignEvents(events: SchedulerEvent[]): void;
+    /** Resolves the effective color index for an event: event.color → resource.color → resource ordered index. */
+    getEventColorIndex(event: SchedulerEvent): number;
+    getLaneCount(resourceId: string): number;
+    getEventLane(event: SchedulerEvent): number;
+    getOverlappingEvents(resourceId: string, startTime: Date, endTime: Date, excludeEventId?: string): SchedulerEvent[];
+    hasConflict(event: SchedulerEvent): boolean;
+    get minStartTime(): Date | null;
+    get maxEndTime(): Date | null;
+}
+export type SchedulerResourceFilterFn = (resource: SchedulerResource) => boolean;

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

@@ -0,0 +1,31 @@
+import { Subject } from "rxjs";
+import { CustomProperty } from "../../common/custom-property";
+export declare class SchedulerEvent {
+    #private;
+    get id(): string;
+    get resourceId(): string;
+    set resourceId(value: string);
+    get name(): string;
+    set name(value: string);
+    get startTime(): Date;
+    set startTime(value: Date);
+    get endTime(): Date;
+    set endTime(value: Date);
+    get color(): number | null;
+    set color(value: number | null);
+    data: any;
+    changed$: Subject<SchedulerEventEventArgs>;
+    constructor(id: string | null, resourceId: string, name: string, startTime: Date, endTime: Date);
+    get durationMs(): number;
+    get durationHours(): number;
+    addProperty(property: CustomProperty): void;
+    removeProperty(property: CustomProperty): void;
+    getPropertyByName(name: string): CustomProperty | null;
+    getPropertyValue(name: string): any;
+    setPropertyValue(name: string, value: any): void;
+    toAny(): any;
+    static fromAny(obj: any): SchedulerEvent;
+}
+export interface SchedulerEventEventArgs {
+    event: SchedulerEvent;
+}

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

@@ -0,0 +1,35 @@
+import { Subject } from "rxjs";
+import { CustomProperty } from "../../common/custom-property";
+export declare const ResourceType: {
+    readonly Person: "person";
+    readonly Room: "room";
+    readonly Equipment: "equipment";
+    readonly Vehicle: "vehicle";
+};
+export type ResourceTypeValue = typeof ResourceType[keyof typeof ResourceType];
+export declare class SchedulerResource {
+    #private;
+    get id(): string;
+    get name(): string;
+    set name(value: string);
+    get color(): number | null;
+    set color(value: number | null);
+    get avatarUrl(): string | null;
+    set avatarUrl(value: string | null);
+    get type(): string | null;
+    set type(value: string | null);
+    get filtered(): boolean;
+    set filtered(value: boolean);
+    changed$: Subject<SchedulerResourceEventArgs>;
+    constructor(id: string | null, name: string);
+    addProperty(property: CustomProperty): void;
+    removeProperty(property: CustomProperty): void;
+    getPropertyByName(name: string): CustomProperty | null;
+    getPropertyValue(name: string): any;
+    setPropertyValue(name: string, value: any): void;
+    toAny(): any;
+    static fromAny(obj: any): SchedulerResource;
+}
+export interface SchedulerResourceEventArgs {
+    resource: SchedulerResource;
+}