@primeui/scheduler-core 0.0.1-alpha.1

package/dist/event/index.d.mts

@@ -0,0 +1,267 @@
+export { P as ParsedEvent, e as eventMatchesResource, a as eventsOverlap, f as filterEventsByDateRange, b as filterEventsForDay, g as getEventColor, c as getEventEnd, d as getEventEndMinutes, h as getEventStart, i as getEventStartMinutes, j as getEventTextColor, k as getEventsForCell, l as getEventsForDayAndResource, m as getOverflowCountForCell, n as getTimedEventsForDayAndResource, o as getVisibleEventsForCell, p as isEventEndOnDate, q as isEventStartOnDate, r as moveEventTo, s as parseEvent, t as parseEventDate, u as parseEvents, v as resizeEventBy, w as sortEvents, x as sortEventsForCell } from '../event.utils-QSNdd-3W.mjs';
+import { SchedulerEvent, DateRange, EventCategory, RRuleOptions, RRuleFrequency, RRuleWeekday, RecurringEvent, ExpandedEvent, RecurringEventSeries, RecurrenceEditOptions, RecurrenceException, RecurrenceDeleteScope, RecurrenceEditScope, RecurrenceDeleteSource, RecurrenceEditSource } from '@primeui/scheduler-types/scheduler';
+export { E as EventGroup, M as MonthEventPosition, P as PositionedEvent, a as PositioningOptions, W as WeekRowEventData, c as calculateEventPosition, g as getAllDayEventsForDay, b as getTimedEventsForDay, p as positionAllDayEventsForWeek, d as positionEventsForDay, e as positionEventsForWeekRow } from '../event.positioning-BdzAVPk7.mjs';
+import { SchedulerResource } from '@primeui/scheduler-types/resource';
+import { a as SchedulerEventSurfaceContext } from '../event-surface-_R_LHD95.mjs';
+import { S as SchedulerCalendarDisplayConfigInput, c as SchedulerCalendarDisplayConfig } from '../display-format-CLVvRt4I.mjs';
+
+declare function upsertEventById(eventList: SchedulerEvent[], event: SchedulerEvent): SchedulerEvent[];
+declare function removeEventById(eventList: SchedulerEvent[], eventId: string | number): SchedulerEvent[];
+
+interface SchedulerEventPipelineInput {
+    events: SchedulerEvent[];
+    dateRange: DateRange;
+    categories?: EventCategory[];
+    categoryField?: string;
+    categoryAutoTextColor?: boolean;
+    eventShell?: 'default' | 'none';
+    activeCategoryIds?: (string | number)[];
+    resources?: SchedulerResource[];
+    schedulerTimezone?: string;
+    resolvedDisplayTimezone?: string;
+}
+interface SchedulerEventPipelineResult {
+    rawEvents: SchedulerEvent[];
+    expandedEvents: SchedulerEvent[];
+    categoryFilteredEvents: SchedulerEvent[];
+    displayTimezoneEvents: SchedulerEvent[];
+    categoryCounts: Record<string | number, number>;
+    eventSurfaceContext: SchedulerEventSurfaceContext;
+    eventSurfaceColors: Map<string | number, string | undefined>;
+}
+type SchedulerEventPipelineMemoizedBuilder = (input: SchedulerEventPipelineInput) => SchedulerEventPipelineResult;
+declare function normalizeSchedulerEventToDisplayTimezone(event: SchedulerEvent, schedulerTimezone: string | undefined, displayTimezone: string): SchedulerEvent;
+declare function normalizeSchedulerEventsToDisplayTimezone(events: SchedulerEvent[], schedulerTimezone: string | undefined, resolvedDisplayTimezone: string | undefined): SchedulerEvent[];
+declare function buildSchedulerEventPipeline(input: SchedulerEventPipelineInput): SchedulerEventPipelineResult;
+declare function createSchedulerEventPipelineMemo(): SchedulerEventPipelineMemoizedBuilder;
+
+/**
+ * RRULE - RFC 5545 compliant recurrence rule implementation
+ *
+ * This module provides parsing, serialization, and expansion of recurrence rules
+ * following the iCalendar standard (RFC 5545).
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc5545#section-3.3.10
+ */
+
+interface SchedulerRecurrenceDisplayOptions extends SchedulerCalendarDisplayConfigInput {
+    calendarDisplayConfig?: SchedulerCalendarDisplayConfigInput | SchedulerCalendarDisplayConfig;
+}
+declare function parseRRule(rruleString: string): RRuleOptions | null;
+declare function serializeRRule(options: RRuleOptions): string;
+declare function expandRRule(event: RecurringEvent, rangeStart: Date, rangeEnd: Date, maxOccurrences?: number): ExpandedEvent[];
+declare function expandRecurringSeries(series: RecurringEventSeries, rangeStart: Date, rangeEnd: Date, maxOccurrences?: number): ExpandedEvent[];
+declare function createRRule(options: Partial<RRuleOptions> & {
+    freq: RRuleFrequency;
+}): RRuleOptions;
+declare function daily(interval?: number): RRuleOptions;
+declare function weekly(interval?: number, weekdays?: RRuleWeekday[]): RRuleOptions;
+declare function monthly(interval?: number, options?: {
+    bymonthday?: number[];
+    byday?: string[];
+}): RRuleOptions;
+declare function yearly(interval?: number, options?: {
+    bymonth?: number[];
+    bymonthday?: number[];
+}): RRuleOptions;
+declare function weekdays(): RRuleOptions;
+declare function everyNthWeekday(n: number, weekday: RRuleWeekday): RRuleOptions;
+declare function lastWeekdayOfMonth(weekday: RRuleWeekday): RRuleOptions;
+declare function describeRRule(rrule: RRuleOptions | string, localeOrOptions?: string | SchedulerRecurrenceDisplayOptions, displayOptions?: SchedulerRecurrenceDisplayOptions): string;
+
+/**
+ * Advanced Recurring Event Editing - RFC 5545 compliant
+ *
+ * This module handles editing and deleting recurring event instances
+ * with support for "this", "all", and "this & future" edit scopes.
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc5545
+ */
+
+declare const DEFAULT_RECURRENCE_EDIT_OPTIONS: RecurrenceEditOptions;
+declare function normalizeRecurrenceEditOptions(options: boolean | Partial<RecurrenceEditOptions> | undefined): RecurrenceEditOptions;
+interface EditThisOnlyResult {
+    series: RecurringEventSeries;
+    exception: RecurrenceException;
+}
+declare function editThisOnly(series: RecurringEventSeries, occurrence: ExpandedEvent, changes: Partial<RecurringEvent>): EditThisOnlyResult;
+interface EditAllResult {
+    series: RecurringEventSeries;
+}
+declare function editAll(series: RecurringEventSeries, changes: Partial<RecurringEvent>): EditAllResult;
+interface EditFutureResult {
+    originalSeries: RecurringEventSeries;
+    newSeries: RecurringEventSeries;
+}
+declare function editThisAndFuture(series: RecurringEventSeries, occurrence: ExpandedEvent, changes: Partial<RecurringEvent>): EditFutureResult;
+interface DeleteThisOnlyResult {
+    series: RecurringEventSeries;
+}
+declare function deleteThisOnly(series: RecurringEventSeries, occurrence: ExpandedEvent): DeleteThisOnlyResult;
+interface DeleteAllResult {
+    deleted: true;
+}
+declare function deleteAll(): DeleteAllResult;
+interface DeleteFutureResult {
+    series: RecurringEventSeries | null;
+}
+declare function deleteThisAndFuture(series: RecurringEventSeries, occurrence: ExpandedEvent): DeleteFutureResult;
+declare function applyRecurrenceEdit(series: RecurringEventSeries, occurrence: ExpandedEvent, changes: Partial<RecurringEvent>, scope: RecurrenceEditScope): {
+    series: RecurringEventSeries;
+    newSeries?: RecurringEventSeries;
+};
+declare function applyRecurrenceDelete(series: RecurringEventSeries, occurrence: ExpandedEvent, scope: RecurrenceDeleteScope): {
+    series: RecurringEventSeries | null;
+    deleted?: boolean;
+};
+declare function addRDate(series: RecurringEventSeries, date: Date | string): RecurringEventSeries;
+declare function removeRDate(series: RecurringEventSeries, date: Date | string): RecurringEventSeries;
+declare function addException(series: RecurringEventSeries, exception: RecurrenceException): RecurringEventSeries;
+declare function removeException(series: RecurringEventSeries, originalStart: Date | string): RecurringEventSeries;
+declare function getExceptionForDate(series: RecurringEventSeries, date: Date | string): RecurrenceException | undefined;
+declare function hasExceptionForDate(series: RecurringEventSeries, date: Date | string): boolean;
+declare function isOccurrenceExcluded(series: RecurringEventSeries, date: Date | string): boolean;
+declare function getRecurrenceDescription(scope: RecurrenceEditScope): string;
+declare function getDeleteDescription(scope: RecurrenceDeleteScope): string;
+declare function isRecurringSeries(event: RecurringEventSeries | RecurringEvent): event is RecurringEventSeries;
+declare function convertToSeries(event: RecurringEvent): RecurringEventSeries | null;
+declare function serializeSeries(series: RecurringEventSeries): string;
+declare function parseICalDate(dateStr: string): Date;
+declare function parseExDates(exdateStr: string): Date[];
+declare function parseRDates(rdateStr: string): Date[];
+
+type RecurrenceRuntimeAction = 'edit' | 'drag' | 'resize';
+interface RecurrenceResolvedContext {
+    series: RecurringEventSeries;
+    occurrence: ExpandedEvent;
+}
+interface RecurrenceEditApplyState {
+    handled: boolean;
+    canceled?: boolean;
+    scope?: RecurrenceEditScope;
+    context?: RecurrenceResolvedContext;
+    result?: {
+        series: RecurringEventSeries;
+        newSeries?: RecurringEventSeries;
+    };
+}
+interface RecurrenceDeleteApplyState {
+    handled: boolean;
+    canceled?: boolean;
+    scope?: RecurrenceDeleteScope;
+    context?: RecurrenceResolvedContext;
+    result?: {
+        series: RecurringEventSeries | null;
+        deleted?: boolean;
+    };
+}
+interface RecurrenceEditScopeSelectionRequest {
+    action: RecurrenceRuntimeAction;
+    modes: RecurrenceEditScope[];
+    fallback: RecurrenceEditScope;
+}
+interface RecurrenceDeleteScopeSelectionRequest {
+    modes: RecurrenceDeleteScope[];
+    fallback: RecurrenceDeleteScope;
+}
+type RecurrenceEditScopeSelector = (request: RecurrenceEditScopeSelectionRequest) => RecurrenceEditScope | null;
+type RecurrenceDeleteScopeSelector = (request: RecurrenceDeleteScopeSelectionRequest) => RecurrenceDeleteScope | null;
+interface ApplyRecurringEditChangeInput {
+    action: RecurrenceRuntimeAction;
+    event: SchedulerEvent;
+    changes: Partial<RecurringEvent>;
+    editOptions: RecurrenceEditOptions;
+    baseEvents: SchedulerEvent[];
+    scopeSelector?: RecurrenceEditScopeSelector;
+    durationFallbackMinutes?: number;
+}
+interface ApplyRecurringDeleteChangeInput {
+    event: SchedulerEvent;
+    editOptions: RecurrenceEditOptions;
+    baseEvents: SchedulerEvent[];
+    scopeSelector?: RecurrenceDeleteScopeSelector;
+    durationFallbackMinutes?: number;
+}
+declare function resolveSeriesIdFromOccurrence(event: SchedulerEvent): string | number | null;
+declare function isRecurringOccurrenceEvent(event: SchedulerEvent): boolean;
+declare function resolveRecurringContext(event: SchedulerEvent, baseEvents: SchedulerEvent[], durationFallbackMinutes?: number): RecurrenceResolvedContext | null;
+declare function resolveDefaultEditScope(modes: RecurrenceEditScope[]): RecurrenceEditScope | null;
+declare function resolveDefaultDeleteScope(modes: RecurrenceDeleteScope[]): RecurrenceDeleteScope | null;
+declare function resolveRecurrenceEditScope(action: RecurrenceRuntimeAction, options: Pick<RecurrenceEditOptions, 'editModes' | 'dragMode' | 'resizeMode'>, scopeSelector?: RecurrenceEditScopeSelector): RecurrenceEditScope | null;
+declare function resolveRecurrenceDeleteScope(options: Pick<RecurrenceEditOptions, 'deleteModes'>, scopeSelector?: RecurrenceDeleteScopeSelector): RecurrenceDeleteScope | null;
+declare function applyRecurringEditChange(input: ApplyRecurringEditChangeInput): RecurrenceEditApplyState;
+declare function applyRecurringDeleteChange(input: ApplyRecurringDeleteChangeInput): RecurrenceDeleteApplyState;
+
+interface RecurrenceEditEmitPayload {
+    source: RecurrenceEditSource;
+    scope: RecurrenceEditScope;
+    occurrence: ExpandedEvent;
+    series: RecurringEventSeries;
+    changes: Partial<RecurringEvent>;
+    result: {
+        series: RecurringEventSeries;
+        newSeries?: RecurringEventSeries;
+    };
+}
+interface RecurrenceDeleteEmitPayload {
+    source: RecurrenceDeleteSource;
+    scope: RecurrenceDeleteScope;
+    occurrence: ExpandedEvent;
+    series: RecurringEventSeries;
+    result: {
+        series: RecurringEventSeries | null;
+        deleted?: boolean;
+    };
+}
+interface RecurrenceEditEmitInstruction {
+    recurrenceEdit: RecurrenceEditEmitPayload;
+    eventChange: {
+        event: SchedulerEvent;
+        oldEvent: SchedulerEvent;
+    };
+    eventAdd?: SchedulerEvent;
+}
+interface RecurrenceDeleteEmitInstruction {
+    recurrenceDelete: RecurrenceDeleteEmitPayload;
+    eventChange?: {
+        event: SchedulerEvent;
+        oldEvent: SchedulerEvent;
+    };
+    eventRemove?: {
+        event: SchedulerEvent;
+    };
+}
+interface RecurrenceEditWorkflowResult extends RecurrenceEditApplyState {
+    emits?: RecurrenceEditEmitInstruction;
+}
+interface RecurrenceDeleteWorkflowResult extends RecurrenceDeleteApplyState {
+    emits?: RecurrenceDeleteEmitInstruction;
+}
+interface RecurrenceContextResolution {
+    resolved: boolean;
+    canceled?: boolean;
+    scope?: RecurrenceEditScope;
+    context?: RecurrenceResolvedContext;
+}
+interface ProcessRecurrenceEditInput extends ApplyRecurringEditChangeInput {
+    source: RecurrenceEditSource;
+}
+interface ProcessRecurrenceDeleteInput extends ApplyRecurringDeleteChangeInput {
+    source: RecurrenceDeleteSource;
+}
+interface ResolveRecurrenceEditContextInput {
+    event: SchedulerEvent;
+    baseEvents: SchedulerEvent[];
+    editOptions: RecurrenceEditOptions;
+    scopeSelector?: RecurrenceEditScopeSelector;
+    durationFallbackMinutes?: number;
+}
+declare function processRecurrenceEdit(input: ProcessRecurrenceEditInput): RecurrenceEditWorkflowResult;
+declare function processRecurrenceDelete(input: ProcessRecurrenceDeleteInput): RecurrenceDeleteWorkflowResult;
+declare function resolveRecurrenceEditContext(input: ResolveRecurrenceEditContextInput): RecurrenceContextResolution;
+declare function getRecurrenceEditScopeMessage(action: RecurrenceRuntimeAction): string;
+declare function getRecurrenceDeleteScopeMessage(): string;
+declare function getEditScopeLabel(scope: RecurrenceEditScope, index: number): string;
+declare function getDeleteScopeLabel(scope: RecurrenceDeleteScope, index: number): string;
+
+export { type ApplyRecurringDeleteChangeInput, type ApplyRecurringEditChangeInput, DEFAULT_RECURRENCE_EDIT_OPTIONS, type DeleteAllResult, type DeleteFutureResult, type DeleteThisOnlyResult, type EditAllResult, type EditFutureResult, type EditThisOnlyResult, type ProcessRecurrenceDeleteInput, type ProcessRecurrenceEditInput, type RecurrenceContextResolution, type RecurrenceDeleteApplyState, type RecurrenceDeleteEmitInstruction, type RecurrenceDeleteEmitPayload, type RecurrenceDeleteScopeSelectionRequest, type RecurrenceDeleteScopeSelector, type RecurrenceDeleteWorkflowResult, type RecurrenceEditApplyState, type RecurrenceEditEmitInstruction, type RecurrenceEditEmitPayload, type RecurrenceEditScopeSelectionRequest, type RecurrenceEditScopeSelector, type RecurrenceEditWorkflowResult, type RecurrenceResolvedContext, type RecurrenceRuntimeAction, type ResolveRecurrenceEditContextInput, type SchedulerEventPipelineInput, type SchedulerEventPipelineMemoizedBuilder, type SchedulerEventPipelineResult, type SchedulerRecurrenceDisplayOptions, addException, addRDate, applyRecurrenceDelete, applyRecurrenceEdit, applyRecurringDeleteChange, applyRecurringEditChange, buildSchedulerEventPipeline, convertToSeries, createRRule, createSchedulerEventPipelineMemo, daily, deleteAll, deleteThisAndFuture, deleteThisOnly, describeRRule, editAll, editThisAndFuture, editThisOnly, everyNthWeekday, expandRRule, expandRecurringSeries, getDeleteDescription, getDeleteScopeLabel, getEditScopeLabel, getExceptionForDate, getRecurrenceDeleteScopeMessage, getRecurrenceDescription, getRecurrenceEditScopeMessage, hasExceptionForDate, isOccurrenceExcluded, isRecurringOccurrenceEvent, isRecurringSeries, lastWeekdayOfMonth, monthly, normalizeRecurrenceEditOptions, normalizeSchedulerEventToDisplayTimezone, normalizeSchedulerEventsToDisplayTimezone, parseExDates, parseICalDate, parseRDates, parseRRule, processRecurrenceDelete, processRecurrenceEdit, removeEventById, removeException, removeRDate, resolveDefaultDeleteScope, resolveDefaultEditScope, resolveRecurrenceDeleteScope, resolveRecurrenceEditContext, resolveRecurrenceEditScope, resolveRecurringContext, resolveSeriesIdFromOccurrence, serializeRRule, serializeSeries, upsertEventById, weekdays, weekly, yearly };

