@timelinekit/core 1.0.0 → 1.0.3

package/dist/calendar/eventcalendar-engine.d.ts

@@ -0,0 +1,80 @@
+import { CalendarData } from "./model/calendar-data";
+import { CalendarEntry } from "./model/calendar-entry";
+import { type ViewMode, type EntryRenderFn, type EntryTooltipFn } from "./eventcalendar-context";
+import { EventCalendarEvents } from "./eventcalendar-events";
+import { EventCalendarSettings } from "./eventcalendar-settings";
+import { type CalendarImageExportOptions } from "./export/calendar-image-exporter";
+import { type CalendarPdfExportOptions } from "./export/calendar-pdf-exporter";
+import { type CalendarIcsExportOptions } from "./export/calendar-icalendar-exporter";
+import { type CalendarIcsImportOptions, type CalendarIcsImportResult } from "./import/calendar-icalendar-importer";
+import { type CalendarCsvExportOptions, type CalendarExcelExportOptions } from "./export/calendar-data-exporter";
+/** Main public API for the EventCalendar component. */
+export declare class EventCalendarEngine {
+    #private;
+    constructor(hostElement: HTMLElement);
+    get data(): CalendarData;
+    get events(): EventCalendarEvents;
+    get settings(): EventCalendarSettings;
+    get viewMode(): ViewMode;
+    set viewMode(value: ViewMode);
+    get currentDate(): Date;
+    set currentDate(value: Date);
+    get selectedEntries(): CalendarEntry[];
+    set selectedEntries(value: CalendarEntry[]);
+    get selectedEntry(): CalendarEntry | null;
+    set selectedEntry(value: CalendarEntry | null);
+    get canEdit(): boolean;
+    set canEdit(v: boolean);
+    get sidebarVisible(): boolean;
+    set sidebarVisible(v: boolean);
+    /** Custom entry rendering function. Set to override default entry rendering, or null for default. */
+    get entryRendering(): EntryRenderFn | null;
+    set entryRendering(value: EntryRenderFn | null);
+    /** Custom tooltip content function. Set to override default tooltip, or null for default. */
+    get entryTooltip(): EntryTooltipFn | null;
+    set entryTooltip(value: EntryTooltipFn | null);
+    /** Copy selected entries to the clipboard. */
+    copyEntries(entries?: CalendarEntry[]): Promise<void>;
+    /** Cut selected entries to the clipboard. */
+    cutEntries(entries?: CalendarEntry[]): Promise<void>;
+    /** Paste entries from the clipboard at the current date. */
+    pasteEntries(): Promise<void>;
+    /** Export the current view as an image (PNG or JPEG). Requires html2canvas. */
+    exportToImage(options?: CalendarImageExportOptions): Promise<Blob>;
+    /** Export the current view as a PDF document. Requires jspdf and html2canvas. */
+    exportToPdf(options?: CalendarPdfExportOptions): Promise<Blob>;
+    /** Export calendar items to iCalendar (.ics) format. Returns a Blob with MIME type text/calendar. */
+    exportToIcs(options?: CalendarIcsExportOptions): Blob;
+    /** Export calendar items to iCalendar (.ics) format. Returns the raw text string. */
+    exportToIcsText(options?: CalendarIcsExportOptions): string;
+    /** Import calendar items from iCalendar (.ics) text. */
+    importFromIcs(text: string, options?: CalendarIcsImportOptions): CalendarIcsImportResult;
+    /** Export all calendar items as a CSV string. */
+    exportToCsv(options?: CalendarCsvExportOptions): string;
+    /** Export all calendar items as an Excel workbook. Requires the `exceljs` package. */
+    exportToExcel(options?: CalendarExcelExportOptions): Promise<Blob>;
+    /** Check which optional export dependencies are available. */
+    static checkExportDependencies(): Promise<{
+        html2canvas: boolean;
+        jspdf: boolean;
+        exceljs: boolean;
+    }>;
+    today(): void;
+    next(): void;
+    previous(): void;
+    goToDate(date: Date): void;
+    undo(): void;
+    redo(): void;
+    get canUndo$(): import("rxjs").BehaviorSubject<boolean>;
+    get canRedo$(): import("rxjs").BehaviorSubject<boolean>;
+    save(): string;
+    load(text: string): void;
+    destroy(): void;
+}
+/** Serialized state shape for save/load. */
+export interface EventCalendarSerialized {
+    calendars: any[];
+    items: any[];
+    currentDate?: string;
+    viewMode?: ViewMode;
+}

