ezux 1.0.0

package/dist/components/EzScheduler/EzSchedulerToolbar.d.ts

@@ -0,0 +1,117 @@
+import { ViewType, View, ViewsModel } from './EzScheduler.types';
+/**
+ * Props for the EzSchedulerToolbar component.
+ */
+interface EzSchedulerToolbarProps {
+    /**
+     * The current date displayed in the scheduler.
+     * @group Properties
+     */
+    currentDate: Date;
+    /**
+     * Current view type (legacy support).
+     * @group Properties
+     */
+    view: ViewType;
+    /**
+     * Sets the view type (legacy support).
+     * @group Methods
+     */
+    setView: (view: ViewType) => void;
+    /**
+     * Navigates to the next period (legacy support).
+     * @group Methods
+     */
+    next: () => void;
+    /**
+     * Navigates to the previous period (legacy support).
+     * @group Methods
+     */
+    prev: () => void;
+    /**
+     * Navigates to today (legacy support).
+     * @group Methods
+     */
+    today: () => void;
+    /**
+     * Callback when the "Add" button is clicked.
+     * @group Events
+     */
+    onAddClick: () => void;
+    /**
+     * Duration of each time slot in minutes.
+     * @group Properties
+     */
+    slotDuration: number;
+    /**
+     * Sets the duration of each time slot.
+     * @group Methods
+     */
+    setSlotDuration: (duration: number) => void;
+    /**
+     * Sets the current date.
+     * @group Methods
+     */
+    setCurrentDate: (date: Date) => void;
+    /**
+     * Callback to navigate to the previous period.
+     * @group Events
+     */
+    onPrev: () => void;
+    /**
+     * Callback to navigate to the next period.
+     * @group Events
+     */
+    onNext: () => void;
+    /**
+     * Callback to navigate to today.
+     * @group Events
+     */
+    onToday: () => void;
+    /**
+     * The currently active view mode.
+     * @group Properties
+     */
+    currentView: View;
+    /**
+     * Callback when the view mode changes.
+     * @group Events
+     */
+    onViewChange: (view: View) => void;
+    /**
+     * List of available views.
+     * @group Properties
+     */
+    views: (View | ViewsModel)[];
+    /**
+     * Callback for Excel export.
+     * @group Events
+     */
+    onExportExcel?: () => void;
+    /**
+     * Callback for CSV export.
+     * @group Events
+     */
+    onExportCSV?: () => void;
+    /**
+     * Callback for ICS export.
+     * @group Events
+     */
+    /**
+     * Callback for ICS export.
+     * @group Events
+     */
+    onExportICS?: () => void;
+    /**
+     * Text direction.
+     * @group Appearance
+     */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+/**
+ * Toolbar component for the EzScheduler.
+ * Provides navigation, view switching, and action buttons.
+ * @group Subcomponents
+ */
+export declare const EzSchedulerToolbar: import('react').MemoExoticComponent<({ currentDate, next, prev, today, slotDuration, setSlotDuration, setCurrentDate, onPrev, onNext, onToday, currentView, onViewChange, views, onExportExcel, onExportCSV, onExportICS, dir }: EzSchedulerToolbarProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/EzScheduler/components/EzEventModal.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { SchedulerEvent, Resource } from '../EzScheduler.types';
+interface EzEventModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    mode: 'create' | 'edit' | 'view';
+    event?: Partial<SchedulerEvent>;
+    onSave: (event: Partial<SchedulerEvent>) => void;
+    onDelete?: (eventId: string) => void;
+    resources?: Resource[];
+    locale?: string;
+    editorTemplate?: (event: Partial<SchedulerEvent>) => React.ReactNode;
+    headerTemplate?: (event: Partial<SchedulerEvent>, mode: string) => React.ReactNode;
+    footerTemplate?: (event: Partial<SchedulerEvent>, mode: string, onSave: () => void, onClose: () => void) => React.ReactNode;
+}
+export declare const EzEventModal: React.FC<EzEventModalProps>;
+export {};

package/dist/components/EzScheduler/components/EzOverlapAlert.d.ts

@@ -0,0 +1,12 @@
+import { SchedulerEvent } from '../EzScheduler.types';
+interface EzOverlapAlertProps {
+    isOpen: boolean;
+    onClose: () => void;
+    conflicts: SchedulerEvent[];
+    onResolve?: (action: 'keep-both' | 'cancel') => void;
+}
+/**
+ * Overlap alert dialog - warns when events overlap and allowOverlap is false
+ */
+export declare const EzOverlapAlert: import('react').MemoExoticComponent<({ isOpen, onClose, conflicts, onResolve, }: EzOverlapAlertProps) => import("react/jsx-runtime").JSX.Element | null>;
+export {};

package/dist/components/EzScheduler/components/EzQuickInfoPopup.d.ts

@@ -0,0 +1,22 @@
+import { SchedulerEvent } from '../EzScheduler.types';
+interface EzQuickInfoPopupProps {
+    event: SchedulerEvent;
+    isOpen: boolean;
+    onClose: () => void;
+    onEdit?: (event: SchedulerEvent) => void;
+    onDelete?: (id: string) => void;
+    position?: {
+        x: number;
+        y: number;
+    };
+    templates?: {
+        header?: (event: SchedulerEvent) => React.ReactNode;
+        content?: (event: SchedulerEvent) => React.ReactNode;
+        footer?: (event: SchedulerEvent, onEdit: () => void, onDelete: () => void) => React.ReactNode;
+    };
+}
+/**
+ * Quick info popup component - displays event summary on hover/click
+ */
+export declare const EzQuickInfoPopup: import('react').MemoExoticComponent<({ event, isOpen, onClose, onEdit, onDelete, position, templates, }: EzQuickInfoPopupProps) => import("react/jsx-runtime").JSX.Element | null>;
+export {};

package/dist/components/EzScheduler/components/EzResourceSidebar.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+import { Resource } from '../EzScheduler.types';
+/**
+ * Props for the EzResourceSidebar component.
+ */
+interface EzResourceSidebarProps {
+    /**
+     * List of available resources.
+     * @group Properties
+     */
+    resources: Resource[];
+    /**
+     * List of selected resource IDs.
+     * @group Properties
+     */
+    selectedResourceIds: string[];
+    /**
+     * Callback when selection changes.
+     * @group Events
+     */
+    onSelectionChange: (selectedIds: string[]) => void;
+    /**
+     * Custom class name.
+     * @group Properties
+     */
+    className?: string;
+}
+/**
+ * Sidebar component for filtering resources.
+ * @group Subcomponents
+ */
+export declare const EzResourceSidebar: React.FC<EzResourceSidebarProps>;
+export {};

package/dist/components/EzScheduler/components/EzSchedulerContent.d.ts

@@ -0,0 +1,123 @@
+import { default as React } from 'react';
+import { Store } from '@tanstack/store';
+import { SchedulerState, SchedulerActions } from '../state/scheduler.store';
+import { ViewType, SchedulerEvent, Resource, EzSchedulerProps } from '../EzScheduler.types';
+/**
+ * Props for the EzSchedulerContent component.
+ */
+interface EzSchedulerContentProps {
+    /**
+     * The scheduler state store.
+     * @group Properties
+     */
+    store: Store<SchedulerState>;
+    /**
+     * Actions for state mutation.
+     * @group Methods
+     */
+    actions: SchedulerActions;
+    /**
+     * The currently active view type.
+     * @group Properties
+     */
+    view: ViewType | string;
+    /**
+     * List of days to display in the current view.
+     * @group Properties
+     */
+    daysInView: Date[];
+    /**
+     * List of events to display.
+     * @group Properties
+     */
+    visibleEvents: SchedulerEvent[];
+    /**
+     * Virtualizer for row rendering.
+     * @group Properties
+     */
+    rowVirtualizer: any;
+    /**
+     * List of resources to display.
+     * @group Properties
+     */
+    resources: Resource[];
+    /**
+     * Callback for slot double-click.
+     * @group Events
+     */
+    handleSlotDoubleClick: (date: Date, resourceId?: string) => void;
+    /**
+     * Callback for event double-click.
+     * @group Events
+     */
+    handleEventDoubleClick: (event: SchedulerEvent) => void;
+    /**
+     * Callback for event deletion.
+     * @group Events
+     */
+    handleEventDelete: (eventId: string) => void;
+    /**
+     * Reference to the scroll container.
+     * @group Properties
+     */
+    parentRef: React.RefObject<HTMLDivElement | null>;
+    /**
+     * Callback to change the view.
+     * @group Methods
+     */
+    setView: (view: ViewType) => void;
+    /**
+     * Callback to change the current date.
+     * @group Methods
+     */
+    setCurrentDate: (date: Date) => void;
+    /**
+     * The original props passed to EzScheduler.
+     * @group Properties
+     */
+    props: EzSchedulerProps;
+    /**
+     * Callback for range selection.
+     * @group Events
+     */
+    handleRangeSelect: (start: Date, end: Date, resourceId?: string, position?: {
+        x: number;
+        y: number;
+    }) => void;
+    /**
+     * The currently displayed date.
+     * @group Properties
+     */
+    currentDate: Date;
+    /**
+     * Whether to show an unassigned lane.
+     * @group Properties
+     */
+    showUnassignedLane?: boolean;
+    /**
+     * Duration of a time slot in minutes.
+     * @group Properties
+     */
+    slotDuration: number;
+    /**
+     * Whether to use 24-hour time format.
+     * @group Properties
+     */
+    is24Hour: boolean;
+    /**
+     * Callback to toggle 24-hour format.
+     * @group Methods
+     */
+    setIs24Hour: (is24: boolean) => void;
+    /**
+     * Text direction.
+     * @group Appearance
+     */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+/**
+ * Layout manager that switches between different scheduler views based on the active view type.
+ * @group Subcomponents
+ */
+export declare function EzSchedulerContent({ view, daysInView, visibleEvents, rowVirtualizer, resources, handleSlotDoubleClick, handleEventDoubleClick, handleEventDelete, parentRef, setView, setCurrentDate, props, handleRangeSelect, currentDate, showUnassignedLane, slotDuration, is24Hour, setIs24Hour, dir }: EzSchedulerContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EzScheduler/components/EzSchedulerQuickAdd.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { SchedulerEvent, Resource } from '../EzScheduler.types';
+interface EzSchedulerQuickAddProps {
+    start: Date;
+    end: Date;
+    resourceId?: string;
+    resources?: Resource[];
+    onSave: (event: Partial<SchedulerEvent>) => void;
+    onCancel: () => void;
+    onMoreOptions: (event: Partial<SchedulerEvent>) => void;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare const EzSchedulerQuickAdd: React.FC<EzSchedulerQuickAddProps>;
+export {};

package/dist/components/EzScheduler/components/RecurrenceEditor.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface RecurrenceEditorProps {
+    value?: string;
+    onChange: (rrule: string) => void;
+    startDate?: Date;
+}
+export declare const RecurrenceEditor: React.FC<RecurrenceEditorProps>;

package/dist/components/EzScheduler/components/SchedulerLoadingSpinner.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const SchedulerLoadingSpinner: React.FC;

package/dist/components/EzScheduler/components/dnd/DraggableEvent.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { SchedulerEvent, EzSchedulerComponents } from '../../EzScheduler.types';
+interface DraggableEventProps {
+    event: SchedulerEvent;
+    style?: React.CSSProperties;
+    components?: EzSchedulerComponents;
+    onClick?: (event: SchedulerEvent) => void;
+    onDoubleClick?: (event: SchedulerEvent) => void;
+    onDelete?: (eventId: string) => void;
+    orientation?: 'vertical' | 'horizontal';
+    resizable?: boolean;
+    className?: string;
+    showTime?: boolean;
+    isBlocked?: boolean;
+    isPast?: boolean;
+    isHighlighted?: boolean;
+    slotDuration?: number;
+    pixelsPerSlot?: number;
+}
+export declare const DraggableEvent: ({ event, style, onClick, onDoubleClick, onDelete, orientation, resizable, className, showTime, isBlocked, isPast, isHighlighted, slotDuration, pixelsPerSlot }: DraggableEventProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EzScheduler/components/dnd/DroppableSlot.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+interface DroppableSlotProps {
+    date: Date;
+    resourceId?: string;
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: () => void;
+    onDoubleClick?: () => void;
+    onMouseDown?: () => void;
+    onMouseEnter?: () => void;
+    onContextMenu?: (e: React.MouseEvent) => void;
+    data?: any;
+    isSelected?: boolean;
+    isWorkHour?: boolean;
+    width?: number;
+}
+export declare const DroppableSlot: ({ date, resourceId, children, className, style, onClick, onDoubleClick, onMouseDown, onMouseEnter, onContextMenu, data, isSelected, isWorkHour }: DroppableSlotProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EzScheduler/hooks/useRecurrence.d.ts

@@ -0,0 +1,2 @@
+import { SchedulerEvent } from '../EzScheduler.types';
+export declare const useRecurrence: (events: SchedulerEvent[], rangeStart: Date, rangeEnd: Date) => SchedulerEvent[];

package/dist/components/EzScheduler/hooks/useSchedulerEventHandlers.d.ts

@@ -0,0 +1,11 @@
+import { SchedulerEvent } from '../EzScheduler.types';
+interface UseSchedulerEventHandlersProps {
+    events: SchedulerEvent[];
+    onEventChange?: (updatedEvent: SchedulerEvent) => void;
+    slotDuration?: number;
+}
+export declare const useSchedulerEventHandlers: ({ events, onEventChange, slotDuration }: UseSchedulerEventHandlersProps) => {
+    sensors: import('@dnd-kit/core').SensorDescriptor<import('@dnd-kit/core').SensorOptions>[];
+    handleDragEnd: (event: any) => void;
+};
+export {};

package/dist/components/EzScheduler/hooks/useSchedulerEvents.d.ts

@@ -0,0 +1,26 @@
+import { EzSchedulerProps, ViewType, SchedulerEvent } from '../EzScheduler.types';
+import { SchedulerService } from '../services/SchedulerService';
+/**
+ * Handles event management, recurrence expansion, and view filtering
+ * Uses SchedulerService (Singleton/MockDB) and TanStack Query with Standardized Optimistic Updates
+ */
+export declare const useSchedulerEvents: (props: EzSchedulerProps, view: ViewType, currentDate: Date) => {
+    schedulerService: SchedulerService;
+    recurrenceEngine: any;
+    daysInView: Date[];
+    visibleEvents: any;
+    allEvents: SchedulerEvent[];
+    addEvent: import('@tanstack/react-query').UseMutateAsyncFunction<SchedulerEvent, Error, Partial<SchedulerEvent>, {
+        previousEvents: unknown;
+        queryKey: string[];
+    }>;
+    updateEvent: import('@tanstack/react-query').UseMutateAsyncFunction<SchedulerEvent, Error, SchedulerEvent, {
+        previousEvents: unknown;
+        queryKey: string[];
+    }>;
+    deleteEvent: import('@tanstack/react-query').UseMutateAsyncFunction<string | number, Error, string | number, {
+        previousEvents: unknown;
+        queryKey: string[];
+    }>;
+    isUpdating: boolean;
+};

package/dist/components/EzScheduler/hooks/useSchedulerImperative.d.ts

@@ -0,0 +1,15 @@
+import { ViewType, View, SchedulerEvent, Resource, EzSchedulerRef } from '../EzScheduler.types';
+import { SchedulerService } from '../services/SchedulerService';
+export declare const useSchedulerImperative: (view: ViewType, currentDate: Date, schedulerService: SchedulerService, visibleEvents: SchedulerEvent[], methods: {
+    setEditorState: (state: any) => void;
+    setResources: (res: Resource[] | ((prev: Resource[]) => Resource[])) => void;
+    scrollToIndex: (index: number) => void;
+    forceUpdate: () => void;
+    showSpinner: () => void;
+    hideSpinner: () => void;
+    closeQuickInfoPopup: () => void;
+    changeView: (view: View) => void;
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+}, ref: React.Ref<EzSchedulerRef>, extraApi?: any) => void;

package/dist/components/EzScheduler/hooks/useSchedulerNavigation.d.ts

@@ -0,0 +1,9 @@
+import { ViewType } from '../EzScheduler.types';
+/**
+ * Encapsulates navigation arithmetic for the scheduler
+ */
+export declare const useSchedulerNavigation: (currentDate: Date, setCurrentDate: (date: Date) => void, view: ViewType, onDateChange?: (date: Date) => void) => {
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+};

package/dist/components/EzScheduler/hooks/useSchedulerResources.d.ts

@@ -0,0 +1,10 @@
+import { Resource, ResourceModel } from '../EzScheduler.types';
+interface UseSchedulerResourcesProps {
+    resources: Resource[] | ResourceModel[] | undefined;
+}
+export declare const useSchedulerResources: ({ resources }: UseSchedulerResourcesProps) => {
+    resources: Resource[];
+    internalResources: Resource[];
+    setInternalResources: import('react').Dispatch<import('react').SetStateAction<Resource[]>>;
+};
+export {};

package/dist/components/EzScheduler/hooks/useSchedulerState.d.ts

@@ -0,0 +1,14 @@
+import { EzSchedulerProps, ViewType } from '../EzScheduler.types';
+/**
+ * Manages the core navigation and view state for EzScheduler
+ */
+export declare const useSchedulerState: (props: EzSchedulerProps) => {
+    view: ViewType;
+    setView: (newView: ViewType) => void;
+    currentDate: Date;
+    setCurrentDate: (newDate: Date) => void;
+    slotDuration: number;
+    setSlotDuration: (duration: number) => void;
+    is24Hour: boolean;
+    setIs24Hour: (is24: boolean) => void;
+};

package/dist/components/EzScheduler/hooks/useSchedulerVirtualization.d.ts

@@ -0,0 +1,9 @@
+import { EzSchedulerProps } from '../EzScheduler.types';
+/**
+ * Manages virtualization for the scheduler time axis
+ */
+export declare const useSchedulerVirtualization: (props: EzSchedulerProps) => {
+    parentRef: import('react').RefObject<HTMLDivElement | null>;
+    rowVirtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element>;
+    columnVirtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element> | undefined;
+};

package/dist/components/EzScheduler/index.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { EzSchedulerProps, EzSchedulerRef } from './EzScheduler.types';
+/**
+ * EzScheduler is a comprehensive event management and resource scheduling engine.
+ * It provides a fluid user experience for managing complex schedules across
+ * various view modes with full drag-and-drop and resizing support.
+ *
+
+ * ### Key Features
+ * - **Multi-View System**: Switch between Day, Week, Work Week, Month, and various Timeline views.
+ * - **Resource Management**: Group events by resources (people, rooms, equipment) with dedicated lanes.
+ * - **Interactive Editing**: Intuitive drag-and-drop event movement, resizing, and double-click creation.
+ * - **Intelligent Overlap**: Customizable overlap detection and blocking for intervals like lunch breaks.
+ * - **Quick Info & Editor**: Built-in popovers for quick summaries and a full modal for detailed editing.
+ * - **Virtualization**: Efficient rendering of large resource lists and event densities.
+ *
+ * ### Minimal Example
+ * ```tsx
+ * <EzScheduler
+ *   events={myEvents}
+ *   view="Week"
+ *   onEventChange={(event) => updateEvent(event)}
+ * />
+ * ```
+ *
+ * ### Resource Grouping Example
+ * ```tsx
+ * <EzScheduler
+ *   resources={[
+ *     { id: '1', name: 'Meeting Room A', color: '#e11d48' },
+ *     { id: '2', name: 'Meeting Room B', color: '#2563eb' }
+ *   ]}
+ *   events={events}
+ *   view="TimelineDay"
+ *   onEventCreate={(event) => createNewMeeting(event)}
+ * />
+ * ```
+ *
+ * @group Core Components
+ */
+export declare const EzScheduler: React.ForwardRefExoticComponent<EzSchedulerProps & React.RefAttributes<EzSchedulerRef>>;

package/dist/components/EzScheduler/models/EventSettings.d.ts

@@ -0,0 +1,11 @@
+import { EventSettingsModel, FieldModel, EventData } from '../EzScheduler.types';
+export declare class EventSettings implements EventSettingsModel {
+    dataSource: Object[] | any;
+    fields: FieldModel;
+    allowAdding: boolean;
+    allowDeleting: boolean;
+    allowEditing: boolean;
+    enableTooltip: boolean;
+    template?: string | ((data: EventData) => React.ReactNode);
+    constructor(settings: Partial<EventSettingsModel>);
+}

package/dist/components/EzScheduler/models/View.d.ts

@@ -0,0 +1,49 @@
+import { View, ViewsModel, ViewType } from '../EzScheduler.types';
+/**
+ * Implementation model for scheduler view configuration.
+ * @group Models
+ */
+export declare class ViewModel implements ViewsModel {
+    /**
+     * The view mode.
+     * @group Properties
+     */
+    option: View;
+    /**
+     * Whether virtual scrolling is enabled.
+     * @group Properties
+     */
+    allowVirtualScrolling: boolean;
+    /**
+     * Display name for the view.
+     * @group Properties
+     */
+    displayName?: string;
+    /**
+     * Start hour for the view.
+     * @group Properties
+     */
+    startHour?: string;
+    /**
+     * End hour for the view.
+     * @group Properties
+     */
+    endHour?: string;
+    /**
+     * Time interval in minutes.
+     * @group Properties
+     */
+    interval?: number;
+    /**
+     * Whether to show weekends.
+     * @group Properties
+     */
+    showWeekend?: boolean;
+    /**
+     * Whether this view is currently selected.
+     * @group Properties
+     */
+    isSelected?: boolean;
+    constructor(view: View | ViewsModel);
+    static normalize(view: View | ViewsModel | ViewType): ViewModel;
+}

package/dist/components/EzScheduler/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EventSettings';
+export * from './View';

package/dist/components/EzScheduler/services/AttendeeService.d.ts

@@ -0,0 +1,15 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { Attendee } from '../EzScheduler.types';
+export declare class AttendeeService implements IService {
+    name: string;
+    constructor();
+    /**
+     * Validates attendee email format
+     */
+    isValidEmail(email: string): boolean;
+    /**
+     * Format status for display
+     */
+    getStatusLabel(status: Attendee['status']): string;
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/AuditService.d.ts

@@ -0,0 +1,15 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+export interface AuditLog {
+    timestamp: Date;
+    action: string;
+    userId: string;
+    details: any;
+    tenantId?: string;
+}
+export declare class AuditService implements IService {
+    name: string;
+    private logs;
+    log(action: string, userId: string, details: any, tenantId?: string): void;
+    getLogs(): AuditLog[];
+    cleanup(): void;
+}

package/dist/components/EzScheduler/services/CollisionDetectionService.d.ts

@@ -0,0 +1,19 @@
+import { IService } from '../../../shared/services/ServiceRegistry';
+import { SchedulerEvent } from '../EzScheduler.types';
+export declare class CollisionDetectionService implements IService {
+    name: string;
+    /**
+     * Checks if a new event overlaps with any existing events.
+     * @param event The event to check.
+     * @param events List of existing events.
+     * @returns True if overlap is found, otherwise false.
+     */
+    hasOverlap(event: SchedulerEvent, events: SchedulerEvent[]): boolean;
+    /**
+     * Groups events that overlap to determine rendering columns/positions.
+     * @param events Sorted list of events.
+     * @returns Array of event groups (arrays).
+     */
+    groupOverlappingEvents(events: SchedulerEvent[]): SchedulerEvent[][];
+    cleanup(): void;
+}