package/dist/event/index.mjs

@@ -0,0 +1,8 @@
+export { DEFAULT_RECURRENCE_EDIT_OPTIONS, addException, addRDate, applyRecurrenceDelete, applyRecurrenceEdit, applyRecurringDeleteChange, applyRecurringEditChange, buildSchedulerEventPipeline, calculateEventPosition, convertToSeries, createSchedulerEventPipelineMemo, deleteAll, deleteThisAndFuture, deleteThisOnly, editAll, editThisAndFuture, editThisOnly, getAllDayEventsForDay, getDeleteDescription, getDeleteScopeLabel, getEditScopeLabel, getExceptionForDate, getRecurrenceDeleteScopeMessage, getRecurrenceDescription, getRecurrenceEditScopeMessage, getTimedEventsForDay, hasExceptionForDate, isOccurrenceExcluded, isRecurringOccurrenceEvent, isRecurringSeries, normalizeRecurrenceEditOptions, normalizeSchedulerEventToDisplayTimezone, normalizeSchedulerEventsToDisplayTimezone, parseExDates, parseICalDate, parseRDates, positionAllDayEventsForWeek, positionEventsForDay, positionEventsForWeekRow, processRecurrenceDelete, processRecurrenceEdit, removeEventById, removeException, removeRDate, resolveDefaultDeleteScope, resolveDefaultEditScope, resolveRecurrenceDeleteScope, resolveRecurrenceEditContext, resolveRecurrenceEditScope, resolveRecurringContext, resolveSeriesIdFromOccurrence, serializeSeries, upsertEventById } from '../chunk-6VYWVIGM.mjs';
+export { eventMatchesResource, eventsOverlap, filterEventsByDateRange, filterEventsForDay, getEventColor, getEventEnd, getEventEndMinutes, getEventStart, getEventStartMinutes, getEventTextColor, getEventsForCell, getEventsForDayAndResource, getOverflowCountForCell, getTimedEventsForDayAndResource, getVisibleEventsForCell, isEventEndOnDate, isEventStartOnDate, moveEventTo, parseEvent, parseEventDate, parseEvents, resizeEventBy, sortEvents, sortEventsForCell } from '../chunk-2B3YLWHA.mjs';
+import '../chunk-C7ADJGNV.mjs';
+import '../chunk-5KORIWDT.mjs';
+export { createRRule, daily, describeRRule, everyNthWeekday, expandRRule, expandRecurringSeries, lastWeekdayOfMonth, monthly, parseRRule, serializeRRule, weekdays, weekly, yearly } from '../chunk-FIBAZFC4.mjs';
+import '../chunk-QDMZBJDV.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';