package/dist/calendar/eventcalendar-events.d.ts

@@ -0,0 +1,40 @@
+import { Subject } from "rxjs";
+import type { CalendarEventArgs } from "./model/calendar";
+import type { CalendarItemEventArgs } from "./model/calendar-item";
+import type { CalendarEntry } from "./model/calendar-entry";
+import type { EventCalendarContext, ViewMode, EntryEventArgs, EntryContextMenuArgs, DateClickArgs, DateContextMenuArgs, MoreClickArgs, EntryMovingArgs, EntryResizingArgs, EntryCreatingArgs, EntryDeletingArgs, CalendarRemovingArgs } from "./eventcalendar-context";
+/** Public event emitters for EventCalendar. Consumers subscribe to these. */
+export declare class EventCalendarEvents {
+    #private;
+    calendarAdded$: Subject<CalendarEventArgs>;
+    calendarChanged$: Subject<CalendarEventArgs>;
+    calendarRemoved$: Subject<CalendarEventArgs>;
+    calendarAddRequested$: Subject<void>;
+    calendarRemoving$: Subject<CalendarRemovingArgs>;
+    itemAdded$: Subject<CalendarItemEventArgs>;
+    itemChanged$: Subject<CalendarItemEventArgs>;
+    itemRemoved$: Subject<CalendarItemEventArgs>;
+    entryClick$: Subject<EntryEventArgs>;
+    entryDblClick$: Subject<EntryEventArgs>;
+    entryContextMenu$: Subject<EntryContextMenuArgs>;
+    dateClick$: Subject<DateClickArgs>;
+    dateContextMenu$: Subject<DateContextMenuArgs>;
+    moreClick$: Subject<MoreClickArgs>;
+    entryMoving$: Subject<EntryMovingArgs>;
+    entryResizing$: Subject<EntryResizingArgs>;
+    entryCreating$: Subject<EntryCreatingArgs>;
+    entryDeleting$: Subject<EntryDeletingArgs>;
+    viewModeChanged$: Subject<ViewMode>;
+    currentDateChanged$: Subject<Date>;
+    viewDateRangeChanged$: Subject<{
+        start: Date;
+        end: Date;
+    }>;
+    selectedEntriesChanged$: Subject<CalendarEntry[]>;
+    /** Last selected entry, or null. For backwards compatibility. */
+    selectedEntryChanged$: Subject<CalendarEntry | null>;
+    undone$: Subject<void>;
+    redone$: Subject<void>;
+    constructor(ec: EventCalendarContext);
+    destroy(): void;
+}

package/dist/calendar/eventcalendar-settings.d.ts

@@ -0,0 +1,30 @@
+import { Subject } from "rxjs";
+import type { TimelineKitLocale } from "../common/locale";
+import type { EventCalendarContext } from "./eventcalendar-context";
+import type { EventCalendarTheme } from "./themes/eventcalendar-theme";
+/** Configuration container for EventCalendar. Changes are emitted via `changed$`. */
+export declare class EventCalendarSettings {
+    #private;
+    changed$: Subject<void>;
+    constructor(ctx: EventCalendarContext);
+    get locale(): TimelineKitLocale;
+    set locale(value: TimelineKitLocale);
+    get theme(): EventCalendarTheme;
+    set theme(value: EventCalendarTheme);
+    get firstDayOfWeek(): number;
+    set firstDayOfWeek(value: number);
+    get showWeekNumbers(): boolean;
+    set showWeekNumbers(value: boolean);
+    get slotDuration(): number;
+    set slotDuration(value: number);
+    get workingHours(): {
+        start: number;
+        end: number;
+    };
+    set workingHours(value: {
+        start: number;
+        end: number;
+    });
+    get agendaDays(): number;
+    set agendaDays(value: number);
+}

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

