@dayflow/core 2.0.7 → 3.0.1

package/dist/index.d.ts

@@ -1,39 +1,2555 @@
-import './styles/tailwind.css';
-export { CalendarApp } from './core/CalendarApp';
-export { useCalendarApp } from './core/useCalendarApp';
-export { DayFlowCalendar } from './core/DayFlowCalendar';
-export { CalendarRegistry } from './core/calendarRegistry';
-export { ThemeProvider, useTheme } from './contexts/ThemeContext';
-export type { ThemeContextType, ThemeProviderProps } from './contexts/ThemeContext';
-export { createDayView } from './factories/createDayView';
-export { createWeekView } from './factories/createWeekView';
-export { createMonthView } from './factories/createMonthView';
-export { createYearView } from './factories/createYearView';
-export { createEventsPlugin } from './plugins/eventsPlugin';
-export { createDragPlugin } from './plugins/dragPlugin';
-export { useDragForView } from './plugins/dragPlugin';
-export { useDrag } from './hooks/drag/useDrag';
-export { useVirtualScroll, useResponsiveConfig, } from './hooks/virtualScroll/useVirtualScroll';
-export { useVirtualMonthScroll, useResponsiveMonthConfig, } from './hooks/virtualScroll/useVirtualMonthScroll';
-export { default as CalendarEvent } from './components/calendarEvent';
-export { default as DefaultEventDetailPanel } from './components/common/DefaultEventDetailPanel';
-export { default as DefaultEventDetailDialog } from './components/common/DefaultEventDetailDialog';
-export { default as EventDetailPanelWithContent } from './components/common/EventDetailPanelWithContent';
-export { default as ViewHeader } from './components/common/ViewHeader';
-export type { ViewHeaderType, ViewSwitcherMode, } from './components/common/ViewHeader';
-export { default as CalendarPicker } from './components/common/CalendarPicker';
-export type { CalendarOption, CalendarPickerProps, } from './components/common/CalendarPicker';
-export { EventLayoutCalculator } from './components/eventLayout';
-export * from './utils';
-export * from './locale';
-export type { CalendarPlugin, CalendarView, CalendarConfig, CalendarSidebarRenderProps, SidebarConfig, UseCalendarAppReturn, CalendarApp as ICalendarApp, CalendarAppConfig, CalendarCallbacks, } from './types/core';
-export type { Event } from './types/event';
-export type { DragConfig } from './types/config';
-export type { CalendarType, ThemeMode, ThemeConfig, CalendarColors, CalendarsConfig, } from './types/calendarTypes';
-export type { DragIndicatorProps, DragIndicatorRenderer, } from './types/dragIndicator';
-export type { EventsService, EventsPluginConfig, DragService, DragPluginConfig, DragHookOptions, DragHookReturn, } from './types/plugin';
-export type { BaseViewProps, ViewFactory, ViewAdapterProps, } from './types/factory';
-export type { EventDetailPosition, EventDetailPanelProps, EventDetailPanelRenderer, EventDetailContentProps, EventDetailContentRenderer, EventDetailDialogProps, EventDetailDialogRenderer, } from './types/eventDetail';
-export type { CalendarSearchProps, CalendarSearchEvent, } from './types/search';
-export type { MobileEventProps, MobileEventRenderer, } from './types/mobileEvent';
-export { ViewType } from './types';
+import { Temporal } from 'temporal-polyfill';
+import * as preact from 'preact';
+import { ComponentChildren, RefObject } from 'preact';
+
+/**
+ * Calendar event interface (using Temporal API)
+ * Unified event data structure supporting single-day, cross-day, and all-day events
+ */
+interface Event {
+    id: string;
+    title: string;
+    description?: string;
+    start: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+    end: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+    allDay?: boolean;
+    icon?: boolean | ComponentChildren;
+    calendarId?: string;
+    meta?: Record<string, any>;
+    day?: number;
+}
+
+type ViewSwitcherMode = 'buttons' | 'select';
+
+/**
+ * Color configuration for a calendar type
+ */
+interface CalendarColors {
+    /** Event background color */
+    eventColor: string;
+    /** Selected event background color */
+    eventSelectedColor: string;
+    /** Border/line color */
+    lineColor: string;
+    /** Text color */
+    textColor: string;
+}
+/**
+ * Calendar Type Definition
+ * Represents a category of events (e.g., Work, Personal, Study)
+ */
+interface CalendarType {
+    /** Unique identifier (e.g., 'work', 'personal') */
+    id: string;
+    /** Display name (e.g., 'Work', 'Personal') */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Light mode colors */
+    colors: CalendarColors;
+    /** Dark mode colors (optional, falls back to light mode if not provided) */
+    darkColors?: CalendarColors;
+    /** Optional icon (emoji or icon name) */
+    icon?: string;
+    /** Whether this is a system default type */
+    isDefault?: boolean;
+    /** Whether events of this type should be visible */
+    isVisible?: boolean;
+}
+/**
+ * Theme mode
+ */
+type ThemeMode = 'light' | 'dark' | 'auto';
+/**
+ * System-level theme colors
+ */
+interface ThemeColors {
+    background?: string;
+    text?: string;
+    border?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Theme configuration
+ */
+interface ThemeConfig {
+    /** Current theme mode */
+    mode: ThemeMode;
+    /** System-level theme colors (optional) */
+    colors?: ThemeColors;
+}
+/**
+ * Calendar configuration for the app
+ */
+interface CalendarsConfig {
+    /** Array of calendar types */
+    calendars?: CalendarType[];
+    /** Default calendar for new events */
+    defaultCalendar?: string;
+    /** Theme configuration */
+    theme?: ThemeConfig;
+}
+
+/**
+ * Calendar Registry
+ * Manages calendar types and provides color resolution
+ */
+declare class CalendarRegistry {
+    private calendars;
+    private defaultCalendarId;
+    private currentTheme;
+    constructor(customCalendars?: CalendarType[], defaultCalendarId?: string, theme?: ThemeMode);
+    /**
+     * Register a new calendar type
+     */
+    register(calendar: CalendarType): void;
+    /**
+     * Unregister a calendar type
+     */
+    unregister(calendarId: string): boolean;
+    /**
+     * Get a calendar type by ID
+     */
+    get(calendarId: string): CalendarType | undefined;
+    /**
+     * Get all calendar types
+     */
+    getAll(): CalendarType[];
+    /**
+     * Get visible calendar types
+     */
+    getVisible(): CalendarType[];
+    /**
+     * Check if a calendar exists
+     */
+    has(calendarId: string): boolean;
+    /**
+     * Reorder calendars
+     * @param fromIndex - Source index
+     * @param toIndex - Destination index
+     */
+    reorder(fromIndex: number, toIndex: number): void;
+    /**
+     * Update visibility of a specific calendar type
+     */
+    setVisibility(calendarId: string, visible: boolean): void;
+    /**
+     * Update visibility for all calendar types
+     */
+    setAllVisibility(visible: boolean): void;
+    /**
+     * Update calendar properties
+     */
+    updateCalendar(calendarId: string, updates: Partial<CalendarType>): void;
+    /**
+     * Set the default calendar ID
+     */
+    setDefaultCalendar(calendarId: string): void;
+    /**
+     * Get the default calendar ID
+     */
+    getDefaultCalendarId(): string;
+    /**
+     * Get the default calendar type
+     */
+    getDefaultCalendar(): CalendarType;
+    /**
+     * Set the current theme
+     */
+    setTheme(theme: ThemeMode): void;
+    /**
+     * Get the current theme
+     */
+    getTheme(): ThemeMode;
+    /**
+     * Resolve colors for a calendar ID based on current theme
+     */
+    resolveColors(calendarId?: string, theme?: ThemeMode): CalendarColors;
+    /**
+     * Get selected background color
+     */
+    getSelectedBgColor(calendarId?: string, theme?: ThemeMode): string;
+    /**
+     * Get line color
+     */
+    getLineColor(calendarId?: string, theme?: ThemeMode): string;
+    /**
+     * Get text color
+     */
+    getTextColor(calendarId?: string, theme?: ThemeMode): string;
+    /**
+     * Check if the current theme is dark
+     */
+    private isDarkTheme;
+    /**
+     * Validate calendar configuration
+     */
+    validate(calendar: Partial<CalendarType>): string[];
+}
+
+type LocaleCode = string;
+type TranslationKey = 'allDay' | 'noEvents' | 'more' | 'eventTitle' | 'dateRange' | 'timeRange' | 'note' | 'addNotePlaceholder' | 'setAsAllDay' | 'setAsTimed' | 'delete' | 'confirm' | 'cancel' | 'today' | 'day' | 'week' | 'month' | 'year' | 'newEvent' | 'newAllDayEvent' | 'newCalendarEvent' | 'newAllDayCalendarEvent' | 'save' | 'deleteCalendar' | 'deleteCalendarMessage' | 'merge' | 'confirmDeleteTitle' | 'confirmDeleteMessage' | 'mergeConfirmTitle' | 'mergeConfirmMessage' | 'expandSidebar' | 'collapseSidebar' | 'calendars' | 'createCalendar' | 'calendarNamePlaceholder' | 'customColor' | 'create' | 'calendarOptions' | 'untitled' | 'search' | 'noResults' | 'calendar' | 'starts' | 'ends' | 'notes' | 'titlePlaceholder' | 'notesPlaceholder' | 'editEvent' | 'done' | 'quickCreateEvent' | 'quickCreatePlaceholder' | 'noSuggestions' | 'newCalendar' | 'refreshAll' | 'tomorrow' | 'importCalendar' | 'exportCalendar' | 'addSchedule' | 'importCalendarMessage' | 'ok' | 'cut' | 'copy' | 'pasteHere' | 'eventSummary';
+type LocaleDict = Partial<Record<TranslationKey, string>>;
+type LocaleMessages = Partial<Record<TranslationKey, string>>;
+interface Locale {
+    code: string;
+    messages: LocaleDict;
+}
+
+/**
+ * Mobile event drawer/dialog Props
+ */
+interface MobileEventProps {
+    /** Whether the drawer/dialog is open */
+    isOpen: boolean;
+    /** Callback to close the drawer/dialog */
+    onClose: () => void;
+    /** Callback to save the event (creates or updates) */
+    onSave: (event: Event) => void;
+    /** Current event data (newly created template or existing event) */
+    draftEvent: Event | null;
+    /** The ICalendarApp instance providing built-in services */
+    app: ICalendarApp;
+}
+/**
+ * Custom mobile event renderer (Drawer or Dialog)
+ */
+type MobileEventRenderer = any;
+
+/** Generic type for framework-specific components */
+type TComponent = any;
+/** Generic type for framework-specific nodes/elements */
+type TNode = any;
+/**
+ * View type enum
+ */
+declare enum ViewType {
+    DAY = "day",
+    WEEK = "week",
+    MONTH = "month",
+    YEAR = "year"
+}
+/**
+ * Plugin interface
+ * Defines the basic structure of calendar plugins
+ */
+interface CalendarPlugin {
+    name: string;
+    install: (app: ICalendarApp) => void;
+    config?: Record<string, unknown>;
+    api?: unknown;
+}
+/**
+ * View interface
+ * Defines the basic structure of calendar views
+ */
+interface CalendarView {
+    type: ViewType;
+    component: TComponent;
+    config?: Record<string, unknown>;
+}
+/**
+ * Calendar callbacks interface
+ * Defines calendar event callback functions
+ */
+interface CalendarCallbacks {
+    onViewChange?: (view: ViewType) => void | Promise<void>;
+    onEventCreate?: (event: Event) => void | Promise<void>;
+    onEventUpdate?: (event: Event) => void | Promise<void>;
+    onEventDelete?: (eventId: string) => void | Promise<void>;
+    onDateChange?: (date: Date) => void | Promise<void>;
+    onRender?: () => void | Promise<void>;
+    onVisibleMonthChange?: (date: Date) => void | Promise<void>;
+    onCalendarUpdate?: (calendar: CalendarType) => void | Promise<void>;
+    onCalendarCreate?: (calendar: CalendarType) => void | Promise<void>;
+    onCalendarDelete?: (calendarId: string) => void | Promise<void>;
+    onCalendarMerge?: (sourceId: string, targetId: string) => void | Promise<void>;
+    onEventClick?: (event: Event) => void | Promise<void>;
+    onMoreEventsClick?: (date: Date) => void | Promise<void>;
+}
+interface CreateCalendarDialogProps {
+    onClose: () => void;
+    onCreate: (calendar: CalendarType) => void;
+    colorPickerMode?: 'blossom' | 'default';
+}
+interface CalendarHeaderProps {
+    calendar: ICalendarApp;
+    switcherMode?: ViewSwitcherMode;
+    onAddCalendar?: (e: any) => void;
+    onSearchChange?: (value: string) => void;
+    /** Triggered when search icon is clicked (typically on mobile) */
+    onSearchClick?: () => void;
+    searchValue?: string;
+    isSearchOpen?: boolean;
+    isEditable?: boolean;
+    /** Left safe area padding (px) to avoid overlapping with traffic light buttons in macMode */
+    safeAreaLeft?: number;
+}
+/**
+ * Sidebar render props
+ */
+interface CalendarSidebarRenderProps {
+    app: ICalendarApp;
+    calendars: CalendarType[];
+    toggleCalendarVisibility: (calendarId: string, visible: boolean) => void;
+    toggleAll: (visible: boolean) => void;
+    isCollapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    renderCalendarContextMenu?: (calendar: CalendarType, onClose: () => void) => TNode;
+    createCalendarMode?: 'inline' | 'modal';
+    renderCreateCalendarDialog?: (props: CreateCalendarDialogProps) => TNode;
+    editingCalendarId?: string | null;
+    setEditingCalendarId?: (id: string | null) => void;
+    onCreateCalendar?: () => void;
+    colorPickerMode?: 'blossom' | 'default';
+}
+/**
+ * Sidebar config
+ */
+interface SidebarConfig {
+    enabled?: boolean;
+    width?: number | string;
+    initialCollapsed?: boolean;
+    render?: (props: CalendarSidebarRenderProps) => TNode;
+    renderCalendarContextMenu?: (calendar: CalendarType, onClose: () => void) => TNode;
+    createCalendarMode?: 'inline' | 'modal';
+    renderCreateCalendarDialog?: (props: CreateCalendarDialogProps) => TNode;
+    /** Color picker mode: 'blossom' for BlossomColorPicker, 'default' for react-color */
+    colorPickerMode?: 'blossom' | 'default';
+}
+/**
+ * Calendar application configuration
+ * Used to initialize CalendarApp
+ */
+interface CalendarAppConfig {
+    views: CalendarView[];
+    plugins?: CalendarPlugin[];
+    events?: Event[];
+    callbacks?: CalendarCallbacks;
+    defaultView?: ViewType;
+    initialDate?: Date;
+    switcherMode?: ViewSwitcherMode;
+    calendars?: CalendarType[];
+    defaultCalendar?: string;
+    theme?: ThemeConfig;
+    useSidebar?: boolean | SidebarConfig;
+    useEventDetailDialog?: boolean;
+    useCalendarHeader?: boolean | ((props: CalendarHeaderProps) => TNode);
+    customMobileEventRenderer?: MobileEventRenderer;
+    locale?: string | Locale;
+    readOnly?: boolean | ReadOnlyConfig;
+}
+/**
+ * Read-only configuration
+ */
+interface ReadOnlyConfig {
+    draggable?: boolean;
+    viewable?: boolean;
+}
+/**
+ * Calendar application state
+ * Internal state of CalendarApp
+ */
+interface CalendarAppState {
+    currentView: ViewType;
+    currentDate: Date;
+    events: Event[];
+    plugins: Map<string, CalendarPlugin>;
+    views: Map<ViewType, CalendarView>;
+    switcherMode?: ViewSwitcherMode;
+    sidebar?: SidebarConfig;
+    locale: string | Locale;
+    highlightedEventId?: string | null;
+    readOnly: boolean | ReadOnlyConfig;
+}
+/**
+ * Calendar application instance
+ * Core interface of CalendarApp
+ */
+interface ICalendarApp {
+    state: CalendarAppState;
+    getReadOnlyConfig: () => ReadOnlyConfig;
+    subscribe: (listener: (app: ICalendarApp) => void) => () => void;
+    changeView: (view: ViewType) => void;
+    getCurrentView: () => CalendarView;
+    getViewConfig: (viewType: ViewType) => Record<string, unknown>;
+    setCurrentDate: (date: Date) => void;
+    getCurrentDate: () => Date;
+    goToToday: () => void;
+    goToPrevious: () => void;
+    goToNext: () => void;
+    selectDate: (date: Date) => void;
+    undo: () => void;
+    applyEventsChanges: (changes: {
+        add?: Event[];
+        update?: Array<{
+            id: string;
+            updates: Partial<Event>;
+        }>;
+        delete?: string[];
+    }, isPending?: boolean) => void;
+    addEvent: (event: Event) => void;
+    updateEvent: (id: string, event: Partial<Event>, isPending?: boolean) => void;
+    deleteEvent: (id: string) => void;
+    getEvents: () => Event[];
+    getAllEvents: () => Event[];
+    onEventClick: (event: Event) => void;
+    onMoreEventsClick: (date: Date) => void;
+    highlightEvent: (eventId: string | null) => void;
+    getCalendars: () => CalendarType[];
+    reorderCalendars: (fromIndex: number, toIndex: number) => void;
+    setCalendarVisibility: (calendarId: string, visible: boolean) => void;
+    setAllCalendarsVisibility: (visible: boolean) => void;
+    updateCalendar: (id: string, updates: Partial<CalendarType>, isPending?: boolean) => void;
+    createCalendar: (calendar: CalendarType) => void;
+    deleteCalendar: (id: string) => void;
+    mergeCalendars: (sourceId: string, targetId: string) => void;
+    setVisibleMonth: (date: Date) => void;
+    getVisibleMonth: () => Date;
+    getPlugin: <T = unknown>(name: string) => T | undefined;
+    hasPlugin: (name: string) => boolean;
+    getSidebarConfig: () => SidebarConfig;
+    getCalendarHeaderConfig: () => boolean | ((props: CalendarHeaderProps) => TNode);
+    triggerRender: () => void;
+    getCalendarRegistry: () => CalendarRegistry;
+    getUseEventDetailDialog: () => boolean;
+    getCustomMobileEventRenderer: () => MobileEventRenderer | undefined;
+    updateConfig: (config: Partial<CalendarAppConfig>) => void;
+    setTheme: (mode: ThemeMode) => void;
+    getTheme: () => ThemeMode;
+    subscribeThemeChange: (callback: (theme: ThemeMode) => void) => () => void;
+    unsubscribeThemeChange: (callback: (theme: ThemeMode) => void) => void;
+}
+/**
+ * useCalendarApp Hook return type
+ * Calendar application interface provided for React components
+ */
+interface UseCalendarAppReturn {
+    app: ICalendarApp;
+    currentView: ViewType;
+    currentDate: Date;
+    events: Event[];
+    applyEventsChanges: (changes: {
+        add?: Event[];
+        update?: Array<{
+            id: string;
+            updates: Partial<Event>;
+        }>;
+        delete?: string[];
+    }, isPending?: boolean) => void;
+    changeView: (view: ViewType) => void;
+    setCurrentDate: (date: Date) => void;
+    addEvent: (event: Event) => void;
+    updateEvent: (id: string, event: Partial<Event>, isPending?: boolean) => void;
+    deleteEvent: (id: string) => void;
+    goToToday: () => void;
+    goToPrevious: () => void;
+    goToNext: () => void;
+    selectDate: (date: Date) => void;
+    undo: () => void;
+    getCalendars: () => CalendarType[];
+    createCalendar: (calendar: CalendarType) => void;
+    mergeCalendars: (sourceId: string, targetId: string) => void;
+    setCalendarVisibility: (calendarId: string, visible: boolean) => void;
+    setAllCalendarsVisibility: (visible: boolean) => void;
+    getAllEvents: () => Event[];
+    highlightEvent: (eventId: string | null) => void;
+    setVisibleMonth: (date: Date) => void;
+    getVisibleMonth: () => Date;
+    sidebarConfig: SidebarConfig;
+    readOnlyConfig: ReadOnlyConfig;
+}
+/**
+ * Calendar configuration system type
+ * Contains drag and view configurations
+ */
+interface CalendarConfig {
+    locale?: string;
+    drag: {
+        HOUR_HEIGHT: number;
+        FIRST_HOUR: number;
+        LAST_HOUR: number;
+        MIN_DURATION: number;
+        TIME_COLUMN_WIDTH: number;
+        ALL_DAY_HEIGHT: number;
+        getLineColor: (color: string) => string;
+        getDynamicPadding: (drag: {
+            endHour: number;
+            startHour: number;
+        }) => string;
+    };
+    views: {
+        day: Record<string, unknown>;
+        week: Record<string, unknown>;
+        month: Record<string, unknown>;
+    };
+}
+interface UseCalendarReturn {
+    view: ViewType;
+    currentDate: Date;
+    events: Event[];
+    currentWeekStart: Date;
+    changeView: (view: ViewType) => void;
+    goToToday: () => void;
+    goToPrevious: () => void;
+    goToNext: () => void;
+    selectDate: (date: Date) => void;
+    updateEvent: (eventId: string, updates: Partial<Event>, isPending?: boolean) => void;
+    deleteEvent: (eventId: string) => void;
+    addEvent: (event: Omit<Event, 'id'>) => void;
+    setEvents: (events: Event[] | ((prev: Event[]) => Event[])) => void;
+}
+
+/**
+ * Date data interface
+ * Represents detailed information for a single date
+ */
+interface DayData {
+    date: Date;
+    day: number;
+    month: number;
+    year: number;
+    monthName: string;
+    shortMonthName: string;
+    isToday: boolean;
+}
+/**
+ * Week data interface
+ * Represents a week's data, containing date information for 7 days
+ */
+interface WeeksData {
+    days: DayData[];
+    startDate: Date;
+    monthYear: {
+        month: string;
+        monthIndex: number;
+        year: number;
+    };
+}
+
+/**
+ * Event layout configuration constants
+ * Controls visual presentation of events in the calendar
+ */
+declare const LAYOUT_CONFIG: {
+    readonly INDENT_STEP: 2;
+    readonly MIN_WIDTH: 25;
+    readonly MARGIN_BETWEEN: 2;
+    readonly CONTAINER_WIDTH: 320;
+    readonly OVERLAP_THRESHOLD: 0.25;
+    readonly EDGE_MARGIN: 3;
+    readonly MAX_LOAD_IMBALANCE: 0;
+    readonly REBALANCE_THRESHOLD: 2;
+};
+/**
+ * Event layout interface
+ * Defines position and styling of events in the UI
+ */
+interface EventLayout {
+    id: string;
+    left: number;
+    width: number;
+    zIndex: number;
+    level: number;
+    isPrimary: boolean;
+    indentOffset: number;
+    importance: number;
+}
+/**
+ * Nested layer interface
+ * Represents hierarchical relationships of events
+ */
+interface NestedLayer {
+    events: Event[];
+    level: number;
+    parentEvent?: Event;
+    timeSlot?: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Event group interface
+ * Represents a group of related events and their nested structure
+ */
+interface EventGroup {
+    events: Event[];
+    startHour: number;
+    endHour: number;
+    primaryEvent?: Event;
+    nestedStructure: NestedLayer[];
+    specialLayoutRules?: SpecialLayoutRule[];
+    originalBranchMap?: Map<string, Event>;
+}
+/**
+ * Event relationship information interface
+ * Describes relationships of events in nested structures
+ */
+interface EventRelations {
+    directChildren: Event[];
+    allDescendants: Event[];
+    directParent: Event | null;
+    layer: NestedLayer | null;
+    subtreeSize: number;
+    isLeaf: boolean;
+}
+/**
+ * Subtree analysis interface
+ * Used to analyze structural information of event trees
+ */
+interface SubtreeAnalysis {
+    rootEvent: Event;
+    allDescendants: Event[];
+    timeSpan: {
+        start: number;
+        end: number;
+        duration: number;
+    };
+    descendantCount: number;
+    maxDepth: number;
+    branchPath: Event[];
+}
+/**
+ * Balance strategy interface
+ * Used for balance algorithms to optimize event layouts
+ */
+interface BalanceStrategy {
+    type: 'count_balance' | 'timespan_balance';
+    transfers: TransferOperation[];
+    specialLayoutRules: SpecialLayoutRule[];
+}
+/**
+ * Transfer operation interface
+ * Describes movement of events in layout optimization
+ */
+interface TransferOperation {
+    event: Event;
+    fromParent: Event;
+    toParent: Event;
+    reason: string;
+}
+/**
+ * Special layout rule interface
+ * Defines layout constraints for specific events
+ */
+interface SpecialLayoutRule {
+    eventId: string;
+    layoutType: 'align_with_ancestor' | 'full_width' | 'full_width_from_level' | 'align_with_sibling';
+    referenceEvent?: Event;
+    targetLevel?: number;
+    reason?: string;
+}
+
+/**
+ * Virtual scroll item interface (YearView)
+ */
+interface VirtualItem {
+    index: number;
+    year: number;
+    top: number;
+    height: number;
+}
+/**
+ * Virtual scroll Hook parameters interface (YearView)
+ */
+interface UseVirtualScrollProps {
+    currentDate: Date;
+    yearHeight: number;
+    onCurrentYearChange?: (year: number) => void;
+}
+/**
+ * Virtual scroll Hook return value interface (YearView)
+ */
+interface UseVirtualScrollReturn {
+    scrollTop: number;
+    containerHeight: number;
+    currentYear: number;
+    isScrolling: boolean;
+    virtualData: {
+        totalHeight: number;
+        visibleItems: VirtualItem[];
+    };
+    scrollElementRef: any;
+    handleScroll: (e: any) => void;
+    scrollToYear: (targetYear: number, smooth?: boolean) => void;
+    handlePreviousYear: () => void;
+    handleNextYear: () => void;
+    handleToday: () => void;
+    setScrollTop: (val: number | ((prev: number) => number)) => void;
+    setContainerHeight: (val: number | ((prev: number) => number)) => void;
+    setCurrentYear: (val: number | ((prev: number) => number)) => void;
+    setIsScrolling: (val: boolean | ((prev: boolean) => boolean)) => void;
+}
+/**
+ * Drag state Hook return value
+ */
+interface UseDragStateReturn {
+    dragRef: RefObject<UnifiedDragRef>;
+    currentDragRef: RefObject<{
+        x: number;
+        y: number;
+    }>;
+    dragState: MonthDragState | WeekDayDragState;
+    setDragState: (val: MonthDragState | WeekDayDragState | ((prev: MonthDragState | WeekDayDragState) => MonthDragState | WeekDayDragState)) => void;
+    resetDragState: () => void;
+    throttledSetEvents: (updateFunc: (events: Event[]) => Event[], dragState?: string) => void;
+}
+/**
+ * Drag common utilities Hook return value
+ */
+interface UseDragCommonReturn {
+    pixelYToHour: (y: number) => number;
+    getColumnDayIndex: (x: number) => number;
+    checkIfInAllDayArea: (clientY: number) => boolean;
+    handleDirectScroll: (clientY: number) => void;
+    daysDifference: (date1: Date, date2: Date) => number;
+    addDaysToDate: (date: Date, days: number) => Date;
+    getTargetDateFromPosition: (clientX: number, clientY: number) => Date | null;
+    ONE_DAY_MS: number;
+}
+/**
+ * Drag management Hook return value
+ */
+interface UseDragManagerReturn {
+    dragIndicatorRef: RefObject<HTMLDivElement | null>;
+    removeDragIndicator: () => void;
+    createDragIndicator: (drag: UnifiedDragRef, color?: string, title?: string, layout?: EventLayout | null, sourceElement?: HTMLElement) => void;
+    updateDragIndicator: (...args: (number | boolean | EventLayout | null | undefined)[]) => void;
+}
+/**
+ * Drag handler Hook return value
+ */
+interface UseDragHandlersReturn {
+    handleDragMove: (e: MouseEvent | TouchEvent) => void;
+    handleDragEnd: (e: MouseEvent | TouchEvent) => void;
+    handleCreateStart: (e: any | any, ...args: (Date | number)[]) => void;
+    handleMoveStart: (e: any | any, event: Event) => void;
+    handleResizeStart: (e: any | any, event: Event, direction: string) => void;
+    handleUniversalDragMove: (e: MouseEvent | TouchEvent) => void;
+    handleUniversalDragEnd: (e?: MouseEvent | TouchEvent) => void;
+}
+/**
+ * Drag handler Hook parameters
+ */
+interface UseDragHandlersParams {
+    options: useDragProps;
+    common: UseDragCommonReturn;
+    state: UseDragStateReturn;
+    manager: UseDragManagerReturn;
+}
+
+/**
+ * Drag mode type
+ */
+type Mode = 'create' | 'move' | 'resize' | null;
+/**
+ * Drag reference interface
+ * Stores state information for drag operations
+ */
+interface DragRef {
+    active: boolean;
+    mode: Mode;
+    eventId: string | null;
+    dayIndex: number;
+    startX: number;
+    startY: number;
+    startHour: number;
+    endHour: number;
+    originalDay: number;
+    originalStartHour: number;
+    originalEndHour: number;
+    resizeDirection: string | null;
+    hourOffset: number | null;
+    duration: number;
+    lastRawMouseHour: number | null;
+    lastUpdateTime: number;
+    initialMouseY: number;
+    lastClientY: number;
+    allDay: boolean;
+    eventDate?: Date;
+}
+/**
+ * Event detail position interface
+ * Used to position event detail popup
+ */
+interface EventDetailPosition {
+    top: number;
+    left: number;
+    eventHeight: number;
+    eventMiddleY: number;
+    isSunday?: boolean;
+}
+interface DragIndicatorProps {
+    drag: DragRef;
+    color?: string;
+    title?: string;
+    layout?: EventLayout | null;
+    allDay: boolean;
+    formatTime: (hour: number) => string;
+    getLineColor: (color: string) => string;
+    getDynamicPadding: (drag: DragRef) => string;
+    locale?: string;
+    isMobile?: boolean;
+}
+interface DragIndicatorRenderer {
+    renderAllDayContent: (props: DragIndicatorProps) => any;
+    renderRegularContent: (props: DragIndicatorProps) => any;
+    renderDefaultContent: (props: DragIndicatorProps) => any;
+}
+interface UnifiedDragRef extends DragRef {
+    targetDate?: Date | null;
+    originalDate?: Date | null;
+    originalEvent?: Event | null;
+    dragOffset?: number;
+    originalStartDate?: Date | null;
+    originalEndDate?: Date | null;
+    eventDate?: Date;
+    originalStartTime?: {
+        hour: number;
+        minute: number;
+        second: number;
+    } | null;
+    originalEndTime?: {
+        hour: number;
+        minute: number;
+        second: number;
+    } | null;
+    sourceElement?: HTMLElement | null;
+    indicatorVisible?: boolean;
+    eventDurationDays?: number;
+    currentSegmentDays?: number;
+    startDragDayIndex?: number;
+    calendarId?: string;
+    title?: string;
+}
+interface useDragProps extends Partial<DragConfig> {
+    calendarRef: any;
+    allDayRowRef?: any;
+    onEventsUpdate: (updateFunc: (events: Event[]) => Event[], isResizing?: boolean) => void;
+    onEventCreate: (event: Event) => void;
+    onEventEdit?: (event: Event) => void;
+    calculateNewEventLayout?: (dayIndex: number, startHour: number, endHour: number) => EventLayout | null;
+    calculateDragLayout?: (event: Event, targetDay: number, targetStartHour: number, targetEndHour: number) => EventLayout | null;
+    currentWeekStart: Date;
+    events: Event[];
+    renderer?: DragIndicatorRenderer;
+    app?: ICalendarApp;
+    isMobile?: boolean;
+}
+type MonthDragState = {
+    active: boolean;
+    mode: 'create' | 'move' | 'resize' | null;
+    eventId: string | null;
+    targetDate: Date | null;
+    startDate: Date | null;
+    endDate: Date | null;
+};
+type WeekDayDragState = {
+    active: boolean;
+    mode: 'create' | 'move' | 'resize' | null;
+    eventId: string | null;
+    dayIndex: number;
+    startHour: number;
+    endHour: number;
+    allDay: boolean;
+};
+interface useDragReturn {
+    createDragIndicator: (drag: UnifiedDragRef, color?: string, title?: string, layout?: EventLayout | null, sourceElement?: HTMLElement) => void;
+    updateDragIndicator: (...args: (number | boolean | EventLayout | null | undefined)[]) => void;
+    removeDragIndicator: () => void;
+    handleCreateAllDayEvent?: (e: any, dayIndex: number) => void;
+    handleCreateStart: (e: any | any, ...args: (Date | number)[]) => void;
+    handleMoveStart: (e: any | any, event: Event) => void;
+    handleResizeStart: (e: any | any, event: Event, direction: string) => void;
+    dragState: MonthDragState | WeekDayDragState;
+    isDragging: boolean;
+    pixelYToHour?: (y: number) => number;
+    getColumnDayIndex?: (x: number) => number;
+}
+/**
+ * Month view event drag state (alias for MonthDragState, maintains backward compatibility)
+ */
+type MonthEventDragState = MonthDragState;
+interface UseMonthDragReturn {
+    daysDifference: (date1: Date, date2: Date) => number;
+    addDaysToDate: (date: Date, days: number) => Date;
+    getTargetDateFromPosition: (clientX: number, clientY: number) => Date | null;
+}
+interface UseMonthDragParams {
+    options: useDragProps;
+    common: UseDragCommonReturn;
+    state: UseDragStateReturn;
+    manager: UseDragManagerReturn;
+}
+interface UseWeekDayDragReturn {
+    handleCreateAllDayEvent: (e: any, dayIndex: number) => void;
+    pixelYToHour: (y: number) => number;
+    getColumnDayIndex: (x: number) => number;
+}
+interface UseWeekDayDragParams {
+    options: useDragProps;
+    common: UseDragCommonReturn;
+    state: UseDragStateReturn;
+    manager: UseDragManagerReturn;
+    handleDragMove: (e: MouseEvent) => void;
+    handleDragEnd: (e: MouseEvent) => void;
+}
+
+interface UseVirtualMonthScrollProps {
+    currentDate: Date;
+    weekHeight: number;
+    onCurrentMonthChange?: (month: string, year: number) => void;
+    initialWeeksToLoad?: number;
+    locale?: string;
+    isEnabled?: boolean;
+}
+interface UseVirtualMonthScrollReturn {
+    scrollTop: number;
+    containerHeight: number;
+    currentMonth: string;
+    currentYear: number;
+    isScrolling: boolean;
+    virtualData: {
+        totalHeight: number;
+        visibleItems: VirtualWeekItem[];
+        displayStartIndex: number;
+    };
+    scrollElementRef: any;
+    handleScroll: (e: any) => void;
+    scrollToDate: (targetDate: Date, smooth?: boolean) => void;
+    handlePreviousMonth: () => void;
+    handleNextMonth: () => void;
+    handleToday: () => void;
+    setScrollTop: React.Dispatch<React.SetStateAction<number>>;
+    setContainerHeight: React.Dispatch<React.SetStateAction<number>>;
+    setCurrentMonth: React.Dispatch<React.SetStateAction<string>>;
+    setCurrentYear: React.Dispatch<React.SetStateAction<number>>;
+    setIsScrolling: React.Dispatch<React.SetStateAction<boolean>>;
+    cache: WeekDataCache;
+    scrollElementRefCallback: (element: HTMLDivElement | null) => void;
+    weeksData: WeeksData[];
+}
+declare const VIRTUAL_MONTH_SCROLL_CONFIG: {
+    readonly OVERSCAN: 6;
+    readonly BUFFER_SIZE: 100;
+    readonly MIN_YEAR: 1900;
+    readonly MAX_YEAR: 2200;
+    readonly SCROLL_THROTTLE: 8;
+    readonly SCROLL_DEBOUNCE: 150;
+    readonly CACHE_CLEANUP_THRESHOLD: 200;
+    readonly MOBILE_WEEK_HEIGHT: 80;
+    readonly TABLET_WEEK_HEIGHT: 90;
+    readonly WEEK_HEIGHT: 119;
+};
+interface VirtualWeekItem {
+    index: number;
+    weekData: WeeksData;
+    top: number;
+    height: number;
+}
+declare class WeekDataCache {
+    private cache;
+    private accessOrder;
+    private maxSize;
+    constructor(maxSize?: number);
+    private getKey;
+    get(weekStartDate: Date): WeeksData | undefined;
+    set(weekStartDate: Date, data: WeeksData): void;
+    private updateAccessOrder;
+    getSize(): number;
+    clear(): void;
+}
+
+/**
+ * Event detail panel Props
+ */
+interface EventDetailPanelProps {
+    /** Current event data */
+    event: Event;
+    /** Panel position information */
+    position: EventDetailPosition;
+    /** Panel DOM reference */
+    panelRef: any;
+    /** Whether the event is all-day */
+    isAllDay: boolean;
+    /** Event visibility state */
+    eventVisibility: 'visible' | 'sticky-top' | 'sticky-bottom';
+    /** Calendar container reference */
+    calendarRef: any;
+    /** Selected event element reference */
+    selectedEventElementRef: any;
+    /** Event update callback */
+    onEventUpdate: (updatedEvent: Event) => void;
+    /** Event delete callback */
+    onEventDelete: (eventId: string) => void;
+    /** Close panel callback (optional) */
+    onClose?: () => void;
+}
+/**
+ * Custom event detail panel renderer (full panel including positioning and styling)
+ */
+type EventDetailPanelRenderer = any;
+/**
+ * Event detail content Props (excluding panel container, content only)
+ */
+interface EventDetailContentProps {
+    /** Current event data */
+    event: Event;
+    /** Whether the event is all-day */
+    isAllDay: boolean;
+    /** Event update callback */
+    onEventUpdate: (updatedEvent: Event) => void;
+    /** Event delete callback */
+    onEventDelete: (eventId: string) => void;
+    /** Close panel callback (optional) */
+    onClose?: () => void;
+}
+/**
+ * Custom event detail content renderer (content only, will be wrapped in default panel)
+ */
+type EventDetailContentRenderer = any;
+/**
+ * Event detail dialog Props
+ */
+interface EventDetailDialogProps {
+    /** Current event data */
+    event: Event;
+    /** Whether the dialog is open */
+    isOpen: boolean;
+    /** Whether the event is all-day */
+    isAllDay: boolean;
+    /** Event update callback */
+    onEventUpdate: (updatedEvent: Event) => void;
+    /** Event delete callback */
+    onEventDelete: (eventId: string) => void;
+    /** Close dialog callback */
+    onClose: () => void;
+    app?: ICalendarApp;
+}
+/**
+ * Custom event detail dialog renderer (Dialog/Modal mode)
+ */
+type EventDetailDialogRenderer = any;
+
+/**
+ * Common Props interface for view components
+ * Base properties for all view components
+ */
+interface BaseViewProps<TConfig = any> {
+    app: ICalendarApp;
+    currentDate?: Date;
+    currentView?: ViewType;
+    events?: Event[];
+    onEventUpdate?: (event: Event) => void;
+    onEventDelete?: (eventId: string) => void;
+    onEventCreate?: (event: Event) => void;
+    onDateChange?: (date: Date) => void;
+    onViewChange?: (view: ViewType) => void;
+    config: TConfig;
+    selectedEventId?: string | null;
+    onEventSelect?: (eventId: string | null) => void;
+    detailPanelEventId?: string | null;
+    onDetailPanelToggle?: (eventId: string | null) => void;
+    customDetailPanelContent?: EventDetailContentRenderer;
+    customEventDetailDialog?: EventDetailDialogRenderer;
+    calendarRef: any;
+    switcherMode?: ViewSwitcherMode;
+    meta?: Record<string, any>;
+}
+/**
+ * Day view specific Props
+ */
+interface DayViewProps extends BaseViewProps<DayViewConfig> {
+}
+/**
+ * Week view specific Props
+ */
+interface WeekViewProps extends BaseViewProps<WeekViewConfig> {
+}
+/**
+ * Month view specific Props
+ */
+interface MonthViewProps extends BaseViewProps<MonthViewConfig> {
+}
+/**
+ * Year view specific Props
+ */
+interface YearViewProps extends BaseViewProps<YearViewConfig> {
+}
+/**
+ * View factory configuration interface
+ * Base configuration for creating views
+ */
+interface ViewFactoryConfig {
+    enableDrag?: boolean;
+    enableResize?: boolean;
+    enableCreate?: boolean;
+    dragConfig?: Record<string, any>;
+    eventsConfig?: Record<string, any>;
+    virtualScrollConfig?: Record<string, any>;
+    viewConfig?: Record<string, any>;
+}
+/**
+ * Day view factory configuration
+ */
+interface DayViewConfig extends ViewFactoryConfig {
+    showMiniCalendar?: boolean;
+    showAllDay?: boolean;
+    scrollToCurrentTime?: boolean;
+    hourHeight?: number;
+    firstHour?: number;
+    lastHour?: number;
+    HOUR_HEIGHT?: number;
+    FIRST_HOUR?: number;
+    LAST_HOUR?: number;
+    ALL_DAY_HEIGHT?: number;
+}
+/**
+ * Week view factory configuration
+ */
+interface WeekViewConfig extends ViewFactoryConfig {
+    showWeekends?: boolean;
+    showAllDay?: boolean;
+    startOfWeek?: number;
+    scrollToCurrentTime?: boolean;
+    hourHeight?: number;
+    firstHour?: number;
+    lastHour?: number;
+    HOUR_HEIGHT?: number;
+    FIRST_HOUR?: number;
+    LAST_HOUR?: number;
+    ALL_DAY_HEIGHT?: number;
+}
+/**
+ * Month view factory configuration
+ */
+interface MonthViewConfig extends ViewFactoryConfig {
+    showOtherMonth?: boolean;
+    weekHeight?: number;
+    showWeekNumbers?: boolean;
+    enableVirtualScroll?: boolean;
+    initialWeeksToLoad?: number;
+}
+/**
+ * Year view factory configuration
+ */
+interface YearViewConfig extends ViewFactoryConfig {
+    enableVirtualScroll?: boolean;
+    showDebugInfo?: boolean;
+    mode?: 'year-canvas' | 'fixed-week';
+    showTimedEventsInYearView?: boolean;
+}
+/**
+ * View adapter Props
+ * Adapter properties for wrapping original components
+ */
+interface ViewAdapterProps extends BaseViewProps {
+    viewType: ViewType;
+    originalComponent: any;
+    config: ViewFactoryConfig;
+    className?: string;
+}
+/**
+ * Drag integration Props
+ * Properties for integrating drag functionality into views
+ */
+interface DragIntegrationProps {
+    app: ICalendarApp;
+    viewType: ViewType;
+    calendarRef: any;
+    allDayRowRef?: any;
+    events: Event[];
+    onEventsUpdate: (updateFunc: (events: Event[]) => Event[]) => void;
+    onEventCreate: (event: Event) => void;
+    calculateNewEventLayout?: (dayIndex: number, startHour: number, endHour: number) => EventLayout | null;
+    calculateDragLayout?: (event: Event, targetDay: number, targetStartHour: number, targetEndHour: number) => EventLayout | null;
+    currentWeekStart: Date;
+}
+/**
+ * Virtual scroll integration Props
+ * Properties for integrating virtual scroll functionality into views
+ */
+interface VirtualScrollIntegrationProps {
+    app: ICalendarApp;
+    currentDate: Date;
+    weekHeight?: number;
+    onCurrentMonthChange?: (month: string, year: number) => void;
+    initialWeeksToLoad?: number;
+}
+/**
+ * Factory function return type
+ * Type definition for view factory functions
+ */
+interface ViewFactory<TConfig = ViewFactoryConfig> {
+    (config?: TConfig): CalendarView;
+}
+
+/**
+ * Drag configuration type
+ * Defines configuration parameters for drag functionality
+ */
+interface DragConfig {
+    viewType: ViewType;
+    getLineColor: (color: string) => string;
+    getDynamicPadding: (drag: {
+        endHour: number;
+        startHour: number;
+    }) => string;
+    HOUR_HEIGHT: number;
+    FIRST_HOUR: number;
+    LAST_HOUR: number;
+    MIN_DURATION: number;
+    TIME_COLUMN_WIDTH: number;
+    ALL_DAY_HEIGHT: number;
+}
+
+/**
+ * Events service interface
+ * Provides various event management functions
+ */
+interface EventsService {
+    getAll: () => Event[];
+    getById: (id: string) => Event | undefined;
+    add: (event: Event) => void;
+    update: (id: string, updates: Partial<Event>) => Event;
+    delete: (id: string) => void;
+    getByDate: (date: Date) => Event[];
+    getByDateRange: (startDate: Date, endDate: Date) => Event[];
+    getByDay: (dayIndex: number, weekStart: Date) => Event[];
+    getAllDayEvents: (dayIndex: number, events: Event[]) => Event[];
+    recalculateEventDays: (events: Event[], weekStart: Date) => Event[];
+    validateEvent: (event: Partial<Event>) => string[];
+    filterEvents: (events: Event[], filter: (event: Event) => boolean) => Event[];
+}
+/**
+ * Events plugin configuration
+ */
+interface EventsPluginConfig {
+    enableAutoRecalculate?: boolean;
+    enableValidation?: boolean;
+    defaultEvents?: Event[];
+    maxEventsPerDay?: number;
+}
+/**
+ * Drag Hook options
+ */
+interface DragHookOptions extends Partial<DragConfig> {
+    calendarRef: any;
+    allDayRowRef?: any;
+    viewType: ViewType;
+    onEventsUpdate: (updateFunc: (events: Event[]) => Event[], isResizing?: boolean) => void;
+    onEventCreate: (event: Event) => void;
+    onEventEdit: (event: Event) => void;
+    currentWeekStart: Date;
+    events: Event[];
+    calculateNewEventLayout?: (dayIndex: number, startHour: number, endHour: number) => EventLayout | null;
+    calculateDragLayout?: (event: Event, targetDay: number, targetStartHour: number, targetEndHour: number) => EventLayout | null;
+    isMobile?: boolean;
+}
+/**
+ * Drag Hook return value
+ */
+interface DragHookReturn {
+    handleMoveStart?: (e: any | any, event: Event) => void;
+    handleCreateStart?: (e: any | any, ...args: (Date | number)[]) => void;
+    handleResizeStart?: (e: any | any, event: Event, direction: string) => void;
+    handleCreateAllDayEvent?: (e: any, dayIndex: number) => void;
+    dragState: MonthDragState | WeekDayDragState;
+    isDragging: boolean;
+}
+/**
+ * Drag plugin configuration
+ */
+interface DragPluginConfig {
+    enableDrag: boolean;
+    enableResize: boolean;
+    enableCreate: boolean;
+    enableAllDayCreate: boolean;
+    supportedViews: ViewType[];
+    [key: string]: unknown;
+}
+/**
+ * Drag service interface
+ * Provides drag capability for views
+ */
+interface DragService {
+    getConfig: () => DragPluginConfig;
+    updateConfig: (updates: Partial<DragPluginConfig>) => void;
+    isViewSupported: (viewType: ViewType) => boolean;
+}
+
+declare class CalendarApp implements ICalendarApp {
+    state: CalendarAppState;
+    private callbacks;
+    private calendarRegistry;
+    private sidebarConfig;
+    private visibleMonth;
+    private useEventDetailDialog;
+    private useCalendarHeader;
+    private customMobileEventRenderer?;
+    private themeChangeListeners;
+    private listeners;
+    private undoStack;
+    private pendingSnapshot;
+    private readonly MAX_UNDO_STACK;
+    constructor(config: CalendarAppConfig);
+    private resolveLocale;
+    subscribe: (listener: (app: ICalendarApp) => void) => (() => void);
+    private notify;
+    private pushToUndo;
+    undo: () => void;
+    getReadOnlyConfig: () => ReadOnlyConfig;
+    /**
+     * Helper to check if the calendar is in any form of read-only mode.
+     * If readOnly config is present, it's considered non-editable.
+     */
+    private isInternalEditable;
+    changeView: (view: ViewType) => void;
+    getCurrentView: () => CalendarView;
+    setCurrentDate: (date: Date) => void;
+    getCurrentDate: () => Date;
+    setVisibleMonth: (date: Date) => void;
+    getVisibleMonth: () => Date;
+    goToToday: () => void;
+    goToPrevious: () => void;
+    goToNext: () => void;
+    selectDate: (date: Date) => void;
+    applyEventsChanges: (changes: {
+        add?: Event[];
+        update?: Array<{
+            id: string;
+            updates: Partial<Event>;
+        }>;
+        delete?: string[];
+    }, isPending?: boolean) => void;
+    addEvent: (event: Event) => void;
+    updateEvent: (id: string, eventUpdate: Partial<Event>, isPending?: boolean) => void;
+    deleteEvent: (id: string) => void;
+    getAllEvents: () => Event[];
+    onEventClick: (event: Event) => void;
+    onMoreEventsClick: (date: Date) => void;
+    highlightEvent: (eventId: string | null) => void;
+    getEvents: () => Event[];
+    getCalendars: () => CalendarType[];
+    reorderCalendars: (fromIndex: number, toIndex: number) => void;
+    setCalendarVisibility: (calendarId: string, visible: boolean) => void;
+    setAllCalendarsVisibility: (visible: boolean) => void;
+    updateCalendar: (id: string, updates: Partial<CalendarType>, isPending?: boolean) => void;
+    createCalendar: (calendar: CalendarType) => void;
+    deleteCalendar: (id: string) => void;
+    mergeCalendars: (sourceId: string, targetId: string) => void;
+    getSidebarConfig: () => SidebarConfig;
+    getCalendarHeaderConfig: () => boolean | ((props: any) => TNode);
+    private installPlugin;
+    getPlugin: <T = unknown>(name: string) => T | undefined;
+    hasPlugin: (name: string) => boolean;
+    getPluginConfig: (pluginName: string) => Record<string, unknown>;
+    updatePluginConfig: (pluginName: string, config: Record<string, unknown>) => void;
+    getViewConfig: (viewType: ViewType) => Record<string, unknown>;
+    triggerRender: () => void;
+    getCalendarRegistry: () => CalendarRegistry;
+    getUseEventDetailDialog: () => boolean;
+    getCustomMobileEventRenderer: () => MobileEventRenderer | undefined;
+    updateConfig: (config: Partial<CalendarAppConfig>) => void;
+    /**
+     * Set theme mode
+     * @param mode - Theme mode ('light', 'dark', or 'auto')
+     */
+    setTheme: (mode: ThemeMode) => void;
+    /**
+     * Get current theme mode
+     * @returns Current theme mode
+     */
+    getTheme: () => ThemeMode;
+    /**
+     * Subscribe to theme changes
+     * @param callback - Function to call when theme changes
+     * @returns Unsubscribe function
+     */
+    subscribeThemeChange: (callback: (theme: ThemeMode) => void) => (() => void);
+    /**
+     * Unsubscribe from theme changes
+     * @param callback - Function to remove from listeners
+     */
+    unsubscribeThemeChange: (callback: (theme: ThemeMode) => void) => void;
+}
+
+interface CustomRendering {
+    id: string;
+    containerEl: HTMLElement;
+    generatorName: string;
+    generatorArgs: any;
+}
+type CustomRenderingListener = (map: Map<string, CustomRendering>) => void;
+declare class CustomRenderingStore {
+    private renderings;
+    private overrides;
+    private listeners;
+    /**
+     * Register a new custom rendering placeholder.
+     * Called by the ContentSlot Preact component.
+     */
+    register(rendering: CustomRendering): void;
+    /**
+     * Unregister a custom rendering placeholder.
+     */
+    unregister(id: string): void;
+    /**
+     * Set the list of generator names that have custom overrides.
+     * Called by framework adapters (React/Vue/etc.)
+     */
+    setOverrides(names: string[]): void;
+    /**
+     * Check if a specific generator has a custom override.
+     */
+    isOverridden(generatorName: string): boolean;
+    /**
+     * Subscribe to updates of the renderings map.
+     * Called by the framework adapter (React/Vue/etc.)
+     */
+    subscribe(listener: CustomRenderingListener): () => void;
+    private notify;
+}
+
+declare class CalendarRenderer {
+    private app;
+    private container;
+    private customRenderingStore;
+    private unsubscribe;
+    private renderRequested;
+    constructor(app: ICalendarApp);
+    private requestRender;
+    /**
+     * Mount the calendar to a DOM container.
+     */
+    mount(container: HTMLElement): void;
+    /**
+     * Unmount the calendar and cleanup.
+     */
+    unmount(): void;
+    getCustomRenderingStore(): CustomRenderingStore;
+    private render;
+}
+
+/**
+ * Date and Time Conversion Utilities
+ *
+ * This module provides utilities for converting between Date and Temporal API objects,
+ * extracting time components, and performing date comparisons.
+ *
+ * All functions support both legacy Date objects and modern Temporal API types
+ * for backward compatibility and future-proofing.
+ */
+
+/**
+ * Extract hour number from Date or Temporal object (with decimal for minutes, e.g., 14.5 = 14:30)
+ * @param dateTime Date or Temporal object
+ * @returns Hour number (0-24, supports decimals)
+ */
+declare const extractHourFromDate: (dateTime: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => number;
+/**
+ * Create a new date-time object based on given date but set to specified hour
+ * @param baseDateTime Base date-time
+ * @param hour Hour number (supports decimals, e.g., 14.5 = 14:30)
+ * @returns Date or Temporal (PlainDateTime or ZonedDateTime)
+ */
+declare const createDateWithHour: (baseDateTime: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, hour: number) => Date | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+/**
+ * Get start of day (00:00:00.000)
+ * @param dateTime Date-time
+ * @returns Start of day
+ */
+declare const getStartOfDay: (dateTime: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => Date | Temporal.ZonedDateTime;
+/**
+ * Get end of day (23:59:59.999)
+ * @param dateTime Date-time
+ * @returns End of day
+ */
+declare const getEndOfDay: (dateTime: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => Date | Temporal.ZonedDateTime;
+/**
+ * Check if two dates are on the same day
+ * @param date1 Date 1
+ * @param date2 Date 2
+ * @returns Whether they are the same day
+ */
+declare const isSameDay: (date1: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, date2: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => boolean;
+/**
+ * Check if event spans multiple days
+ * @param start Start time
+ * @param end End time
+ * @returns Whether it's a multi-day event
+ */
+declare const isMultiDayEvent: (start: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, end: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => boolean;
+
+/**
+ * Color Utilities
+ *
+ * This module provides utilities for resolving event colors using the calendar registry.
+ * All color functions return actual color values (not CSS classes) for inline styles.
+ */
+
+/**
+ * Get event background color (actual color value, not CSS class)
+ * Use this for inline styles
+ */
+declare const getEventBgColor: (calendarIdOrColor: string, registry?: CalendarRegistry) => string;
+/**
+ * Get event text color (actual color value, not CSS class)
+ * Use this for inline styles
+ */
+declare const getEventTextColor: (calendarIdOrColor: string, registry?: CalendarRegistry) => string;
+/**
+ * Get selected background color
+ * Now uses the calendar registry for color resolution
+ */
+declare const getSelectedBgColor: (calendarIdOrColor: string, registry?: CalendarRegistry) => string;
+/**
+ * Get line color
+ * Now uses the calendar registry for color resolution
+ */
+declare const getLineColor: (calendarIdOrColor: string, registry?: CalendarRegistry) => string;
+
+/**
+ * Time Utilities
+ *
+ * This module provides utilities for time formatting, calculations, and time step operations.
+ * Handles 24-hour format, time rounding, and special cases like midnight crossings.
+ */
+
+/**
+ * Time step for calendar grid (0.25 = 15 minutes)
+ */
+declare const TIME_STEP = 0.25;
+/**
+ * Format hours and minutes to HH:MM format
+ * @param hours Hour number (supports decimals, e.g., 14.5 = 14:30)
+ * @param minutes Optional minutes (if not provided, extracted from decimal hours)
+ * @returns Formatted time string (e.g., "14:30")
+ */
+declare const formatTime: (hours: number, minutes?: number) => string;
+/**
+ * Format event time range as a string
+ * @param event Event object
+ * @returns Formatted time range (e.g., "14:00 - 16:00" or "All day")
+ */
+declare const formatEventTimeRange: (event: Event) => string;
+/**
+ * Round hour to nearest time step
+ * @param hour Hour number
+ * @returns Rounded hour
+ */
+declare const roundToTimeStep: (hour: number) => number;
+/**
+ * Get event end hour (handles cross-day events less than 24 hours)
+ * When an event ends exactly at midnight of the next day and duration is less than 24 hours,
+ * it should be treated as 24:00 of the current day in week/day views to avoid displaying as next day 00:00.
+ * @param event Event object
+ * @returns End hour (0-24)
+ */
+declare const getEventEndHour: (event: Event) => number;
+
+/**
+ * Date Constants
+ *
+ * This module provides constant arrays for day and month names in various formats.
+ * Used throughout the application for displaying date information.
+ */
+/**
+ * Week day abbreviations (Mon-Sun)
+ */
+declare const weekDays: string[];
+/**
+ * Full week day names (Monday-Sunday)
+ */
+declare const weekDaysFullName: string[];
+/**
+ * Full month names (January-December)
+ */
+declare const monthNames: string[];
+/**
+ * Month abbreviations (Jan-Dec)
+ */
+declare const shortMonthNames: string[];
+
+/**
+ * Date Range Utilities
+ *
+ * This module provides utilities for calculating date ranges, particularly
+ * for week-based operations (Monday-Sunday).
+ */
+/**
+ * Get the Monday-Sunday range for a given date
+ * @param date Input date
+ * @returns Object with monday and sunday dates
+ */
+declare const getWeekRange: (date: Date) => {
+    monday: Date;
+    sunday: Date;
+};
+/**
+ * Get current week dates (Monday-Sunday) with today indicator
+ * @returns Array of 7 date objects with date, month, and isToday flag
+ */
+declare const getCurrentWeekDates: () => {
+    date: number;
+    month: string;
+    isToday: boolean;
+}[];
+
+/**
+ * Calendar Data Generation Utilities
+ *
+ * This module provides utilities for generating calendar data structures
+ * including days, weeks, and month/year metadata.
+ */
+
+/**
+ * Generate day data object from a date
+ * @param date Date to generate data for
+ * @returns Day data with date, day, month, year, and isToday flag
+ */
+declare const generateDayData: (date: string | number | Date) => {
+    date: Date;
+    day: number;
+    month: number;
+    year: number;
+    monthName: string;
+    shortMonthName: string;
+    isToday: boolean;
+};
+/**
+ * Generate week data (7 days starting from given date)
+ * @param startDate Week start date
+ * @returns Week data with days array, startDate, and monthYear
+ */
+declare const generateWeekData: (startDate: string | number | Date) => {
+    days: {
+        date: Date;
+        day: number;
+        month: number;
+        year: number;
+        monthName: string;
+        shortMonthName: string;
+        isToday: boolean;
+    }[];
+    startDate: Date;
+    monthYear: {
+        month: string;
+        monthIndex: number;
+        year: number;
+    };
+};
+/**
+ * Determine which month and year a week belongs to (based on majority of days)
+ * @param days Array of day data
+ * @returns Month name, month index, and year
+ */
+declare const getMonthYearOfWeek: (days: DayData[]) => {
+    month: string;
+    monthIndex: number;
+    year: number;
+};
+/**
+ * Generate weeks data around a central date
+ * @param centralDate Central date for range
+ * @param monthsToLoad Number of months to load (default: 3)
+ * @returns Array of week data
+ */
+declare const generateWeeksData: (centralDate: Date, monthsToLoad?: number) => {
+    days: {
+        date: Date;
+        day: number;
+        month: number;
+        year: number;
+        monthName: string;
+        shortMonthName: string;
+        isToday: boolean;
+    }[];
+    startDate: Date;
+    monthYear: {
+        month: string;
+        monthIndex: number;
+        year: number;
+    };
+}[];
+/**
+ * Generate week range around a center date
+ * @param centerDate Center date for range
+ * @param totalWeeks Total number of weeks to generate
+ * @returns Array of weeks data
+ */
+declare function generateWeekRange(centerDate: Date, totalWeeks: number): WeeksData[];
+
+/**
+ * Event Utilities
+ *
+ * This module provides utilities for event operations including:
+ * - Filtering events by day and type
+ * - Calculating day indices based on week start dates
+ * - Creating and updating events with proper date/time handling
+ * - Converting between Date and Temporal API objects
+ */
+
+/**
+ * Get regular (non-all-day) events for a specific day index
+ * @param dayIndex Day index (0-6, Monday-Sunday)
+ * @param events Array of events
+ * @returns Filtered events
+ */
+declare const getEventsForDay: (dayIndex: number, events: Event[]) => Event[];
+/**
+ * Get all-day events for a specific day index
+ * Supports date range checking when weekStart is provided
+ * @param dayIndex Day index (0-6, Monday-Sunday)
+ * @param events Array of events
+ * @param weekStart Optional week start date for accurate date range checking
+ * @returns Filtered all-day events
+ */
+declare const getAllDayEventsForDay: (dayIndex: number, events: Event[], weekStart?: Date) => Event[];
+/**
+ * Get Date object for a specific day index relative to week start
+ * @param weekStart Week start date
+ * @param dayIndex Day index (0-6)
+ * @returns Date object
+ */
+declare const getDateByDayIndex: (weekStart: Date, dayIndex: number) => Date;
+/**
+ * Update event's date and dayIndex
+ * @param event Event to update
+ * @param newDayIndex New day index
+ * @param weekStart Week start date
+ * @returns Updated event
+ */
+declare const updateEventDateAndDay: (event: Event, newDayIndex: number, weekStart: Date) => Event;
+/**
+ * Create new event with Date fields set
+ * @param eventData Event data without start/end
+ * @param weekStart Week start date
+ * @returns Complete event with Temporal start/end
+ */
+declare const createEventWithDate: (eventData: Omit<Event, "start" | "end">, weekStart: Date) => Event;
+/**
+ * Calculate day index based on real date and current week start
+ * @param eventDate Event date
+ * @param weekStart Week start date
+ * @returns Day index (can be outside 0-6 range for events outside current week)
+ */
+declare const calculateDayIndex: (eventDate: Date, weekStart: Date) => number;
+/**
+ * Check if event is within current week range
+ * @param eventDate Event date
+ * @param weekStart Week start date
+ * @returns Whether event is in the week
+ */
+declare const isEventInWeek: (eventDate: Date, weekStart: Date) => boolean;
+/**
+ * Recalculate day field for all events (based on current week)
+ * @param events Array of events
+ * @param weekStart Week start date
+ * @returns Events with updated day indices
+ */
+declare const recalculateEventDays: (events: Event[], weekStart: Date) => Event[];
+/**
+ * Get day index by Date (relative to week start)
+ * @param weekStart Week start date
+ * @param targetDate Target date
+ * @returns Day index
+ */
+declare const getDayIndexByDate: (weekStart: Date, targetDate: Date) => number;
+/**
+ * Get events within specified week range
+ * @param events Array of events
+ * @param weekStart Week start date
+ * @returns Filtered and recalculated events
+ */
+declare const getEventsForWeek: (events: Event[], weekStart: Date) => Event[];
+/**
+ * Create event with real date
+ * @param eventData Event data without start/end
+ * @param weekStart Week start date
+ * @returns Complete event
+ */
+declare const createEventWithRealDate: (eventData: Omit<Event, "start" | "end">, weekStart: Date) => Event;
+/**
+ * Update event with real date
+ * @param event Event to update
+ * @param newDayIndex New day index
+ * @param weekStart Week start date
+ * @returns Updated event
+ */
+declare const updateEventWithRealDate: (event: Event, newDayIndex: number, weekStart: Date) => Event;
+/**
+ * Compare two events for equality
+ * @param event1 First event
+ * @param event2 Second event
+ * @returns Whether events are equal in content
+ */
+declare const isEventEqual: (event1: Event | null, event2: Event | null) => boolean;
+
+/**
+ * Test Data Generation Utilities
+ *
+ * This module provides test/demo event data for calendar development and testing.
+ * The generated events are relative to the current week for consistent demo experience.
+ */
+
+/**
+ * Generate test events for calendar demo/testing
+ * Events are generated relative to the current week (Monday-Sunday)
+ * Includes various overlapping events, all-day events, and edge cases
+ * @returns Array of test events
+ */
+declare function getTestEvents(): Event[];
+
+/**
+ * General Utility Functions
+ *
+ * This module provides general-purpose utility functions that don't fit
+ * into other specialized categories.
+ */
+/**
+ * Generate unique key (using timestamp and random number combination)
+ * @returns Unique key string
+ */
+declare function generateUniKey(): string;
+
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ * Supports primitives, Date objects, and plain objects/arrays.
+ */
+declare function isDeepEqual(a: any, b: any): boolean;
+
+/**
+ * Format date to DD/MM/YYYY format
+ * Ensures consistent server and client rendering
+ */
+declare const formatDateConsistent: (date?: Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => string;
+/**
+ * Format month and year to consistent format
+ */
+declare const formatMonthYear: (date: Date) => string;
+/**
+ * Format date to "DD MMM YYYY" format (e.g., "15 Jan 2025")
+ * Used for event detail display
+ */
+declare const formatDate: (temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime) => string;
+
+/**
+ * Temporal Type Guards and Conversion Utilities
+ *
+ * This module provides type guards for distinguishing between different Temporal types
+ * and unified conversion functions for internal processing.
+ */
+
+/**
+ * Check if temporal is PlainDate (date only, no time)
+ */
+declare function isPlainDate(temporal: any): temporal is Temporal.PlainDate;
+/**
+ * Check if temporal is PlainDateTime (date + time, no timezone)
+ */
+declare function isPlainDateTime(temporal: any): temporal is Temporal.PlainDateTime;
+/**
+ * Check if temporal is ZonedDateTime (date + time + timezone)
+ */
+declare function isZonedDateTime(temporal: any): temporal is Temporal.ZonedDateTime;
+/**
+ * Convert any Temporal type or Date to Date (for internal processing)
+ * Handles all three Temporal types and native Date uniformly
+ */
+declare function temporalToDate(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date): Date;
+/**
+ * Convert Date to PlainDate (for all-day events)
+ */
+declare function dateToPlainDate(date: Date): Temporal.PlainDate;
+/**
+ * Convert Date to PlainDateTime (for local events without timezone)
+ */
+declare function dateToPlainDateTime(date: Date): Temporal.PlainDateTime;
+/**
+ * Convert Date to ZonedDateTime (for timezone-aware events)
+ */
+declare function dateToZonedDateTime(date: Date, timeZone: string): Temporal.ZonedDateTime;
+/**
+ * Convert PlainDateTime to Date
+ */
+declare function plainDateTimeToDate(pdt: Temporal.PlainDateTime): Date;
+/**
+ * Convert PlainDate to Date (at midnight)
+ */
+declare function plainDateToDate(pd: Temporal.PlainDate): Date;
+/**
+ * Extract hour from any Temporal type (with decimal for minutes)
+ * @returns Hour number (0-24, with decimals, e.g., 14.5 = 14:30)
+ */
+declare function extractHourFromTemporal(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date): number;
+/**
+ * Create a new Temporal with specified hour (supports PlainDateTime and ZonedDateTime)
+ * @param temporal Base temporal object
+ * @param hour Hour with decimals (e.g., 14.5 = 14:30)
+ */
+declare function setHourInTemporal(temporal: Temporal.PlainDateTime | Temporal.ZonedDateTime, hour: number): Temporal.PlainDateTime | Temporal.ZonedDateTime;
+/**
+ * Check if two Temporal objects represent the same day
+ */
+declare function isSameTemporal(t1: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date, t2: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date): boolean;
+/**
+ * Get PlainDate from any Temporal type or Date
+ */
+declare function getPlainDate(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date): Temporal.PlainDate;
+
+/**
+ * Temporal API utility functions
+ * Provides date-time processing, conversion, and compatibility support
+ */
+
+/**
+ * Check if value is Date object
+ */
+declare function isDate(value: any): value is Date;
+/**
+ * Convert Temporal.ZonedDateTime to Date
+ * @param zdt Temporal.ZonedDateTime
+ * @returns Date object
+ */
+declare function zonedDateTimeToDate(zdt: Temporal.ZonedDateTime): Date;
+/**
+ * Create new Temporal object with specified hour
+ * @param temporal Base Temporal object
+ * @param hour Hour number (supports decimals)
+ * @returns New Temporal (PlainDateTime or ZonedDateTime)
+ */
+declare function createTemporalWithHour(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, hour: number): Temporal.PlainDateTime | Temporal.ZonedDateTime;
+/**
+ * Check if two Temporal dates are on the same day
+ */
+declare function isSamePlainDate(date1: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date, date2: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date): boolean;
+/**
+ * Check if event spans multiple days
+ */
+declare function isMultiDayTemporalEvent(start: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date, end: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | Date): boolean;
+/**
+ * Get start time of Temporal date (00:00:00)
+ */
+declare function getStartOfTemporal(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, timeZone?: string): Temporal.ZonedDateTime;
+/**
+ * Get end time of Temporal date (23:59:59.999)
+ */
+declare function getEndOfTemporal(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, timeZone?: string): Temporal.ZonedDateTime;
+/**
+ * Calculate days difference between two Temporal dates
+ */
+declare function daysBetween(start: Temporal.PlainDate | Temporal.ZonedDateTime, end: Temporal.PlainDate | Temporal.ZonedDateTime): number;
+/**
+ * Calculate days difference between two Date objects (ignoring time component)
+ */
+declare function daysDifference(date1: Date, date2: Date): number;
+/**
+ * Add specified days to a date
+ */
+declare function addDays(date: Date, days: number): Date;
+/**
+ * Get current time (Temporal.ZonedDateTime)
+ */
+declare function now(timeZone?: string): Temporal.ZonedDateTime;
+/**
+ * Get today's date (Temporal.PlainDate)
+ */
+declare function today(timeZone?: string): Temporal.PlainDate;
+
+declare const pad: (input: number) => string;
+declare const mergeFormatTemplate: (dateFormat: string, timeFormat: string) => string;
+declare const buildParseRegExp: (template: string) => RegExp;
+declare const parseTemporalString: (input: string, regExp: RegExp, reference: Temporal.ZonedDateTime, zoneId: string) => Temporal.ZonedDateTime | null;
+declare const getZoneId: (value: Temporal.ZonedDateTime) => string;
+declare const normalizeToZoned: (input: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, fallbackZone?: string, fallbackTemporal?: Temporal.ZonedDateTime) => Temporal.ZonedDateTime;
+declare const formatTemporal: (value: Temporal.ZonedDateTime, format: string, timeFormat: string) => string;
+
+/**
+ * Style Utility Functions
+ *
+ * This module provides utility functions for working with CSS styles.
+ */
+/**
+ * Normalize a width value to a CSS string
+ *
+ * Converts numeric values to pixels and validates string values.
+ * Returns a default width if the input is invalid.
+ *
+ * @param width - Width as number (pixels) or CSS string
+ * @param defaultWidth - Default width to use if input is invalid (default: '240px')
+ * @returns Normalized CSS width string
+ *
+ * @example
+ * ```ts
+ * normalizeCssWidth(300) // '300px'
+ * normalizeCssWidth('20rem') // '20rem'
+ * normalizeCssWidth('') // '240px'
+ * normalizeCssWidth(undefined) // '240px'
+ * ```
+ */
+declare function normalizeCssWidth(width?: number | string, defaultWidth?: string): string;
+/**
+ * Check if the browser's scrollbar takes up space in the layout.
+ *
+ * Some browsers (like Safari on macOS with "Show scroll bars: When scrolling" setting)
+ * use overlay scrollbars that don't take up space, while others (like Chrome on Windows)
+ * use scrollbars that reduce the available width of the container.
+ *
+ * @returns true if scrollbar takes space, false otherwise
+ */
+declare function scrollbarTakesSpace(): boolean;
+
+/**
+ * Theme Utility Functions
+ *
+ * This module provides utility functions for working with theme-aware class names.
+ */
+/**
+ * Combine class names with theme-specific variants
+ *
+ * @param base - Base class names (applied in both themes)
+ * @param light - Light mode specific class names
+ * @param dark - Dark mode specific class names (will be prefixed with 'dark:')
+ * @returns Combined class name string
+ *
+ * @example
+ * ```ts
+ * themeCn('p-4 rounded', 'bg-white text-black', 'bg-gray-900 text-white')
+ * // Returns: 'p-4 rounded bg-white text-black dark:bg-gray-900 dark:text-white'
+ * ```
+ */
+declare const themeCn: (base: string, light: string, dark: string) => string;
+/**
+ * Common theme class combinations
+ *
+ * Pre-defined class combinations for common UI elements.
+ * Use these for consistency across the application.
+ */
+declare const themeClasses: {
+    container: string;
+    card: string;
+    sidebar: string;
+    text: string;
+    textMuted: string;
+    textSubtle: string;
+    textEmphasis: string;
+    border: string;
+    borderLight: string;
+    borderStrong: string;
+    bgPrimary: string;
+    bgSecondary: string;
+    bgTertiary: string;
+    bgMuted: string;
+    hover: string;
+    hoverSubtle: string;
+    active: string;
+    focus: string;
+    input: string;
+    inputFocus: string;
+    buttonPrimary: string;
+    buttonSecondary: string;
+    buttonDanger: string;
+    buttonSuccess: string;
+    shadow: string;
+    shadowMd: string;
+    shadowLg: string;
+    divider: string;
+};
+/**
+ * Conditional theme class
+ *
+ * Returns different class names based on a condition.
+ *
+ * @param condition - Condition to evaluate
+ * @param whenTrue - Class names when condition is true
+ * @param whenFalse - Class names when condition is false
+ * @returns Class name string based on condition
+ *
+ * @example
+ * ```ts
+ * conditionalTheme(isActive, 'bg-blue-500 dark:bg-blue-600', 'bg-gray-200 dark:bg-gray-700')
+ * ```
+ */
+declare const conditionalTheme: (condition: boolean, whenTrue: string, whenFalse: string) => string;
+/**
+ * Merge multiple class names, filtering out falsy values
+ *
+ * @param classes - Array of class names or falsy values
+ * @returns Merged class name string
+ *
+ * @example
+ * ```ts
+ * mergeClasses('p-4', isActive && 'bg-blue-500', 'rounded')
+ * // Returns: 'p-4 bg-blue-500 rounded' (if isActive is true)
+ * ```
+ */
+declare const mergeClasses: (...classes: (string | undefined | null | false)[]) => string;
+/**
+ * Resolve the currently applied theme on the document.
+ *
+ * This inspects common override hooks (like `data-dayflow-theme-override` or
+ * manual `dark`/`light` classes) so host applications can force a theme even
+ * when DayFlow is configured in `auto` mode.
+ */
+declare const resolveAppliedTheme: (effectiveTheme: "light" | "dark") => "light" | "dark";
+
+/**
+ * Event Helper Functions
+ *
+ * This module provides simplified APIs for creating events.
+ * Provides multiple layers of abstraction:
+ * - Simple API: createSimpleEvent() - for local events without timezone complexity
+ * - Advanced API: createEventWithTimeZone() - for timezone-aware events
+ * - Direct API: Users can still use Temporal API directly for full control
+ */
+
+/**
+ * Event creation parameters - supports both Date and Temporal types
+ * For local events (no timezone)
+ */
+interface CreateEventParams {
+    id: string;
+    title: string;
+    description?: string;
+    start: Date | Temporal.PlainDate | Temporal.PlainDateTime;
+    end: Date | Temporal.PlainDate | Temporal.PlainDateTime;
+    allDay?: boolean;
+    calendarId?: string;
+    meta?: Record<string, any>;
+}
+/**
+ * Timezone event creation parameters
+ * For events that need explicit timezone handling
+ */
+interface CreateTimezoneEventParams {
+    id: string;
+    title: string;
+    description?: string;
+    start: Date | Temporal.ZonedDateTime;
+    end: Date | Temporal.ZonedDateTime;
+    timeZone: string;
+    calendarId?: string;
+    meta?: Record<string, any>;
+}
+/**
+ * Create local event (recommended for most use cases)
+ *
+ * Supports flexible input types:
+ * - Date objects (automatically converted)
+ * - Temporal.PlainDate (for all-day events)
+ * - Temporal.PlainDateTime (for timed events)
+ *
+ * @example
+ * // Using Date objects
+ * createEvent({
+ *   id: '1',
+ *   title: 'Team Meeting',
+ *   start: new Date(2025, 0, 15, 14, 30),
+ *   end: new Date(2025, 0, 15, 16, 0),
+ * });
+ *
+ * @example
+ * // Using Temporal.PlainDateTime
+ * createEvent({
+ *   id: '2',
+ *   title: 'Workshop',
+ *   start: Temporal.PlainDateTime.from('2025-01-15T09:00'),
+ *   end: Temporal.PlainDateTime.from('2025-01-15T17:00'),
+ * });
+ *
+ * @example
+ * // All-day event
+ * createEvent({
+ *   id: '3',
+ *   title: 'Birthday',
+ *   start: new Date(2025, 0, 15),
+ *   end: new Date(2025, 0, 15),
+ *   allDay: true,
+ * });
+ */
+declare function createEvent(params: CreateEventParams): Event;
+/**
+ * Create timezone-aware event
+ *
+ * Use this when you need explicit timezone control, such as:
+ * - International meetings across timezones
+ * - Flight schedules
+ * - Events that need to show in different timezones
+ *
+ * Supports flexible input types:
+ * - Date objects (converted using specified timezone)
+ * - Temporal.ZonedDateTime (used directly)
+ *
+ * @example
+ * // Using Date objects
+ * createTimezoneEvent({
+ *   id: '1',
+ *   title: 'International Conference',
+ *   start: new Date(2025, 0, 15, 14, 0),
+ *   end: new Date(2025, 0, 15, 16, 0),
+ *   timeZone: 'America/New_York'
+ * });
+ *
+ * @example
+ * // Using ZonedDateTime
+ * createTimezoneEvent({
+ *   id: '2',
+ *   title: 'Asia-US Sync',
+ *   start: Temporal.ZonedDateTime.from('2025-01-15T09:00[Asia/Shanghai]'),
+ *   end: Temporal.ZonedDateTime.from('2025-01-15T10:00[Asia/Shanghai]'),
+ *   timeZone: 'Asia/Shanghai', // Only used if start/end are Date objects
+ * });
+ */
+declare function createTimezoneEvent(params: CreateTimezoneEventParams): Event;
+/**
+ * Create multiple local events at once
+ */
+declare function createEvents(paramsArray: CreateEventParams[]): Event[];
+/**
+ * Create multiple timezone-aware events at once
+ */
+declare function createTimezoneEvents(paramsArray: CreateTimezoneEventParams[]): Event[];
+/**
+ * Quick create all-day event
+ */
+declare function createAllDayEvent(id: string, title: string, date: Date, options?: Omit<CreateEventParams, 'id' | 'title' | 'start' | 'end' | 'allDay'>): Event;
+/**
+ * Quick create timed event
+ */
+declare function createTimedEvent(id: string, title: string, start: Date, end: Date, options?: Omit<CreateEventParams, 'id' | 'title' | 'start' | 'end'>): Event;
+/**
+ * Convert legacy Date-based event to Temporal-based event
+ * @deprecated Use createEvent() directly with Date objects instead
+ */
+declare function convertDateEvent(id: string, title: string, startDate: Date, endDate: Date, allDay?: boolean, options?: {
+    description?: string;
+    calendarId?: string;
+    meta?: Record<string, any>;
+}): Event;
+/**
+ * Convert legacy Date-based event to timezone-aware event
+ * @deprecated Use createTimezoneEvent() directly with Date objects instead
+ */
+declare function convertDateEventWithTimeZone(id: string, title: string, startDate: Date, endDate: Date, timeZone: string, options?: {
+    description?: string;
+    calendarId?: string;
+    meta?: Record<string, any>;
+}): Event;
+
+type CalendarSearchEvent = Event & {
+    color?: string;
+    [key: string]: any;
+};
+
+/**
+ * Helper to get date object from event start
+ * @param dateInput Date, string, or Temporal object
+ * @returns Date object
+ */
+declare const getDateObj: (dateInput: any) => Date;
+/**
+ * Helper to normalize date (reset time to 00:00:00)
+ * @param date Date object
+ * @returns Normalized Date object
+ */
+declare const normalizeDate: (date: Date) => Date;
+/**
+ * Helper to get header text and color for a date group in search results
+ * @param groupDate The date of the group
+ * @param today Reference today date (normalized)
+ * @param locale Locale string
+ * @param t Translation function
+ * @returns Object with title and colorClass
+ */
+declare const getSearchHeaderInfo: (groupDate: Date, today: Date, locale: string, t: (key: any) => string) => {
+    title: string;
+    colorClass: string;
+};
+/**
+ * Helper to group search results by date
+ * @param results List of search events
+ * @param today Reference today date (normalized)
+ * @returns Array of grouped events
+ */
+declare const groupSearchResults: (results: CalendarSearchEvent[], today: Date) => Array<{
+    date: Date;
+    events: CalendarSearchEvent[];
+}>;
+
+/**
+ * ICS (iCalendar) Types
+ *
+ * Type definitions for ICS file import/export functionality.
+ * Based on RFC 5545 iCalendar specification.
+ */
+
+/**
+ * ICS VEVENT raw data structure (intermediate format after parsing)
+ */
+interface ICSVEvent {
+    /** Unique identifier */
+    uid: string;
+    /** Event summary/title */
+    summary: string;
+    /** Event description */
+    description?: string;
+    /** Start date/time in ICS format */
+    dtstart: string;
+    /** End date/time in ICS format */
+    dtend: string;
+    /** DTSTART parameters */
+    dtstartParams?: ICSDateParams;
+    /** DTEND parameters */
+    dtendParams?: ICSDateParams;
+    /** Event location */
+    location?: string;
+    /** Event categories */
+    categories?: string[];
+}
+/**
+ * ICS date/time parameters
+ */
+interface ICSDateParams {
+    /** Value type: DATE for all-day, DATE-TIME for timed events */
+    value?: 'DATE' | 'DATE-TIME';
+    /** Timezone identifier (e.g., "America/New_York") */
+    tzid?: string;
+}
+/**
+ * ICS import options
+ */
+interface ICSImportOptions {
+    /** Default calendar ID for imported events */
+    calendarId?: string;
+    /** Generate new IDs for imported events (default: true) */
+    generateNewIds?: boolean;
+    /** ID prefix for generated IDs (default: "ics-") */
+    idPrefix?: string;
+    /** Default timezone when ICS has no timezone info */
+    defaultTimeZone?: string;
+}
+/**
+ * ICS export options
+ */
+interface ICSExportOptions {
+    /** Calendar name in exported file */
+    calendarName?: string;
+    /** Product identifier */
+    productId?: string;
+    /** Include timezone information */
+    includeTimezone?: boolean;
+    /** Export filename (without extension) */
+    filename?: string;
+}
+/**
+ * ICS import result
+ */
+interface ICSImportResult {
+    /** Whether import completed without errors */
+    success: boolean;
+    /** Successfully imported events */
+    events: Event[];
+    /** Parse errors encountered */
+    errors: ICSParseError[];
+    /** Total VEVENTs found in file */
+    totalParsed: number;
+    /** Successfully imported event count */
+    totalImported: number;
+}
+/**
+ * ICS parse error
+ */
+interface ICSParseError {
+    /** Line number where error occurred */
+    line?: number;
+    /** Error message */
+    message: string;
+    /** UID of the event that failed (if available) */
+    eventUid?: string;
+}
+
+/**
+ * ICS Date Utilities
+ *
+ * Convert between ICS date formats (RFC 5545) and Temporal API types.
+ *
+ * ICS Date Formats:
+ * 1. DATE (all-day): YYYYMMDD (e.g., 20250115)
+ * 2. DATE-TIME (local): YYYYMMDDTHHMMSS (e.g., 20250115T143000)
+ * 3. DATE-TIME (UTC): YYYYMMDDTHHMMSSZ (e.g., 20250115T143000Z)
+ * 4. DATE-TIME (with TZID): DTSTART;TZID=America/New_York:20250115T143000
+ */
+
+/**
+ * Parse ICS date string to Temporal type
+ *
+ * @param dateStr - ICS date string
+ * @param params - Date parameters (VALUE, TZID)
+ * @param defaultTimeZone - Default timezone when none specified
+ * @returns Temporal.PlainDate, PlainDateTime, or ZonedDateTime
+ */
+declare function parseICSDate(dateStr: string, params?: ICSDateParams, defaultTimeZone?: string): Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+/**
+ * Format Temporal type to ICS date string
+ *
+ * @param temporal - Temporal date/time object
+ * @param allDay - Force all-day format
+ * @returns Object with value and optional params
+ */
+declare function formatICSDate(temporal: Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime, allDay?: boolean): {
+    value: string;
+    params?: Record<string, string>;
+};
+/**
+ * Format a Date to ICS timestamp (UTC format for DTSTAMP)
+ */
+declare function formatDateToICSTimestamp(date: Date): string;
+
+/**
+ * ICS Parser
+ *
+ * Parses iCalendar (.ics) format into DayFlow Event objects.
+ * Supports standard RFC 5545 VEVENT components.
+ */
+
+/**
+ * Main function to parse ICS content string
+ *
+ * @param icsContent - Raw string content of the .ics file
+ * @param options - Import options
+ * @returns Result object containing success flag, events, and errors
+ */
+declare function parseICS(icsContent: string, options?: ICSImportOptions): ICSImportResult;
+
+/**
+ * ICS Generator
+ *
+ * Generates iCalendar (.ics) files from DayFlow Event objects.
+ * Supports standard RFC 5545 components.
+ */
+
+/**
+ * Generate ICS content string from events
+ *
+ * @param events - List of DayFlow events to export
+ * @param options - Export options
+ * @returns ICS file content string
+ */
+declare function generateICS(events: Event[], options?: ICSExportOptions): string;
+/**
+ * Trigger download of ICS file (Browser only)
+ *
+ * @param events - Events to export
+ * @param options - Export options
+ */
+declare function downloadICS(events: Event[], options?: ICSExportOptions): void;
+
+/**
+ * ICS Utilities Module
+ */
+
+/**
+ * Import events from an ICS file object
+ *
+ * @param file - The File object (from input[type="file"])
+ * @param options - Import options
+ * @returns Promise resolving to import result
+ */
+declare function importICSFile(file: File, options?: ICSImportOptions): Promise<ICSImportResult>;
+
+/**
+ * Core translation function.
+ * 1. Try Intl API for standard terms.
+ * 2. Fall back to language-specific dictionary.
+ * 3. Fall back to English dictionary.
+ * 4. Fall back to the key itself.
+ */
+declare function t(key: TranslationKey, locale?: LocaleCode): string;
+
+/**
+ * Encapsulates Intl API calls for standard calendar terms.
+ */
+declare function getIntlLabel(key: 'today' | 'day' | 'week' | 'month' | 'year', locale: string): string | null;
+/**
+ * Capitalizes the first letter of a string.
+ */
+declare function capitalize(str: string): string;
+/**
+ * Get localized weekday labels (Mon, Tue, etc.)
+ */
+declare const getWeekDaysLabels: (locale: string, format?: "long" | "short" | "narrow") => string[];
+/**
+ * Get localized month labels
+ */
+declare const getMonthLabels: (locale: string, format?: "long" | "short" | "narrow" | "numeric" | "2-digit") => string[];
+
+declare const en: Locale;
+
+declare const zh: Locale;
+
+declare const ja: Locale;
+
+declare const ko: Locale;
+
+declare const fr: Locale;
+
+declare const de: Locale;
+
+declare const es: Locale;
+
+declare const LOCALES: {
+    en: Locale;
+    zh: Locale;
+    ja: Locale;
+    ko: Locale;
+    fr: Locale;
+    de: Locale;
+    es: Locale;
+};
+type SupportedLang = keyof typeof LOCALES;
+
+/**
+ * Normalizes a locale string to a supported language code.
+ * e.g., 'en-US' -> 'en', 'zh-CN' -> 'zh'
+ */
+declare function normalizeLocale(locale: string): SupportedLang;
+/**
+ * Checks if a string is a valid locale identifier.
+ */
+declare function isValidLocale(locale: string): boolean;
+
+interface LocaleContextValue {
+    locale: LocaleCode;
+    t: (key: TranslationKey, vars?: Record<string, string>) => string;
+    getWeekDaysLabels: (locale: string, format?: 'long' | 'short' | 'narrow') => string[];
+    getMonthLabels: (locale: string, format?: 'long' | 'short' | 'narrow' | 'numeric' | '2-digit') => string[];
+    isDefault?: boolean;
+}
+declare const LocaleContext: preact.Context<LocaleContextValue>;
+
+/**
+ * Hook to use the locale context in functional components.
+ */
+declare function useLocale(): LocaleContextValue;
+
+declare const createDayView: ViewFactory<DayViewConfig>;
+
+declare const createWeekView: ViewFactory<WeekViewConfig>;
+
+declare const createMonthView: ViewFactory<MonthViewConfig>;
+
+declare const createYearView: ViewFactory<YearViewConfig>;
+
+declare function createStandardViews(config?: {
+    day?: Partial<DayViewConfig>;
+    week?: Partial<WeekViewConfig>;
+    month?: Partial<MonthViewConfig>;
+}): CalendarView[];
+
+declare function createDragPlugin(config?: Partial<DragPluginConfig>): CalendarPlugin;
+
+declare function createEventsPlugin(config?: EventsPluginConfig): CalendarPlugin;
+
+export { CalendarApp, CalendarRegistry, CalendarRenderer, CustomRenderingStore, LAYOUT_CONFIG, LOCALES, LocaleContext, TIME_STEP, VIRTUAL_MONTH_SCROLL_CONFIG, ViewType, WeekDataCache, addDays, buildParseRegExp, calculateDayIndex, capitalize, conditionalTheme, convertDateEvent, convertDateEventWithTimeZone, createAllDayEvent, createDateWithHour, createDayView, createDragPlugin, createEvent, createEventWithDate, createEventWithRealDate, createEvents, createEventsPlugin, createMonthView, createStandardViews, createTemporalWithHour, createTimedEvent, createTimezoneEvent, createTimezoneEvents, createWeekView, createYearView, dateToPlainDate, dateToPlainDateTime, dateToZonedDateTime, daysBetween, daysDifference, de, downloadICS, en, es, extractHourFromDate, extractHourFromTemporal, formatDate, formatDateConsistent, formatDateToICSTimestamp, formatEventTimeRange, formatICSDate, formatMonthYear, formatTemporal, formatTime, fr, generateDayData, generateICS, generateUniKey, generateWeekData, generateWeekRange, generateWeeksData, getAllDayEventsForDay, getCurrentWeekDates, getDateByDayIndex, getDateObj, getDayIndexByDate, getEndOfDay, getEndOfTemporal, getEventBgColor, getEventEndHour, getEventTextColor, getEventsForDay, getEventsForWeek, getIntlLabel, getLineColor, getMonthLabels, getMonthYearOfWeek, getPlainDate, getSearchHeaderInfo, getSelectedBgColor, getStartOfDay, getStartOfTemporal, getTestEvents, getWeekDaysLabels, getWeekRange, getZoneId, groupSearchResults, importICSFile, isDate, isDeepEqual, isEventEqual, isEventInWeek, isMultiDayEvent, isMultiDayTemporalEvent, isPlainDate, isPlainDateTime, isSameDay, isSamePlainDate, isSameTemporal, isValidLocale, isZonedDateTime, ja, ko, mergeClasses, mergeFormatTemplate, monthNames, normalizeCssWidth, normalizeDate, normalizeLocale, normalizeToZoned, now, pad, parseICS, parseICSDate, parseTemporalString, plainDateTimeToDate, plainDateToDate, recalculateEventDays, resolveAppliedTheme, roundToTimeStep, scrollbarTakesSpace, setHourInTemporal, shortMonthNames, t, temporalToDate, themeClasses, themeCn, today, updateEventDateAndDay, updateEventWithRealDate, useLocale, weekDays, weekDaysFullName, zh, zonedDateTimeToDate };
+export type { BalanceStrategy, BaseViewProps, CalendarAppConfig, CalendarAppState, CalendarCallbacks, CalendarColors, CalendarConfig, CalendarHeaderProps, CalendarPlugin, CalendarSidebarRenderProps, CalendarType, CalendarView, CalendarsConfig, CreateCalendarDialogProps, CreateEventParams, CreateTimezoneEventParams, CustomRendering, DayData, DayViewConfig, DayViewProps, DragConfig, DragHookOptions, DragHookReturn, DragIndicatorProps, DragIndicatorRenderer, DragIntegrationProps, DragPluginConfig, DragRef, DragService, Event, EventDetailContentProps, EventDetailContentRenderer, EventDetailDialogProps, EventDetailDialogRenderer, EventDetailPanelProps, EventDetailPanelRenderer, EventDetailPosition, EventGroup, EventLayout, EventRelations, EventsPluginConfig, EventsService, ICSDateParams, ICSExportOptions, ICSImportOptions, ICSImportResult, ICSParseError, ICSVEvent, ICalendarApp, Locale, LocaleCode, LocaleContextValue, LocaleDict, LocaleMessages, MobileEventProps, MobileEventRenderer, Mode, MonthDragState, MonthEventDragState, MonthViewConfig, MonthViewProps, NestedLayer, ReadOnlyConfig, SidebarConfig, SpecialLayoutRule, SubtreeAnalysis, SupportedLang, TComponent, TNode, ThemeColors, ThemeConfig, ThemeMode, TransferOperation, TranslationKey, UnifiedDragRef, UseCalendarAppReturn, UseCalendarReturn, UseDragCommonReturn, UseDragHandlersParams, UseDragHandlersReturn, UseDragManagerReturn, UseDragStateReturn, UseMonthDragParams, UseMonthDragReturn, UseVirtualMonthScrollProps, UseVirtualMonthScrollReturn, UseVirtualScrollProps, UseVirtualScrollReturn, UseWeekDayDragParams, UseWeekDayDragReturn, ViewAdapterProps, ViewFactory, ViewFactoryConfig, VirtualItem, VirtualScrollIntegrationProps, VirtualWeekItem, WeekDayDragState, WeekViewConfig, WeekViewProps, WeeksData, YearViewConfig, YearViewProps, useDragProps, useDragReturn };