package/dist/event-surface-_R_LHD95.d.mts

@@ -0,0 +1,21 @@
+import { SchedulerEvent } from '@primeui/scheduler-types/scheduler';
+import { SchedulerResource } from '@primeui/scheduler-types/resource';
+
+interface SchedulerEventSurfaceCategory {
+    id: string | number;
+    color?: string;
+}
+interface SchedulerEventSurfaceContext {
+    resources?: SchedulerResource[];
+    categories?: SchedulerEventSurfaceCategory[];
+    categoryField?: string;
+    fallbackColor?: string;
+}
+interface SchedulerEventSurfaceOptions {
+    includeSurface?: boolean;
+    includeHoverSurface?: boolean;
+}
+declare function resolveSchedulerEventSurfaceColor(event: SchedulerEvent, context: SchedulerEventSurfaceContext): string | undefined;
+declare function getSchedulerEventSurfaceStyle(event: SchedulerEvent, context: SchedulerEventSurfaceContext, options?: SchedulerEventSurfaceOptions): Record<string, string>;
+
+export { type SchedulerEventSurfaceCategory as S, type SchedulerEventSurfaceContext as a, type SchedulerEventSurfaceOptions as b, getSchedulerEventSurfaceStyle as g, resolveSchedulerEventSurfaceColor as r };