@@ -0,0 +1,32 @@
+import { EventCalendarContext } from "../eventcalendar-context";
+/** Options for CSV export of calendar data. */
+export interface CalendarCsvExportOptions {
+    /** Column delimiter. Default: ',' */
+    delimiter?: ',' | ';' | '\t';
+    /** Include column headers? Default: true */
+    includeHeaders?: boolean;
+    /** Include a separate calendars section? Default: false */
+    includeCalendars?: boolean;
+    /** Export only items from these calendar IDs. Default: all */
+    calendarIds?: string[];
+}
+/** Options for Excel (.xlsx) export of calendar data. */
+export interface CalendarExcelExportOptions {
+    /** Name of the events sheet. Default: locale-dependent ('Events') */
+    eventsSheetName?: string;
+    /** Include a sheet with calendars? Default: true */
+    includeCalendarsSheet?: boolean;
+    /** Apply cell formatting (bold headers, column widths, frozen header row)? Default: true */
+    includeFormatting?: boolean;
+    /** Export only items from these calendar IDs. Default: all */
+    calendarIds?: string[];
+}
+/** Exports calendar data to CSV and Excel formats. */
+export declare class CalendarDataExporter {
+    #private;
+    constructor(ctx: EventCalendarContext);
+    /** Export all calendar items (and optionally calendars) as a CSV string. */
+    exportToCsv(options?: CalendarCsvExportOptions): string;
+    /** Export all calendar items and calendars as an Excel workbook. Requires the `exceljs` package. */
+    exportToExcel(options?: CalendarExcelExportOptions): Promise<Blob>;
+}

package/dist/calendar/export/calendar-icalendar-exporter.d.ts

@@ -0,0 +1,24 @@
+import type { CalendarData } from "../model/calendar-data";
+export interface CalendarIcsExportOptions {
+    /** Which calendars to export. If omitted, all calendars are exported. */
+    calendarIds?: string[];
+    /** Product identifier for PRODID. Default: '-//TimelineKit//EventCalendar//EN'. */
+    prodId?: string;
+    /** Whether to include X-TIMELINEKIT-TYPE custom property. Default: true. */
+    includeCustomType?: boolean;
+}
+/** Exports calendar items to iCalendar (.ics) format (RFC 5545). */
+export declare class CalendarIcsExporter {
+    #private;
+    constructor(data: CalendarData);
+    exportToIcs(options?: CalendarIcsExportOptions): Blob;
+    exportToIcsText(options?: CalendarIcsExportOptions): string;
+}
+/** Format Date as iCalendar UTC datetime: 20261231T235959Z */
+export declare function formatIcsDateTime(d: Date): string;
+/** Format Date as iCalendar date-only: 20261231 */
+export declare function formatIcsDate(d: Date): string;
+/** Escape text for iCalendar property values. */
+export declare function escapeIcsText(text: string): string;
+/** Fold long lines per RFC 5545 (max 75 octets). */
+export declare function foldLines(lines: string[]): string[];

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

@@ -0,0 +1,17 @@
+import type { EventCalendarContext } from "../eventcalendar-context";
+export interface CalendarImageExportOptions {
+    /** Image format. Default: 'png'. */
+    format?: 'png' | 'jpeg';
+    /** JPEG quality (0-1). Default: 0.92. Only used when format is 'jpeg'. */
+    quality?: number;
+    /** Pixel scale factor for higher resolution output. Default: 2. */
+    scale?: number;
+    /** Whether to include the sidebar. Default: false. */
+    includeSidebar?: boolean;
+}
+/** Exports the current calendar view as a raster image. */
+export declare class CalendarImageExporter {
+    #private;
+    constructor(ec: EventCalendarContext, hostElement: HTMLElement);
+    exportToImage(options?: CalendarImageExportOptions): Promise<Blob>;
+}

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

@@ -0,0 +1,30 @@
+import type { EventCalendarContext } from "../eventcalendar-context";
+export interface CalendarPdfExportOptions {
+    /** Page format. Default: 'A4'. */
+    pageSize?: 'A4' | 'A3' | 'Letter' | 'Legal';
+    /** Page orientation. Default: 'landscape'. */
+    orientation?: 'portrait' | 'landscape';
+    /** Page margins in mm. Default: 10mm on all sides. */
+    margin?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Header text on each page. */
+    header?: string | ((pageNumber: number, totalPages: number) => string);
+    /** Footer text on each page. */
+    footer?: string | ((pageNumber: number, totalPages: number) => string);
+    /** Image quality (0-1). Default: 0.92. */
+    quality?: number;
+    /** Pixel scale factor for the captured image. Default: 2. */
+    scale?: number;
+    /** Whether to include the sidebar. Default: false. */
+    includeSidebar?: boolean;
+}
+/** Exports the current calendar view as a PDF document. */
+export declare class CalendarPdfExporter {
+    #private;
+    constructor(ec: EventCalendarContext, hostElement: HTMLElement);
+    exportToPdf(options?: CalendarPdfExportOptions): Promise<Blob>;
+}

package/dist/calendar/import/calendar-icalendar-importer.d.ts

@@ -0,0 +1,30 @@
+import { Calendar } from "../model/calendar";
+import { CalendarItem, CalendarItemType } from "../model/calendar-item";
+export interface CalendarIcsImportOptions {
+    /** Calendar ID to assign to imported items. If omitted, uses X-TIMELINEKIT-CALENDAR or null. */
+    calendarId?: string;
+    /** Whether to create a Calendar object from VCALENDAR metadata. Default: true. */
+    createCalendar?: boolean;
+    /** Default item type when X-TIMELINEKIT-TYPE is not present. Default: 'appointment'. */
+    defaultType?: CalendarItemType;
+}
+export interface CalendarIcsImportResult {
+    /** Created calendar (if createCalendar was true and metadata was present). */
+    calendar: Calendar | null;
+    /** Imported items (master events only, with exceptions attached). */
+    items: CalendarItem[];
+    /** Non-fatal warnings encountered during parsing. */
+    warnings: string[];
+    /** Count of components that were skipped (unsupported types, parse errors). */
+    skippedCount: number;
+}
+/** Imports iCalendar (.ics) text into CalendarItem instances. */
+export declare class CalendarIcsImporter {
+    importFromIcs(text: string, options?: CalendarIcsImportOptions): CalendarIcsImportResult;
+}
+/** Parse iCalendar date or datetime value. */
+export declare function parseIcsDateTimeValue(value: string, tzid?: string | null): Date | null;
+/** Unfold RFC 5545 continuation lines. */
+export declare function unfoldLines(text: string): string;
+/** Unescape iCalendar text property values. */
+export declare function unescapeIcsText(text: string): string;

package/dist/calendar/model/calendar-data.d.ts

@@ -0,0 +1,34 @@
+import { Subject } from "rxjs";
+import { Calendar, CalendarEventArgs } from "./calendar";
+import { CalendarItem, CalendarItemEventArgs } from "./calendar-item";
+import { CalendarEntry } from "./calendar-entry";
+import { TimeRange } from "./recurrence-expander";
+import { ColorValue } from "../../common/base-theme";
+export declare class CalendarData {
+    #private;
+    calendarAdded$: Subject<CalendarEventArgs>;
+    calendarChanged$: Subject<CalendarEventArgs>;
+    calendarRemoved$: Subject<CalendarEventArgs>;
+    calendarVisibilityChanged$: Subject<CalendarEventArgs>;
+    itemAdded$: Subject<CalendarItemEventArgs>;
+    itemChanged$: Subject<CalendarItemEventArgs>;
+    itemRemoved$: Subject<CalendarItemEventArgs>;
+    get calendarsLength(): number;
+    getCalendar(index: number): Calendar;
+    getCalendarById(id: string): Calendar | null;
+    addCalendar(calendar: Calendar): void;
+    removeCalendar(calendar: Calendar): void;
+    get defaultCalendar(): Calendar | null;
+    assignCalendars(calendars: Calendar[]): void;
+    get itemsLength(): number;
+    getItem(index: number): CalendarItem;
+    getItemById(id: string): CalendarItem | null;
+    getItemsForCalendar(calendarId: string): CalendarItem[];
+    addItem(item: CalendarItem): void;
+    removeItem(item: CalendarItem): void;
+    assignItems(items: CalendarItem[]): void;
+    clear(): void;
+    getEntries(range: TimeRange): CalendarEntry[];
+    getItemColor(item: CalendarItem): ColorValue;
+    getEntryColor(entry: CalendarEntry): ColorValue;
+}

package/dist/calendar/model/calendar-entry.d.ts