package/dist/event.positioning-BdzAVPk7.d.mts

@@ -0,0 +1,51 @@
+import { P as ParsedEvent } from './event.utils-QSNdd-3W.mjs';
+
+interface PositionedEvent extends ParsedEvent {
+    column: number;
+    totalColumns: number;
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+    zIndex: number;
+}
+interface EventGroup {
+    events: ParsedEvent[];
+    startMinutes: number;
+    endMinutes: number;
+}
+interface PositioningOptions {
+    slotMinTime: string;
+    slotMaxTime: string;
+    slotDuration: number;
+    slotHeight: number;
+    columnWidth?: number;
+    columnGap?: number;
+    titleHeight?: number;
+}
+declare function positionEventsForDay(events: ParsedEvent[], date: Date, options: PositioningOptions): PositionedEvent[];
+declare function calculateEventPosition(event: ParsedEvent, column: number, totalColumns: number, options: PositioningOptions, nestingDepth?: number): {
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+};
+declare function getAllDayEventsForDay(events: ParsedEvent[], date: Date): ParsedEvent[];
+interface MonthEventPosition {
+    event: ParsedEvent;
+    row: number;
+    startCol: number;
+    endCol: number;
+    isStart: boolean;
+    isEnd: boolean;
+}
+declare function positionAllDayEventsForWeek(events: ParsedEvent[], weekStart: Date, weekEnd: Date): MonthEventPosition[];
+declare function getTimedEventsForDay(events: ParsedEvent[], date: Date): ParsedEvent[];
+interface WeekRowEventData {
+    positioned: MonthEventPosition[];
+    timedEventsByDay: Map<number, ParsedEvent[]>;
+    overflow: Map<number, number>;
+}
+declare function positionEventsForWeekRow(events: ParsedEvent[], weekStart: Date, weekEnd: Date, maxEventsPerDay?: number): WeekRowEventData;
+
+export { type EventGroup as E, type MonthEventPosition as M, type PositionedEvent as P, type WeekRowEventData as W, type PositioningOptions as a, getTimedEventsForDay as b, calculateEventPosition as c, positionEventsForDay as d, positionEventsForWeekRow as e, getAllDayEventsForDay as g, positionAllDayEventsForWeek as p };