@@ -0,0 +1,44 @@
+import { CalendarItem, CalendarItemType, ResponseStatus } from "./calendar-item";
+import { RecurrenceException } from "./recurrence-exception";
+import { ColorValue } from "../../common/base-theme";
+/**
+ * A rendered calendar entry — the universal unit for the view layer.
+ *
+ * Every CalendarItem (recurring or not) is wrapped into one or more CalendarEntry
+ * instances by the RecurrenceExpander. The rendering layer always works exclusively
+ * with CalendarEntry, never with CalendarItem directly.
+ *
+ * For recurring items: multiple entries per item (one per visible occurrence).
+ * For non-recurring items: exactly one entry per item.
+ *
+ * Properties are resolved as: exception overrides > item values.
+ */
+export declare class CalendarEntry {
+    readonly item: CalendarItem;
+    readonly originalStartTime: Date;
+    readonly exception: RecurrenceException | null;
+    constructor(item: CalendarItem, originalStartTime: Date, exception: RecurrenceException | null);
+    get id(): string;
+    get type(): CalendarItemType;
+    get calendarId(): string | null;
+    get startTime(): Date;
+    get endTime(): Date;
+    get title(): string | null;
+    get description(): string | null;
+    get location(): string | null;
+    get color(): ColorValue;
+    get isAllDay(): boolean;
+    get timeZone(): string | null;
+    get tags(): string[] | null;
+    get visibility(): import("./calendar-item").CalendarItemVisibility;
+    get hasReminders(): boolean;
+    get externalSource(): string | null;
+    get data(): any;
+    get isRecurring(): boolean;
+    get isException(): boolean;
+    get isCancelled(): boolean;
+    get responseStatus(): ResponseStatus;
+    get isCompleted(): boolean;
+    get completedAt(): Date | null;
+    getPropertyValue(name: string): any;
+}

package/dist/calendar/model/calendar-item.d.ts

@@ -0,0 +1,151 @@
+import { Subject } from "rxjs";
+import { CustomProperty } from "../../common/custom-property";
+import { RecurrenceRule } from "./recurrence-rule";
+import { RecurrenceException } from "./recurrence-exception";
+import { ColorValue } from "../../common/base-theme";
+export declare abstract class CalendarItem {
+    #private;
+    abstract readonly type: CalendarItemType;
+    get id(): string;
+    get calendarId(): string | null;
+    set calendarId(value: string | null);
+    get startTime(): Date | null;
+    set startTime(value: Date | null);
+    get endTime(): Date | null;
+    set endTime(value: Date | null);
+    get timeZone(): string | null;
+    set timeZone(value: string | null);
+    get isAllDay(): boolean;
+    set isAllDay(value: boolean);
+    get title(): string | null;
+    set title(value: string | null);
+    get description(): string | null;
+    set description(value: string | null);
+    get location(): string | null;
+    set location(value: string | null);
+    /** Color index into the theme's taskColors array, or a custom color definition. */
+    get color(): ColorValue;
+    set color(value: ColorValue);
+    get visibility(): CalendarItemVisibility;
+    set visibility(value: CalendarItemVisibility);
+    get recurrenceRule(): RecurrenceRule | null;
+    set recurrenceRule(value: RecurrenceRule | null);
+    get recurrenceExceptions(): readonly RecurrenceException[];
+    get isRecurring(): boolean;
+    get hasReminders(): boolean;
+    set hasReminders(value: boolean);
+    get externalSource(): ExternalSource | string | null;
+    set externalSource(value: ExternalSource | string | null);
+    get tags(): string[] | null;
+    set tags(value: string[] | null);
+    setException(exception: RecurrenceException): void;
+    removeException(originalStartTime: Date): void;
+    cancelOccurrence(originalStartTime: Date): void;
+    getException(originalStartTime: Date): RecurrenceException | null;
+    clearExceptions(): void;
+    data: any;
+    abstract clone(newId: string | null): CalendarItem;
+    changed$: Subject<CalendarItemEventArgs>;
+    startTimeChanged$: Subject<CalendarItemEventArgs>;
+    endTimeChanged$: Subject<CalendarItemEventArgs>;
+    constructor(id: string | null);
+    addProperty(property: CustomProperty): void;
+    removeProperty(property: CustomProperty): void;
+    getPropertyByName(name: string): CustomProperty | null;
+    getPropertyValue(name: string): any;
+    setPropertyValue(name: string, value: any): void;
+    protected applyFromAny(data: any): void;
+    toAny(): any;
+    protected emitChanged(): void;
+}
+export type CalendarItemType = 'meeting' | 'appointment' | 'task' | 'deadline' | 'availabilityBlock' | 'holiday' | 'birthday' | 'reminder' | 'resourceBooking';
+export type CalendarItemVisibility = 'public' | 'private' | 'confidential';
+export type ExternalSource = 'native' | 'google' | 'outlook' | 'apple' | 'caldav' | 'ical' | 'office365' | 'exchange';
+export interface CalendarItemEventArgs {
+    item: CalendarItem;
+}
+export type ResponseStatus = 'accepted' | 'tentative' | 'declined' | 'needsAction';
+export type AvailabilityStatus = 'busy' | 'free' | 'tentative' | 'outOfOffice' | 'workingElsewhere' | 'focus';
+export declare class Meeting extends CalendarItem {
+    #private;
+    readonly type: "meeting";
+    get responseStatus(): ResponseStatus;
+    set responseStatus(value: ResponseStatus);
+    get attendeeCount(): number;
+    set attendeeCount(value: number);
+    get hasConference(): boolean;
+    set hasConference(value: boolean);
+    get organizer(): string | null;
+    set organizer(value: string | null);
+    protected applyFromAny(data: any): void;
+    toAny(): any;
+    clone(newId: string | null): Meeting;
+    static fromAny(data: any): Meeting;
+}
+export declare class Appointment extends CalendarItem {
+    readonly type: "appointment";
+    clone(newId: string | null): Appointment;
+    static fromAny(data: any): Appointment;
+}
+export declare class Task extends CalendarItem {
+    #private;
+    readonly type: "task";
+    get isCompleted(): boolean;
+    set isCompleted(value: boolean);
+    get completedAt(): Date | null;
+    set completedAt(value: Date | null);
+    get priority(): number;
+    set priority(value: number);
+    protected applyFromAny(data: any): void;
+    toAny(): any;
+    clone(newId: string | null): Task;
+    static fromAny(data: any): Task;
+}
+export declare class Deadline extends CalendarItem {
+    readonly type: "deadline";
+    clone(newId: string | null): Deadline;
+    static fromAny(data: any): Deadline;
+}
+export declare class Holiday extends CalendarItem {
+    readonly type: "holiday";
+    clone(newId: string | null): Holiday;
+    static fromAny(data: any): Holiday;
+}
+export declare class AvailabilityBlock extends CalendarItem {
+    #private;
+    readonly type: "availabilityBlock";
+    get availabilityStatus(): AvailabilityStatus;
+    set availabilityStatus(value: AvailabilityStatus);
+    protected applyFromAny(data: any): void;
+    toAny(): any;
+    clone(newId: string | null): AvailabilityBlock;
+    static fromAny(data: any): AvailabilityBlock;
+}
+export declare class Birthday extends CalendarItem {
+    #private;
+    readonly type: "birthday";
+    get contactName(): string | null;
+    set contactName(value: string | null);
+    protected applyFromAny(data: any): void;
+    toAny(): any;
+    clone(newId: string | null): Birthday;
+    static fromAny(data: any): Birthday;
+}
+export declare class Reminder extends CalendarItem {
+    readonly type: "reminder";
+    clone(newId: string | null): Reminder;
+    static fromAny(data: any): Reminder;
+}
+export declare class ResourceBooking extends CalendarItem {
+    #private;
+    readonly type: "resourceBooking";
+    get resourceId(): string | null;
+    set resourceId(value: string | null);
+    get resourceName(): string | null;
+    set resourceName(value: string | null);
+    protected applyFromAny(data: any): void;
+    toAny(): any;
+    clone(newId: string | null): ResourceBooking;
+    static fromAny(data: any): ResourceBooking;
+}
+export declare function calendarItemFromAny(data: any): CalendarItem;

package/dist/calendar/model/calendar.d.ts