package/dist/event.utils-QSNdd-3W.d.mts

@@ -0,0 +1,35 @@
+import { SchedulerEvent } from '@primeui/scheduler-types/scheduler';
+
+interface ParsedEvent extends Omit<SchedulerEvent, 'start' | 'end'> {
+    start: Date;
+    end: Date;
+    durationMinutes: number;
+    isMultiDay: boolean;
+    spanDays: number;
+}
+declare function parseEventDate(date: Date | string | undefined): Date | null;
+declare function getEventStart(event: SchedulerEvent): Date;
+declare function getEventEnd(event: SchedulerEvent): Date;
+declare function moveEventTo(event: SchedulerEvent, target: Date): SchedulerEvent;
+declare function resizeEventBy(event: SchedulerEvent, minutes: number): SchedulerEvent;
+declare function parseEvent(event: SchedulerEvent): ParsedEvent | null;
+declare function parseEvents(events: SchedulerEvent[]): ParsedEvent[];
+declare function filterEventsByDateRange(events: ParsedEvent[], rangeStart: Date, rangeEnd: Date): ParsedEvent[];
+declare function filterEventsForDay(events: ParsedEvent[], date: Date): ParsedEvent[];
+declare function sortEvents(events: ParsedEvent[]): ParsedEvent[];
+declare function getEventStartMinutes(event: ParsedEvent): number;
+declare function getEventEndMinutes(event: ParsedEvent): number;
+declare function eventsOverlap(a: ParsedEvent, b: ParsedEvent): boolean;
+declare function getEventColor(event: SchedulerEvent, defaultColor?: string): string;
+declare function getEventTextColor(event: SchedulerEvent, defaultTextColor?: string): string;
+declare function getEventsForCell(events: ParsedEvent[], cellDate: Date): ParsedEvent[];
+declare function sortEventsForCell(events: ParsedEvent[]): ParsedEvent[];
+declare function getVisibleEventsForCell(events: ParsedEvent[], cellDate: Date, maxEvents: number): ParsedEvent[];
+declare function getOverflowCountForCell(events: ParsedEvent[], cellDate: Date, maxEvents: number): number;
+declare function isEventStartOnDate(event: ParsedEvent, date: Date): boolean;
+declare function isEventEndOnDate(event: ParsedEvent, date: Date): boolean;
+declare function eventMatchesResource(event: Pick<ParsedEvent, 'resourceId' | 'resourceIds'>, resourceId?: string | number): boolean;
+declare function getEventsForDayAndResource(events: ParsedEvent[], date: Date, resourceId: string | number): ParsedEvent[];
+declare function getTimedEventsForDayAndResource(events: ParsedEvent[], date: Date, resourceId: string | number): ParsedEvent[];
+
+export { type ParsedEvent as P, eventsOverlap as a, filterEventsForDay as b, getEventEnd as c, getEventEndMinutes as d, eventMatchesResource as e, filterEventsByDateRange as f, getEventColor as g, getEventStart as h, getEventStartMinutes as i, getEventTextColor as j, getEventsForCell as k, getEventsForDayAndResource as l, getOverflowCountForCell as m, getTimedEventsForDayAndResource as n, getVisibleEventsForCell as o, isEventEndOnDate as p, isEventStartOnDate as q, moveEventTo as r, parseEvent as s, parseEventDate as t, parseEvents as u, resizeEventBy as v, sortEvents as w, sortEventsForCell as x };