@@ -0,0 +1,29 @@
+import { Subject } from "rxjs";
+import { ColorValue } from "../../common/base-theme";
+export declare class Calendar {
+    #private;
+    get id(): string;
+    get name(): string;
+    set name(value: string);
+    /** Color index into the theme's taskColors array, or a custom color definition. */
+    get color(): ColorValue;
+    set color(value: ColorValue);
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get isDefault(): boolean;
+    set isDefault(value: boolean);
+    get isReadOnly(): boolean;
+    set isReadOnly(value: boolean);
+    get timeZone(): string | null;
+    set timeZone(value: string | null);
+    get description(): string | null;
+    set description(value: string | null);
+    changed$: Subject<CalendarEventArgs>;
+    visibilityChanged$: Subject<CalendarEventArgs>;
+    constructor(id: string | null);
+    toAny(): any;
+    static fromAny(data: any): Calendar;
+}
+export interface CalendarEventArgs {
+    calendar: Calendar;
+}

package/dist/calendar/model/recurrence-editor.d.ts

@@ -0,0 +1,25 @@
+import { CalendarItem } from "./calendar-item";
+import { CalendarEntry } from "./calendar-entry";
+import { CalendarItemOverrides } from "./recurrence-exception";
+export type RecurrenceEditScope = 'this' | 'thisAndFollowing' | 'all';
+export interface RecurrenceEditResult {
+    /** Newly created master (from series split), or null */
+    newMaster: CalendarItem | null;
+    /** true if the original master should be removed from the collection */
+    removeMaster: boolean;
+}
+/**
+ * Utility for applying edits and deletes to recurring events
+ * according to the chosen scope (this / this_and_following / all).
+ */
+export declare class RecurrenceEditor {
+    #private;
+    /**
+     * Apply property changes to a recurring event.
+     */
+    static applyEdit(item: CalendarItem, entry: CalendarEntry, changes: CalendarItemOverrides, scope: RecurrenceEditScope): RecurrenceEditResult;
+    /**
+     * Delete an occurrence or an entire series.
+     */
+    static applyDelete(item: CalendarItem, entry: CalendarEntry, scope: RecurrenceEditScope): RecurrenceEditResult;
+}

package/dist/calendar/model/recurrence-exception.d.ts

@@ -0,0 +1,34 @@
+import type { ResponseStatus } from "./calendar-item";
+import type { ColorValue } from "../../common/base-theme";
+/**
+ * Subset of CalendarItem properties that can be overridden per-occurrence.
+ * Only set keys override the master; unset keys inherit from master.
+ */
+export interface CalendarItemOverrides {
+    startTime?: Date;
+    endTime?: Date;
+    title?: string | null;
+    description?: string | null;
+    location?: string | null;
+    color?: ColorValue;
+    isAllDay?: boolean;
+    timeZone?: string | null;
+    tags?: string[] | null;
+    responseStatus?: ResponseStatus;
+    isCompleted?: boolean;
+    completedAt?: Date | null;
+}
+/**
+ * An exception to a recurring event for a specific occurrence.
+ * Stored on the master CalendarItem.
+ */
+export interface RecurrenceException {
+    /** Original start time of the occurrence per the recurrence rule (slot identifier) */
+    originalStartTime: Date;
+    /** true = this occurrence is cancelled (EXDATE) */
+    isCancelled: boolean;
+    /** Overridden properties (only set keys override the master) */
+    overrides: CalendarItemOverrides | null;
+}
+export declare function recurrenceExceptionToAny(e: RecurrenceException): any;
+export declare function recurrenceExceptionFromAny(data: any): RecurrenceException;

package/dist/calendar/model/recurrence-expander.d.ts

@@ -0,0 +1,17 @@
+import { CalendarItem } from "./calendar-item";
+import { CalendarEntry } from "./calendar-entry";
+export interface TimeRange {
+    start: Date;
+    end: Date;
+}
+/**
+ * Expands CalendarItem instances into CalendarEntry objects for a given visible
+ * time range. Every item (recurring or not) is wrapped into CalendarEntry.
+ *
+ * Recurring items produce multiple entries (one per visible occurrence).
+ * Non-recurring items produce exactly one entry.
+ */
+export declare class RecurrenceExpander {
+    #private;
+    expand(items: CalendarItem[], range: TimeRange): CalendarEntry[];
+}