@primeui/scheduler-core 0.0.1-alpha.1

package/dist/index.mjs

@@ -0,0 +1,1022 @@
+import './chunk-UMAMDBU4.mjs';
+export { RESIZE_EDGE_SIZE, TIMELINE_RESIZE_EDGE_SIZE, calculateDragClickOffset, calculateResizeDeltas, calculateResizePreviewPosition, calculateResizePreviewStyle, calculateTimedDragDelta, calculateTimedDragPreview, calculateTimedResizePreview, calculateTimelineDragDelta, calculateTimelineResizeDeltas, canDropTimedPreviewEvent, cloneEventForSlotTracking, createAppointmentSlotTrackingState, createTimelineDragState, createTimelineResizeState, detectResizeEdgeForAllDay, detectResizeEdgeForTimeline, dispatchTimedPointerEnd, dispatchTimedPointerMove, finalizeMonthDrag, finalizeMonthResize, finalizeTimedDrag, finalizeTimedResize, finalizeTimelineDrag, finalizeTimelineResize, findColumnIndexForDate, findEventPositionInGrid, getDragGhostStyle, getSlotTrackingKey, getTimedPreviewStyle, getTimelineDragGhostStyle, hasTimedDropConstraints, isAppointmentSlotTrackingView, processMonthDragMove, processMonthResizeMove, processTimedDragMove, processTimedResizeMove, processTimelineDragMove, processTimelineResizeMove, resolveTimedPointerStart, resolveTimelineSnapDuration, syncAppointmentSlotTracking, updateTimelineDragState } from './chunk-5N4ZOBJV.mjs';
+export { DEFAULT_DRAG_MIN_DISTANCE, DEFAULT_OVERSCAN, DEFAULT_SNAP_DURATION, RESIZE_HANDLE_SIZE, RESOURCE_VIEWS, VIRTUAL_THRESHOLD, applyDeltaToEvent, applyEventSelection, applyResizeToEvent, buildResourceCapacityMap, calculateDayDelta, calculateDragDelta, calculateNewEventTimes, calculateNewFocusedDate, calculateTimeDelta, calculateTotalWidth, calculateVirtualRange, calculateVisibleEvents, clampTime, clampTimeToSlotBounds, clearEventSelection, computeColumnTimedMultiDragOffsets, computeDayMultiDragOffsets, computeTimedMultiDragOffsets, createChunkedCells, createDragAutoScroller, createDragState, createResizeState, createSchedulerEventDropCandidate, createVirtualScrollState, dedupeConflicts, detectResizeEdge, evaluateDropConflict, evaluateResourceConflictDecision, eventBelongsToResource, filterEventsByPermission, filterVisibleIdsByResource, findCellForDate, findOverlappingEvents, formatEventDate, formatEventDuration, formatEventTimeRange, formatTimeToken, getCellAtPosition, getDayIndexFromX, getDayOffset, getDefaultFocusDate, getDefaultFocusDateForDay, getDefaultFocusDateForMonth, getDefaultFocusDateForWeek, getDefaultFocusDateForYear, getDisplayedMonthFromGrid, getEndOfWeek, getEndOfWeekForFocus, getEstimatedScrollPosition, getInlineEditTimeValue, getKeyboardAction, getNavigationDirectionForDay, getNavigationDirectionForMonth, getNavigationDirectionForWeek, getNavigationDirectionForYear, getPeriodNavigationDirection, getPointerCoords, getResizeCursor, getSchedulerEventDropDelta, getSchedulerTimedInteractionDeltaMs, getSchedulerTimedResizePreview, getSchedulerTimelineResizePreview, getScrollPositionForDate, getScrollPositionForNow, getSelectedEventsForMultiDrag, getStartOfWeek, getStartOfWeekForFocus, getTimeFromYPosition, getTimeOfDayMs, getVisibleChunks, getYPositionFromTime, handleKeyboardNavigation, hasInlineTimeChanged, invertSelection, isDateInDayView, isDateInMonthView, isDateInVisibleRange, isDateInWeekView, isDateInYearView, isEventDraggable, isEventDraggableWithPermission, isEventResizable, isEventResizableWithPermission, isMultiDragCandidate, isPermissionAllowed, isResourceView, normalizeEventSelectionOptions, normalizeInlineEditOptions, normalizeQuickInfoOptions, parseInlineEditTimeValue, parseInlineTimeToken, processConflictDecision, projectEventsWithCandidate, resolveAutoScrollDelta, resolveCapacityExceededPayloads, resolveGlobalKeyAction, resolveOutsideClickAction, resolveResourceConflictRuntime, selectAllVisibleEvents, shouldUseVirtualScrolling, snapTime, snapTimeToSlot, snapToSlot, toValidDate, updateConflictedEventIds, updateDragState, updateResizeState, updateVirtualScrollState, validateDragPosition, validateResize } from './chunk-2THQAZ26.mjs';
+import './chunk-XUBQ2IQS.mjs';
+import { resolveCalendarViewRange } from './chunk-W2SJW3QQ.mjs';
+export { DEFAULT_ADAPTIVE_OPTIONS, DEFAULT_AUTO_HEIGHT_OPTIONS, DEFAULT_STACKING_OPTIONS, DENSITY_CONFIGS, applyImportMerge, assignEventLanes, buildImportValidationReport, calculateAutoHeight, calculateCellRenderingInfo, calculateMaxOverlappingEvents, calculateResourceRowAutoHeight, calculateTimelineRowHeight, calculateWeekViewAutoHeight, canSelectForView, clampPrintScaleFactor, createAdaptiveRenderingState, defaultSchedulerText, detectImportFormat, exportScheduler, exportToCsv, exportToIcal, exportToJson, exportToPdf, exportToXlsx, formatPrintDate, formatPrintDateTime, formatPrintRange, getAutoHeightClasses, getAvailableLocales, getDefaultFirstDayOfWeek, getDensityCSSVars, getDensityClasses, getDensityConfig, getDensityFromContainerWidth, getEventDensityClasses, getIdlePrintSessionState, getLocaleConfig, getMoreText, getSchedulerText, getSchedulerWeekendToggleView, getStackedEventStyle, getStackingClasses, getVisibleEvents, importFromCsv, importFromIcal, importFromJson, importScheduler, isDirectTimeSelectionView, isRTL, isResourceLikeView, isTimedCreateView, isTimelineLikeView, normalizeAdaptiveOptions, normalizeAutoHeightOptions, normalizeStackingOptions, preparePdfData, prepareXlsxData, previewImportMerge, registerLocale, resolveCalendarViewRange, resolveClickCreateEnd, resolveCurrentViewRange, resolveDaysOfWeekForView, resolveEventDensity, resolveGroupedLaneGeometry, resolvePrintColorAction, resolvePrintFilters, resolvePrintOrientation, resolvePrintPageChromeState, resolvePrintPageStyleRule, resolvePrintRuntimeState, resolvePrintScale, resolvePrintSession, resolveSchedulerText, resolveSelectionEmitOutcome, resolveTimedColumnTextMode, resolveTimelineDefaultTextMode, sortMorePopoverEvents, toDateOnlyString, validateImportResult } from './chunk-W2SJW3QQ.mjs';
+export { applyDefaultResourceDrop, eventsTimeOverlap, findOverlappingEventsInResource, getEventResourceIds, getPrimaryResourceId, hasGroupingFieldValue, hasOverlapInAnyAssignedResource, resolveAutoResourceGroupingField, resolveOverlapPolicy, toCssLength, toNumber } from './chunk-SYJ5O4KH.mjs';
+export { DEFAULT_CONFLICT_OPTIONS, calculateDragRange, canDropEventWithResourceConstraints, checkAvailabilityConstraint, checkCapacityConstraint, checkDailyEventsConstraint, checkDailyHoursConstraint, checkEventDurationConstraint, checkOverlapConstraint, checkSkillConstraint, clearSelection, finalizeDragSelection, getActiveRange, getCapacityStatus, getResourceCapacity, handleDateSelection, handleTimeSelection, hasSelection, isDateInSelectionRange, isDateSelected, isRangeEnd, isRangeStart, normalizeConflictOptions, startDragSelection, updateDragPreview, validateResourceConstraints } from './chunk-NX46LPLF.mjs';
+export { agendaView, dayView, formatEventTime, generateTimeSlots, getAgendaViewData, getAvailableViews, getCustomRangeTitle, getDayViewData, getEventHeight, getEventTopPosition, getMonthViewData, getNowIndicatorPosition, getResourceDayViewData, getResourceWeekViewData, getView, getWeekViewData, getYearViewData, getYearViewWeekdayNames, monthView, resourceDayView, resourceWeekView, viewRegistry, weekView, yearView } from './chunk-ZUKUKGNK.mjs';
+export { buildMonthGridViewModel, buildMonthWeekEventLayout, daysBetween, durationDays, getEventsForMonthDay, getEventsForMonthWeek, getMonthSpanningEventLayout } from './chunk-6PK5WSKT.mjs';
+export { buildYearGridViewModel } from './chunk-6OZAPQZ5.mjs';
+export { calculateTimelineEventPosition, formatTimelineTitle, generateDayCells, generateTimelineCells, generateTimelineHeaderCells, getDefaultTimelineHeaderLevels, getEventsInDateRange, getTimelineDayViewData, getTimelineMonthViewData, getTimelineWeekViewData, getTimelineYearViewData, positionTimelineEvents, positionTimelineEventsForDayGranularity, positionTimelineEventsWithBusinessHours, timelineDayView, timelineMonthView, timelineWeekView, timelineYearView } from './chunk-NMX4BW42.mjs';
+import { DEFAULT_TIMELINE_EVENT_MIN_HEIGHT } from './chunk-KQGRXTP5.mjs';
+export { DEFAULT_TIMELINE_EVENT_MIN_HEIGHT, TIMELINE_LANE_BASE_PADDING, TIMELINE_LANE_GAP, buildTimelineCells, buildTimelineHeaderTiers, buildTimelineViewModel, computeTimelineLaneAssignment, filterTimelineLaneEvents, getTimelineEventRect, getTimelineLaneStackHeight, getTimelineVisibleDayStarts, isTimelineMonthGranularityView, resolveTimelineEventMinHeight, resolveTimelineResourceRowHeight, timeToTimelinePixels } from './chunk-KQGRXTP5.mjs';
+export { buildTimeGridViewModel } from './chunk-F5W5HD7S.mjs';
+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';
+export { getTimedBlockedIntervalsOverlays, getTimedBusinessHoursOverlays, isSlotInBlockedInterval, isSlotInBusinessHours } from './chunk-AAVM7UCG.mjs';
+export { DEFAULT_CATEGORY_OPTIONS, calculateContrastTextColor, filterEventsByCategory, filterEventsByCategoryExclude, getCategoriesByIds, getCategoriesWithAutoTextColor, getCategoryById, getCategoryCounts, getCategoryWithAutoTextColor, getEventCategories, getEventCategory, getEventCategoryBorderColor, getEventCategoryColor, getEventCategoryIcon, getEventCategoryStyle, getEventCategoryTextColor, getSortedCategories, groupEventsByCategory, isSchedulerAutoTextColor, markSchedulerAutoTextColor, normalizeCategoryOptions } from './chunk-C7ADJGNV.mjs';
+export { DEFAULT_APPOINTMENT_SLOTS_OPTIONS, canBookSlot, createSlotFromTimeRange, generateAppointmentSlots, getAppointmentSlotDisplayLabels, getAppointmentSlotIndicators, getAppointmentSlotOverlays, getAvailableSlots, getSlotAtTime, getSlotById, getSlotCapacityDisplay, getSlotOverlayClasses, getSlotOverlayStyle, getSlotsForDay, getSlotsForTimeRange, getSlotsInTimeRange, normalizeAppointmentSlotsOptions, updateSlotAvailability, updateSlotsAvailability } from './chunk-NZGJN7HG.mjs';
+import { canSelect } from './chunk-HPC5B3AR.mjs';
+export { DEFAULT_BUSINESS_HOURS, canCreateWithBlockedIntervals, canDropEvent, canDropWithBlockedIntervals, canSelect, expandBlockedInterval, getBlockedIntervalDisplayLabels, getBlockedIntervalsForDay, getBusinessHoursForDay, getExpandedBlockedIntervals, getTimeSlotBusinessHoursInfo, isDateWithinConstraint, isRangeWithinBlockedInterval, isRangeWithinBusinessHours, isTimeSlotInBusinessHours, isTimeWithinBlockedInterval, isWithinBusinessHours, normalizeBusinessHours } from './chunk-HPC5B3AR.mjs';
+export { getSchedulerEventSurfaceStyle, resolveSchedulerEventSurfaceColor } from './chunk-5KORIWDT.mjs';
+export { createRRule, daily, describeRRule, everyNthWeekday, expandRRule, expandRecurringSeries, lastWeekdayOfMonth, monthly, parseRRule, serializeRRule, weekdays, weekly, yearly } from './chunk-FIBAZFC4.mjs';
+export { COMMON_TIMEZONES, convertEventToDisplayTimezone, convertEventsToTimezone, createDateInTimezone, endOfDayInTimezone, formatDateInTimezone, formatDateTimeInTimezone, formatInTimezone, formatTimeInTimezone, fromLocalTimezone, fromUTC, getCommonTimezones, getDatePartsInTimezone, getLocalTimezone, getTimezoneAbbreviation, getTimezoneDisplayLabel, getTimezoneInfo, getTimezoneName, getTimezoneOffset, getTimezoneOffsetString, isSameDayInTimezone, isTodayInTimezone, isValidTimezone, parseISOWithTimezone, startOfDayInTimezone, toISOWithTimezone, toLocalTimezone, toTimezone, toUTC } from './chunk-QDMZBJDV.mjs';
+import { isSameDay, toDateString, parseDate, clampDate, startOfDay, addDays, addWeeks } from './chunk-WFUJWDST.mjs';
+export { addDays, addHours, addMinutes, addMonths, addWeeks, addYears, applyDaysDelta, calculateDaysDelta, clampDate, differenceInDays, differenceInHours, differenceInMinutes, endOfDay, endOfMonth, endOfWeek, formatDateString, formatEventTime12h, formatGregorianDayNumber, formatGregorianMonthTitle, formatGregorianWeekday, formatGregorianYear, formatMonthYearTitle, formatWeekdayName, getDatesBetween, getDayHours, getDaysInMonth, getMonthDays, getMonthNames, getSchedulerGrid, getWeekDays, getWeekNumber, getWeekdayNames, getYearMonths, isAfter, isBefore, isBetween, isDateInRange, isSameDay, isSameMonth, isSameWeek, isSameYear, isToday, isWeekend, minutesToPixels, minutesToTimeString, parseDate, parseTimeString, setTime, startOfDay, startOfMonth, startOfWeek, timeStringToMinutes, toDateString, toDateTimeString, toTimeString } from './chunk-WFUJWDST.mjs';
+export { DEFAULT_DATE_DISPLAY_OPTIONS, DEFAULT_DISPLAY_OPTIONS, DEFAULT_TIME_FORMAT_OPTIONS, __clearDateTimeFormatterCache, __getDateTimeFormatterCacheSize, createSchedulerDateFormatter, formatDate, formatDateRange, formatDayOfMonth, formatEventDateTime, formatHeaderTitle, formatMonth, formatMonthYear, formatSlotTime, formatTime, formatTimeRange, formatWeekday, getRelativeDay, normalizeDateDisplayOptions, normalizeDisplayOptions, normalizeTimeFormatOptions, resolveSchedulerCalendarDisplayConfig } from './chunk-TNKJPFGI.mjs';
+import { getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+export { addCalendarDaysToDate, differenceInCalendarDays, getSchedulerCalendarAdapter, gregorianCalendarAdapter, isCalendarAdapterCorrectView, moveDateToCalendarDay, resolveSchedulerCalendarId, resolveSchedulerCalendarModeForView, schedulerInternationalCalendarIds } from './chunk-DYW6WUHE.mjs';
+export { DEFAULT_ADAPTIVE_BREAKPOINT, DEFAULT_RESOURCE_AREA_WIDTH, DEFAULT_RESOURCE_MIN_ROW_HEIGHT, DEFAULT_RESOURCE_ROW_HEIGHT, DEFAULT_SIDEBAR_WIDTH, adaptiveClasses, addResource, addResourceToEvent, addResourceToTree, areResourceIdSetsEqual, assignEventToResource, buildBreadcrumbPath, calculateExpandedRowHeight, calculateResourceColumnLayouts, calculateResourceRowLayouts, clearResourceSelection, closeSidebar, collapseAllResources, collapseResource, countLeafDescendants, countResources, createAdaptiveGroupingState, createResourceFilter, createResourceStore, dedupeResourceIds, detectMobileMode, expandAllResources, expandResource, filterResources, findResourceById, flattenResourceTree, flattenResources, getAllResourceIds, getAncestorIds, getAncestorResources, getChildResources, getEventsForResource, getEventsWithoutResource, getFilterStats, getFilteredEventsForResource, getHierarchicalHeaderRows, getLeafResources, getMaxDepth, getParentResource, getResourceAreaWidth, getResourceAtPosition, getResourceById, getResourceColumnAtPosition, getResourceIdsForEvent, getResourceLabel, getResourcesByIds, getSelectedResource, getSelectionDepth, getTotalResourceHeight, getVisibleResources, groupEventsByDate, groupEventsByResource, groupResourcesByField, hasHierarchy, highlightMatch, isResourceInPath, moveEventToResource, navigateBreadcrumb, openSidebar, removeResource, removeResourceFromEvent, removeResourceFromTree, resolveResourceScalePolicy, resolveResourceScaleStrategy, searchResources, selectResource, setMobileMode, setResourceExpansionInTree, sortResources, toggleResourceExpansion, toggleSidebar, updateResource, updateResourceInTree, upsertResourceById } from './chunk-QR2SVYAD.mjs';
+import { defineComponent } from '@primeui/core';
+
+// src/scheduler.logic.ts
+function endOfRangeDay(date) {
+  const end = startOfDay(date);
+  end.setHours(23, 59, 59, 999);
+  return end;
+}
+function useSchedulerLogic(instance) {
+  const { $props, $state, $emit } = instance;
+  const getDateRangeForView = (date, view) => {
+    const firstDayOfWeek = $props.firstDayOfWeek ?? 0;
+    const range = resolveCalendarViewRange({
+      view,
+      currentDate: date,
+      locale: $props.locale ?? "en",
+      calendar: $props.calendar,
+      firstDayOfWeek,
+      daysOfWeek: $props.daysOfWeek
+    });
+    return { start: startOfDay(range.start), end: endOfRangeDay(range.end) };
+  };
+  const emitViewChange = (view, date) => {
+    const dateRange = getDateRangeForView(date, view);
+    $emit("view-change", { view, dateRange });
+    $emit("dates-change", dateRange);
+  };
+  const navigate = (direction) => {
+    const currentDate = $state.currentDate;
+    const view = $state.currentView;
+    let newDate;
+    const calendarAdapter = getSchedulerCalendarAdapter($props.calendar, { locale: $props.locale });
+    const calendarDate = calendarAdapter.fromDate(currentDate);
+    switch (view) {
+      case "month":
+      case "resourceMonth":
+      case "dateMonth":
+      case "timelineMonth":
+      case "resourceTimelineMonth":
+        newDate = calendarAdapter.toDate(calendarAdapter.add(calendarDate, { months: direction }));
+        break;
+      case "week":
+      case "timelineWeek":
+      case "resourceTimelineWeek":
+      case "resourceWeek":
+      case "dateWeek":
+        newDate = addWeeks(currentDate, direction);
+        break;
+      case "day":
+      case "timelineDay":
+      case "resourceTimelineDay":
+      case "resourceDay":
+      case "dateDay":
+        newDate = addDays(currentDate, direction);
+        break;
+      case "year":
+      case "timelineYear":
+        newDate = calendarAdapter.toDate(calendarAdapter.add(calendarDate, { years: direction }));
+        break;
+      case "agenda":
+        newDate = addDays(currentDate, direction * 30);
+        break;
+      default:
+        newDate = currentDate;
+    }
+    const clampedDate = clampDate(newDate, $props.minDate, $props.maxDate);
+    $emit("date-change", clampedDate);
+    emitViewChange(view, clampedDate);
+  };
+  const prev = () => {
+    navigate(-1);
+  };
+  const next = () => {
+    navigate(1);
+  };
+  const today2 = () => {
+    const todayDate = clampDate(/* @__PURE__ */ new Date(), $props.minDate, $props.maxDate);
+    $emit("date-change", todayDate);
+    emitViewChange($state.currentView, todayDate);
+  };
+  const gotoDate = (date) => {
+    const targetDate = typeof date === "string" ? parseDate(date) : date;
+    if (!targetDate) return;
+    const clampedDate = clampDate(targetDate, $props.minDate, $props.maxDate);
+    $emit("date-change", clampedDate);
+    emitViewChange($state.currentView, clampedDate);
+  };
+  const changeView = (view) => {
+    $emit("view-change", { view, dateRange: getDateRangeForView($state.currentDate, view) });
+  };
+  const getView2 = () => {
+    return $state.currentView;
+  };
+  const getDate = () => {
+    return new Date($state.currentDate);
+  };
+  const getDateRange = () => {
+    return getDateRangeForView($state.currentDate, $state.currentView);
+  };
+  const select = (start, end) => {
+    if ($props.disabled || $props.readonly || !$props.selectable) return;
+    const endDate = end || start;
+    const allDay = true;
+    if (!canSelect(start, endDate, allDay, $state.currentView, $props.selectConstraint, $props.selectAllow)) {
+      return;
+    }
+    const selectionMode = $props.selectionMode ?? "single";
+    let selectedDates = [];
+    let selectedRange = null;
+    switch (selectionMode) {
+      case "single":
+        selectedDates = [start];
+        break;
+      case "multiple": {
+        const existingIndex = $state.selectedDates.findIndex((d) => isSameDay(d, start));
+        if (existingIndex >= 0) {
+          selectedDates = $state.selectedDates.filter((_, i) => i !== existingIndex);
+        } else {
+          selectedDates = [...$state.selectedDates, start];
+        }
+        break;
+      }
+      case "range":
+        selectedRange = { start, end: endDate };
+        break;
+    }
+    $emit("selection-change", { selectedDates, selectedRange });
+    if (selectedDates.length === 0 && selectedRange === null) {
+      $emit("date-unselect", { view: $state.currentView });
+      return;
+    }
+    $emit("date-select", {
+      start,
+      end: endDate,
+      startStr: toDateString(start),
+      endStr: toDateString(endDate),
+      view: $state.currentView,
+      allDay
+    });
+  };
+  const unselect = () => {
+    $emit("selection-change", { selectedDates: [], selectedRange: null });
+    $emit("date-unselect", { view: $state.currentView });
+  };
+  const getEvents = () => {
+    return $props.events ?? [];
+  };
+  const getEventById = (id) => {
+    return getEvents().find((event) => event.id === id);
+  };
+  const getSelectedEventIds = () => {
+    return $state.selectedEventIds ?? [];
+  };
+  const getSelectedEvents = () => {
+    const selectedIds = new Set(getSelectedEventIds());
+    return getEvents().filter((event) => selectedIds.has(event.id));
+  };
+  const setSelectedEvents = (ids) => {
+    const selectedIds = Array.isArray(ids) ? ids : [];
+    const selectedEvents = getEvents().filter((event) => selectedIds.includes(event.id));
+    $emit("event-selection-change", { selectedIds, events: selectedEvents });
+  };
+  const clearEventSelection2 = () => {
+    $emit("event-selection-change", { selectedIds: [], events: [] });
+  };
+  const addEvent = (event) => {
+    const events = [...getEvents(), event];
+    $emit("event-add", event);
+    return events;
+  };
+  const updateEvent = (event) => {
+    const events = getEvents();
+    const index = events.findIndex((e) => e.id === event.id);
+    if (index >= 0) {
+      const oldEvent = events[index];
+      events[index] = event;
+      $emit("event-change", { event, oldEvent });
+    }
+  };
+  const removeEvent = (id) => {
+    const events = getEvents();
+    const event = events.find((e) => e.id === id);
+    if (event) {
+      $emit("event-remove", { event });
+    }
+  };
+  const getResources = () => {
+    return $props.resources ?? [];
+  };
+  const getResourceById2 = (id) => {
+    const resources = getResources();
+    const findResource = (resources2) => {
+      for (const resource of resources2) {
+        if (resource.id === id) {
+          return resource;
+        }
+        if (resource.children) {
+          const found = findResource(resource.children);
+          if (found) {
+            return found;
+          }
+        }
+      }
+      return void 0;
+    };
+    return findResource(resources);
+  };
+  const addResource2 = (resource, parentId) => {
+    $emit("resource-add", { resource, parentId });
+  };
+  const updateResource2 = (id, updates) => {
+    const resource = getResourceById2(id);
+    if (resource) {
+      $emit("resource-update", { resource: { ...resource, ...updates }, oldResource: resource });
+    }
+  };
+  const removeResource2 = (id) => {
+    const resource = getResourceById2(id);
+    if (resource) {
+      $emit("resource-remove", { resource });
+    }
+  };
+  const expandResource2 = (id) => {
+    const resource = getResourceById2(id);
+    if (resource) {
+      $emit("resource-expand", { resource, expanded: true });
+    }
+  };
+  const collapseResource2 = (id) => {
+    const resource = getResourceById2(id);
+    if (resource) {
+      $emit("resource-collapse", { resource });
+    }
+  };
+  const refetchResources = () => {
+    $emit("resources-refetch", {});
+  };
+  return {
+    prev,
+    next,
+    today: today2,
+    gotoDate,
+    changeView,
+    getView: getView2,
+    getDate,
+    getDateRange,
+    select,
+    unselect,
+    getEvents,
+    getEventById,
+    getSelectedEventIds,
+    getSelectedEvents,
+    setSelectedEvents,
+    clearEventSelection: clearEventSelection2,
+    addEvent,
+    updateEvent,
+    removeEvent,
+    getResources,
+    getResourceById: getResourceById2,
+    addResource: addResource2,
+    updateResource: updateResource2,
+    removeResource: removeResource2,
+    expandResource: expandResource2,
+    collapseResource: collapseResource2,
+    refetchResources
+  };
+}
+
+// src/scheduler.props.ts
+var schedulerDefaultProps = {
+  height: void 0,
+  aspectRatio: 1.2,
+  view: "month",
+  views: ["month", "week", "day", "year", "agenda"],
+  date: /* @__PURE__ */ new Date(),
+  events: [],
+  locale: "en",
+  calendar: "gregory",
+  numberingSystem: void 0,
+  text: void 0,
+  rtl: false,
+  firstDayOfWeek: 0,
+  weekNumbers: false,
+  weekNumbering: "iso",
+  minDate: void 0,
+  maxDate: void 0,
+  disabled: false,
+  readonly: false,
+  selectable: true,
+  selectionMode: "single",
+  unselectOnOutsideClick: false,
+  slotDuration: 30,
+  slotMinTime: "00:00",
+  slotMaxTime: "24:00",
+  nowIndicator: true,
+  nowIndicatorInterval: 6e4,
+  navLinks: false,
+  headerToolbar: {
+    left: "prev,next today",
+    center: "title",
+    right: "month,week,day"
+  },
+  editable: false,
+  eventStartEditable: true,
+  eventDurationEditable: true,
+  eventOverlap: true,
+  snapDuration: void 0,
+  dragMinDistance: 5,
+  dragRevertDuration: void 0,
+  dragScroll: void 0,
+  timezone: void 0,
+  displayTimezone: void 0,
+  businessHours: false,
+  selectConstraint: void 0,
+  selectAllow: void 0,
+  eventConstraint: void 0,
+  eventAllow: void 0,
+  blockedIntervals: void 0,
+  appointmentSlots: void 0,
+  eventSelection: false,
+  timelineSlotWidth: 112,
+  timelineSlotWidthMode: "fixed",
+  timelineSlotDuration: 60,
+  timelineSnapDuration: void 0,
+  timelineMinTime: void 0,
+  timelineMaxTime: void 0,
+  timelineVirtualScroll: "auto",
+  timelineVirtualThreshold: 100,
+  timelineVirtualOverscan: 2,
+  timelineVirtualEventBuffer: 100,
+  timelineEventMinHeight: DEFAULT_TIMELINE_EVENT_MIN_HEIGHT,
+  showBusinessHours: true,
+  agendaDays: 30,
+  showEmptyDays: false,
+  noEventsMessage: void 0,
+  agendaEventShell: "default",
+  eventShell: "default",
+  resources: [],
+  resourceAreaWidth: 200,
+  resourceOrder: void 0,
+  horizontalResourceColumnMode: void 0,
+  horizontalResourceColumnWidth: void 0,
+  horizontalResourceMinColumnWidth: 120,
+  horizontalResourceOverflowThreshold: 8,
+  horizontalResourceGroupMinWidth: void 0,
+  horizontalResourceDayMinWidth: void 0,
+  byGroupId: void 0,
+  byGroupID: false,
+  resourceGroupField: void 0,
+  resourcesExpandable: true,
+  resourcesInitiallyExpanded: true,
+  showAggregatedEvents: true,
+  groupByResource: void 0,
+  groupByDate: void 0,
+  resourceAreaHeaderContent: "Resources",
+  resourceConflict: void 0,
+  adaptiveMode: false,
+  selectedResourceId: null,
+  resourceRowHeight: 48,
+  rowAutoHeight: void 0,
+  resourceTimelineOverlapPolicy: "auto",
+  showResourceFilter: false,
+  monthEventRowHeight: void 0,
+  monthMoreLinkHeight: void 0,
+  showMorePopover: true,
+  maxEventsVisible: 5,
+  numberOfDays: void 0,
+  daysOfWeek: void 0,
+  density: "standard",
+  autoHeight: false,
+  stacking: void 0,
+  adaptiveRendering: void 0,
+  timeFormat: void 0,
+  dateDisplay: void 0,
+  eventPermission: void 0,
+  eventPopover: false,
+  eventPopoverDelay: 300,
+  eventPopoverHideDelay: 100,
+  eventPopoverPosition: "right",
+  eventPopoverShowOnMobile: false,
+  quickInfo: false,
+  quickInfoPosition: "right",
+  recurrenceEdit: true,
+  inlineEdit: false,
+  eventCategories: [],
+  categories: [],
+  categoryField: "categoryId",
+  categoryAutoTextColor: true,
+  showCategoryLegend: false,
+  categoryLegendPosition: "top",
+  categoryFilterable: false
+};
+var schedulerPropKeys = Object.keys(schedulerDefaultProps);
+var schedulerDefaultFactoryKeys = ["views", "date", "events", "headerToolbar", "resources", "eventCategories", "categories"];
+var schedulerDefaultFactories = {
+  views: () => ["month", "week", "day", "year", "agenda"],
+  date: () => /* @__PURE__ */ new Date(),
+  events: () => [],
+  headerToolbar: () => ({
+    left: "prev,next today",
+    center: "title",
+    right: "month,week,day"
+  }),
+  resources: () => [],
+  eventCategories: () => [],
+  categories: () => []
+};
+function getSchedulerDefaultProp(key) {
+  const factory = schedulerDefaultFactories[key];
+  return factory ? factory() : schedulerDefaultProps[key];
+}
+function resolveSchedulerProps(props = {}) {
+  const resolved = {};
+  for (const key of schedulerPropKeys) {
+    resolved[key] = props[key] === void 0 ? getSchedulerDefaultProp(key) : props[key];
+  }
+  return resolved;
+}
+
+// src/scheduler.refs.ts
+var defaultSchedulerRefs = {
+  root: void 0,
+  header: void 0,
+  body: void 0,
+  scrollContainer: void 0
+};
+
+// src/scheduler.state.ts
+var today = /* @__PURE__ */ new Date();
+var defaultSchedulerState = {
+  currentDate: today,
+  currentView: "month",
+  selectedDates: [],
+  selectedRange: null,
+  selectedEventIds: [],
+  lastSelectedEventId: null,
+  eventSelectionAnchor: null,
+  eventSelectionModeActive: false,
+  hoveredDate: null,
+  focusedDate: null,
+  isNavigating: false
+};
+
+// src/createScheduler.ts
+var createScheduler = defineComponent("Scheduler", ({ getCurrentInstance, defineRefs, defineProps, defineState, defineEmits, defineExpose }) => {
+  defineRefs(defaultSchedulerRefs);
+  defineProps(schedulerDefaultProps);
+  defineState(defaultSchedulerState);
+  defineEmits([
+    "view-change",
+    "dates-change",
+    "date-change",
+    "selection-change",
+    "event-selection-change",
+    "bulk-move",
+    "bulk-update",
+    "bulk-delete",
+    "date-click",
+    "date-select",
+    "date-unselect",
+    "event-click",
+    "event-mouseenter",
+    "event-mouseleave",
+    "event-add",
+    "event-change",
+    "event-remove",
+    "resource-add",
+    "resource-update",
+    "resource-remove",
+    "resource-expand",
+    "resource-collapse",
+    "resources-refetch"
+  ]);
+  const currentInstance = getCurrentInstance();
+  const expose = useSchedulerLogic(currentInstance);
+  defineExpose(expose);
+});
+
+// src/scheduler.classes.ts
+var schedulerClasses = {
+  root: "p-scheduler",
+  disabled: "p-scheduler-disabled",
+  selecting: "p-scheduler-selecting",
+  header: "p-scheduler-header",
+  headerLeft: "p-scheduler-header-left",
+  headerCenter: "p-scheduler-header-center",
+  headerRight: "p-scheduler-header-right",
+  title: "p-scheduler-title",
+  body: "p-scheduler-body",
+  loading: "p-scheduler-loading",
+  navButton: "p-scheduler-nav-button",
+  viewSwitcher: "p-scheduler-view-switcher",
+  viewButton: "p-scheduler-view-button",
+  scrollRail: "p-scheduler-scroll-rail",
+  sidebar: "p-scheduler-sidebar",
+  today: "p-scheduler-today",
+  weekend: "p-scheduler-weekend",
+  hierarchical: "p-scheduler-hierarchical",
+  // Month view
+  monthView: "p-scheduler-month-view",
+  compactMode: "p-scheduler-compact-mode",
+  weekdays: "p-scheduler-weekdays",
+  weekday: "p-scheduler-weekday",
+  weeks: "p-scheduler-weeks",
+  week: "p-scheduler-week",
+  weekNumber: "p-scheduler-week-number",
+  day: "p-scheduler-day",
+  dayFocused: "p-scheduler-day-focused",
+  dayNumber: "p-scheduler-day-number",
+  dayEvents: "p-scheduler-day-events",
+  dayToday: "p-scheduler-day-today",
+  dayWeekend: "p-scheduler-day-weekend",
+  dayOtherMonth: "p-scheduler-day-other-month",
+  daySelected: "p-scheduler-day-selected",
+  dayDisabled: "p-scheduler-day-disabled",
+  dayInRange: "p-scheduler-day-in-range",
+  dayRangeStart: "p-scheduler-day-range-start",
+  dayRangeEnd: "p-scheduler-day-range-end",
+  dayDropTarget: "p-scheduler-day-drop-target",
+  moreLink: "p-scheduler-more-link",
+  // Week/Day view
+  weekHeader: "p-scheduler-week-header",
+  weekHeaderGutter: "p-scheduler-week-header-gutter",
+  timezoneLabel: "p-scheduler-timezone-label",
+  weekHeaderDays: "p-scheduler-week-header-days",
+  weekBody: "p-scheduler-week-body",
+  timeGrid: "p-scheduler-time-grid",
+  timeGutter: "p-scheduler-time-gutter",
+  timeSlotLabel: "p-scheduler-time-slot-label",
+  timeContent: "p-scheduler-time-content",
+  timeSlots: "p-scheduler-time-slots",
+  timeSlot: "p-scheduler-time-slot",
+  timeSlotHalf: "p-scheduler-time-slot-half",
+  timeSlotFocused: "p-scheduler-time-slot-focused",
+  timeSlotBusiness: "p-scheduler-time-slot-business",
+  timeSlotNonBusiness: "p-scheduler-time-slot-non-business",
+  timeSlotBusinessStart: "p-scheduler-time-slot-business-start",
+  timeSlotBusinessEnd: "p-scheduler-time-slot-business-end",
+  timeSelection: "p-scheduler-time-selection",
+  allDayRow: "p-scheduler-all-day-row",
+  allDayLabel: "p-scheduler-all-day-label",
+  allDayContent: "p-scheduler-all-day-content",
+  allDayCell: "p-scheduler-all-day-cell",
+  dayColumns: "p-scheduler-day-columns",
+  dayColumn: "p-scheduler-day-column",
+  dayColumnHeader: "p-scheduler-day-column-header",
+  dayColumnHeaderDay: "p-scheduler-day-column-header-day",
+  dayColumnHeaderDate: "p-scheduler-day-column-header-date",
+  dayColumnNonBusiness: "p-scheduler-day-column-non-business",
+  nowIndicator: "p-scheduler-now-indicator",
+  nowIndicatorDot: "p-scheduler-now-indicator-dot",
+  nowIndicatorLabel: "p-scheduler-now-indicator-label",
+  nonBusinessOverlay: "p-scheduler-non-business-overlay",
+  // Event base
+  event: "p-scheduler-event",
+  eventShellNone: "p-scheduler-event-shell-none",
+  eventTimed: "p-scheduler-event-timed",
+  eventAllday: "p-scheduler-event-allday",
+  eventDot: "p-scheduler-event-dot",
+  eventTitleWrap: "p-scheduler-event-title-wrap",
+  eventTitle: "p-scheduler-event-title",
+  eventTime: "p-scheduler-event-time",
+  eventPreview: "p-scheduler-event-preview",
+  eventSelected: "p-scheduler-event-selected",
+  eventContinuesBefore: "p-scheduler-event-continues-before",
+  eventContinuesAfter: "p-scheduler-event-continues-after",
+  // Event drag & drop
+  eventDraggable: "p-scheduler-event-draggable",
+  eventDragging: "p-scheduler-event-dragging",
+  eventDraggingActive: "p-scheduler-event-dragging-active",
+  eventDragPreview: "p-scheduler-event-drag-preview",
+  eventDropPreview: "p-scheduler-event-drop-preview",
+  eventMultiDragging: "p-scheduler-event-multi-dragging",
+  eventMultiDragPreview: "p-scheduler-event-multi-drag-preview",
+  // Event resize
+  eventResizable: "p-scheduler-event-resizable",
+  eventResizing: "p-scheduler-event-resizing",
+  eventResizingActive: "p-scheduler-event-resizing-active",
+  eventResizeHandle: "p-scheduler-event-resize-handle",
+  eventResizeHandleTop: "p-scheduler-event-resize-handle-top",
+  eventResizeHandleBottom: "p-scheduler-event-resize-handle-bottom",
+  eventResizeTop: "p-scheduler-event-resize-top",
+  eventResizeBottom: "p-scheduler-event-resize-bottom",
+  eventResizeStart: "p-scheduler-event-resize-start",
+  eventResizeEnd: "p-scheduler-event-resize-end",
+  eventResizePreview: "p-scheduler-event-resize-preview",
+  // Event selection
+  eventSelectionEnabled: "p-scheduler-event-selection-enabled",
+  eventSelectionToggle: "p-scheduler-event-selection-toggle",
+  eventSelectionCheckbox: "p-scheduler-event-selection-checkbox",
+  // Selection toolbar
+  selectionToolbar: "p-scheduler-selection-toolbar",
+  selectionToolbarCount: "p-scheduler-selection-toolbar-count",
+  selectionToolbarClear: "p-scheduler-selection-toolbar-clear",
+  // Inline edit
+  eventEditing: "p-scheduler-event-editing",
+  eventEditInput: "p-scheduler-event-edit-input",
+  // Event popover
+  eventPopover: "p-scheduler-event-popover",
+  eventPopoverHeader: "p-scheduler-event-popover-header",
+  eventPopoverTitle: "p-scheduler-event-popover-title",
+  eventPopoverBody: "p-scheduler-event-popover-body",
+  eventPopoverTime: "p-scheduler-event-popover-time",
+  eventPopoverDate: "p-scheduler-event-popover-date",
+  eventPopoverDescription: "p-scheduler-event-popover-description",
+  eventPopoverLocation: "p-scheduler-event-popover-location",
+  eventPopoverDuration: "p-scheduler-event-popover-duration",
+  eventPopoverResource: "p-scheduler-event-popover-resource",
+  eventPopoverDragActive: "p-scheduler-event-popover-drag-active",
+  // Quick info
+  quickInfo: "p-scheduler-quick-info",
+  quickInfoHeader: "p-scheduler-quick-info-header",
+  quickInfoTitle: "p-scheduler-quick-info-title",
+  quickInfoBody: "p-scheduler-quick-info-body",
+  quickInfoTime: "p-scheduler-quick-info-time",
+  quickInfoDescription: "p-scheduler-quick-info-description",
+  quickInfoLocation: "p-scheduler-quick-info-location",
+  quickInfoResource: "p-scheduler-quick-info-resource",
+  quickInfoFooter: "p-scheduler-quick-info-footer",
+  quickInfoActions: "p-scheduler-quick-info-actions",
+  quickInfoEditButton: "p-scheduler-quick-info-edit-button",
+  quickInfoDeleteButton: "p-scheduler-quick-info-delete-button",
+  quickInfoCloseButton: "p-scheduler-quick-info-close-button",
+  // More popover
+  morePopover: "p-scheduler-more-popover",
+  morePopoverHeader: "p-scheduler-more-popover-header",
+  morePopoverTitle: "p-scheduler-more-popover-title",
+  morePopoverClose: "p-scheduler-more-popover-close",
+  morePopoverBody: "p-scheduler-more-popover-body",
+  morePopoverList: "p-scheduler-more-popover-list",
+  morePopoverItem: "p-scheduler-more-popover-item",
+  morePopoverItemColor: "p-scheduler-more-popover-item-color",
+  morePopoverItemTitle: "p-scheduler-more-popover-item-title",
+  morePopoverItemTime: "p-scheduler-more-popover-item-time",
+  // Recurrence dialog
+  recurrenceDialog: "p-scheduler-recurrence-dialog",
+  recurrenceDialogOverlay: "p-scheduler-recurrence-dialog-overlay",
+  recurrenceDialogHeader: "p-scheduler-recurrence-dialog-header",
+  recurrenceDialogTitle: "p-scheduler-recurrence-dialog-title",
+  recurrenceDialogSummary: "p-scheduler-recurrence-dialog-summary",
+  recurrenceDialogSummaryRow: "p-scheduler-recurrence-dialog-summary-row",
+  recurrenceDialogSummaryLabel: "p-scheduler-recurrence-dialog-summary-label",
+  recurrenceDialogSummaryValue: "p-scheduler-recurrence-dialog-summary-value",
+  recurrenceDialogBody: "p-scheduler-recurrence-dialog-body",
+  recurrenceDialogOption: "p-scheduler-recurrence-dialog-option",
+  recurrenceDialogOptionSelected: "p-scheduler-recurrence-dialog-option-selected",
+  recurrenceDialogOptionLabel: "p-scheduler-recurrence-dialog-option-label",
+  recurrenceDialogOptionDescription: "p-scheduler-recurrence-dialog-option-description",
+  recurrenceDialogFooter: "p-scheduler-recurrence-dialog-footer",
+  recurrenceDialogCancelButton: "p-scheduler-recurrence-dialog-cancel",
+  recurrenceDialogConfirmButton: "p-scheduler-recurrence-dialog-confirm",
+  // Year view
+  yearView: "p-scheduler-year-view",
+  miniMonth: "p-scheduler-mini-month",
+  miniMonthFocused: "p-scheduler-mini-month-focused",
+  miniMonthHeader: "p-scheduler-mini-month-header",
+  miniMonthGrid: "p-scheduler-mini-month-grid",
+  miniMonthWeekday: "p-scheduler-mini-month-weekday",
+  miniMonthDay: "p-scheduler-mini-month-day",
+  miniMonthDayDisabled: "p-scheduler-mini-month-day-disabled",
+  miniMonthDayOther: "p-scheduler-mini-month-day-other",
+  miniMonthDayToday: "p-scheduler-mini-month-day-today",
+  miniMonthDayWeekend: "p-scheduler-mini-month-day-weekend",
+  miniMonthDayHasEvents: "p-scheduler-mini-month-day-has-events",
+  miniMonthDayIndicator: "p-scheduler-mini-month-day-indicator",
+  miniMonthDaySelected: "p-scheduler-mini-month-day-selected",
+  miniMonthDayInRange: "p-scheduler-mini-month-day-in-range",
+  miniMonthDayRangeStart: "p-scheduler-mini-month-day-range-start",
+  miniMonthDayRangeEnd: "p-scheduler-mini-month-day-range-end",
+  miniMonthDayFocused: "p-scheduler-mini-month-day-focused",
+  // Agenda view
+  agendaView: "p-scheduler-agenda-view",
+  agendaDay: "p-scheduler-agenda-day",
+  agendaDayHeader: "p-scheduler-agenda-day-header",
+  agendaDayDate: "p-scheduler-agenda-day-date",
+  agendaDayWeekday: "p-scheduler-agenda-day-weekday",
+  agendaDayNumber: "p-scheduler-agenda-day-number",
+  agendaEvents: "p-scheduler-agenda-events",
+  agendaEvent: "p-scheduler-agenda-event",
+  agendaEventShellNone: "p-scheduler-agenda-event-shell-none",
+  agendaEventTime: "p-scheduler-agenda-event-time",
+  agendaEventTitle: "p-scheduler-agenda-event-title",
+  agendaNoEvents: "p-scheduler-agenda-no-events",
+  agendaDayDescription: "p-scheduler-agenda-day-description",
+  agendaDayCount: "p-scheduler-agenda-day-count",
+  // Blocked intervals
+  blockedInterval: "p-scheduler-blocked-interval",
+  blockedIntervalStriped: "p-scheduler-blocked-interval-striped",
+  blockedIntervalLabel: "p-scheduler-blocked-interval-label",
+  // Timeline view
+  timelineView: "p-scheduler-timeline-view",
+  timelineViewDayGranularity: "p-scheduler-timeline-view-day-granularity",
+  timelineDayHeader: "p-scheduler-timeline-day-header",
+  timelineDayHeaderContent: "p-scheduler-timeline-day-header-content",
+  timelineDayHeaderDay: "p-scheduler-timeline-day-header-day",
+  timelineDayHeaderDate: "p-scheduler-timeline-day-header-date",
+  timelineHeader: "p-scheduler-timeline-header",
+  timelineHeaderArea: "p-scheduler-timeline-header-area",
+  timelineHeaderScroll: "p-scheduler-timeline-header-scroll",
+  timelineHeaderRow: "p-scheduler-timeline-header-row",
+  timelineHeaderCell: "p-scheduler-timeline-header-cell",
+  timelineHeaderCellLabel: "p-scheduler-timeline-header-cell-label",
+  timelineHeaderCellSecondary: "p-scheduler-timeline-header-cell-secondary",
+  timelineBody: "p-scheduler-timeline-body",
+  timelineRow: "p-scheduler-timeline-row",
+  timelineRowGroup: "p-scheduler-timeline-row-group",
+  timelineGrid: "p-scheduler-timeline-grid",
+  timelineGridArea: "p-scheduler-timeline-grid-area",
+  timelineCell: "p-scheduler-timeline-cell",
+  timelineCellFocused: "p-scheduler-timeline-cell-focused",
+  timelineCellsWrapper: "p-scheduler-timeline-cells-wrapper",
+  timelineCellsStrip: "p-scheduler-timeline-cells-strip",
+  timelineCellToday: "p-scheduler-timeline-cell-today",
+  timelineCellWeekend: "p-scheduler-timeline-cell-weekend",
+  timelineCellBusiness: "p-scheduler-timeline-cell-business",
+  timelineEvents: "p-scheduler-timeline-events",
+  timelineEvent: "p-scheduler-timeline-event",
+  timelineEventShellNone: "p-scheduler-timeline-event-shell-none",
+  timelineEventTitle: "p-scheduler-timeline-event-title",
+  timelineEventTime: "p-scheduler-timeline-event-time",
+  timelineEventContinuesBefore: "p-scheduler-timeline-event-continues-before",
+  timelineEventContinuesAfter: "p-scheduler-timeline-event-continues-after",
+  timelineNowIndicator: "p-scheduler-timeline-now-indicator",
+  timelineScrollContainer: "p-scheduler-timeline-scroll-container",
+  timelineOverflow: "p-scheduler-timeline-overflow",
+  timelineSlotWidthFixed: "p-scheduler-timeline-slot-width-fixed",
+  // Timeline year view
+  timelineYearView: "p-scheduler-timeline-year-view",
+  timelineYearRow: "p-scheduler-timeline-year-row",
+  timelineYearRowCurrent: "p-scheduler-timeline-year-row-current",
+  timelineYearMonthLabel: "p-scheduler-timeline-year-month-label",
+  timelineYearEvents: "p-scheduler-timeline-year-events",
+  timelineYearEvent: "p-scheduler-timeline-year-event",
+  timelineYearEventTime: "p-scheduler-timeline-year-event-time",
+  timelineYearEventTitle: "p-scheduler-timeline-year-event-title",
+  timelineYearMore: "p-scheduler-timeline-year-more",
+  // Timeline resource view
+  timelineResourceView: "p-scheduler-timeline-resource-view",
+  timelineResourceArea: "p-scheduler-timeline-resource-area",
+  timelineResourceRow: "p-scheduler-timeline-resource-row",
+  timelineResourceRows: "p-scheduler-timeline-resource-rows",
+  timelineResourceCell: "p-scheduler-timeline-resource-cell",
+  timelineResourceEvents: "p-scheduler-timeline-resource-events",
+  resourceAggregate: "p-scheduler-resource-aggregate",
+  resourceAggregateCount: "p-scheduler-resource-aggregate-count",
+  resourceAggregateFlag: "p-scheduler-resource-aggregate-flag",
+  resourceAggregateFlagConflict: "p-scheduler-resource-aggregate-flag-conflict",
+  resourceAggregateFlagCapacityNear: "p-scheduler-resource-aggregate-flag-capacity-near",
+  resourceAggregateFlagCapacityFull: "p-scheduler-resource-aggregate-flag-capacity-full",
+  // Resource area (shared)
+  resourceArea: "p-scheduler-resource-area",
+  resourceAreaHeader: "p-scheduler-resource-area-header",
+  resourceAreaBody: "p-scheduler-resource-area-body",
+  resourceRow: "p-scheduler-resource-row",
+  resourceRowExpanded: "p-scheduler-resource-row-expanded",
+  resourceRowCollapsed: "p-scheduler-resource-row-collapsed",
+  resourceRowParent: "p-scheduler-resource-row-parent",
+  resourceRowChild: "p-scheduler-resource-row-child",
+  resourceCell: "p-scheduler-resource-cell",
+  resourceCellContent: "p-scheduler-resource-cell-content",
+  resourceLabel: "p-scheduler-resource-label",
+  resourceExpandIcon: "p-scheduler-resource-expand-icon",
+  resourceExpandSpacer: "p-scheduler-resource-expand-spacer",
+  resourceFilter: "p-scheduler-resource-filter",
+  resourceFilterInput: "p-scheduler-resource-filter-input",
+  resourceColumn: "p-scheduler-resource-column",
+  resourceColumns: "p-scheduler-resource-columns",
+  resourceColumnHeader: "p-scheduler-resource-column-header",
+  resourceRowDragOver: "p-scheduler-resource-row-drag-over",
+  resourceRowDropTarget: "p-scheduler-resource-row-drop-target",
+  resourceRowSelected: "p-scheduler-resource-row-selected",
+  resourceTreeLine: "p-scheduler-resource-tree-line",
+  resourceDropIndicator: "p-scheduler-resource-drop-indicator",
+  // Resource view (Day/Week)
+  resourceView: "p-scheduler-resource-view",
+  resourceWeekView: "p-scheduler-resource-week-view",
+  resourceBody: "p-scheduler-resource-body",
+  resourceGrid: "p-scheduler-resource-grid",
+  resourceGutter: "p-scheduler-resource-gutter",
+  resourceGutterSlot: "p-scheduler-resource-gutter-slot",
+  resourceSlots: "p-scheduler-resource-slots",
+  resourceSlot: "p-scheduler-resource-slot",
+  resourceSlotHalf: "p-scheduler-resource-slot-half",
+  resourceSuperColumn: "p-scheduler-resource-super-column",
+  resourceDayColumn: "p-scheduler-resource-day-column",
+  resourceDayHeaders: "p-scheduler-resource-day-headers",
+  resourceDayHeadersGroup: "p-scheduler-resource-day-headers-group",
+  resourceDayHeadersGutter: "p-scheduler-resource-day-headers-gutter",
+  resourceDayHeadersContent: "p-scheduler-resource-day-headers-content",
+  resourceDayHeader: "p-scheduler-resource-day-header",
+  resourceDayHeaderDay: "p-scheduler-resource-day-header-day",
+  resourceDayHeaderDate: "p-scheduler-resource-day-header-date",
+  resourceHeader: "p-scheduler-resource-header",
+  resourceHeaderGutter: "p-scheduler-resource-header-gutter",
+  resourceHeaderCell: "p-scheduler-resource-header-cell",
+  resourceHeaderCellLeaf: "p-scheduler-resource-header-cell-leaf",
+  resourceHeaderCellParent: "p-scheduler-resource-header-cell-parent",
+  resourceHeaderContent: "p-scheduler-resource-header-content",
+  resourceHeaderTitle: "p-scheduler-resource-header-title",
+  resourceRowsArea: "p-scheduler-resource-rows-area",
+  resourceAllday: "p-scheduler-resource-allday",
+  resourceAlldayGroup: "p-scheduler-resource-allday-group",
+  resourceAlldayGutter: "p-scheduler-resource-allday-gutter",
+  resourceAlldayContent: "p-scheduler-resource-allday-content",
+  resourceAlldayCell: "p-scheduler-resource-allday-cell",
+  resourceScrollContainer: "p-scheduler-resource-scroll-container",
+  resourceScrollContent: "p-scheduler-resource-scroll-content",
+  resourceHeaderBand: "p-scheduler-resource-header-band",
+  // Resource month view
+  resourceMonthView: "p-scheduler-resource-month-view",
+  resourceMonthBody: "p-scheduler-resource-month-body",
+  resourceMonthColumn: "p-scheduler-resource-month-column",
+  resourceMonthContent: "p-scheduler-resource-month-content",
+  resourceMonthGutter: "p-scheduler-resource-month-gutter",
+  resourceMonthWeekdays: "p-scheduler-resource-month-weekdays",
+  resourceMonthWeekdaysGroup: "p-scheduler-resource-month-weekdays-group",
+  resourceMonthWeekdaysGutter: "p-scheduler-resource-month-weekdays-gutter",
+  resourceMonthWeekdaysContent: "p-scheduler-resource-month-weekdays-content",
+  resourceMonthWeekday: "p-scheduler-resource-month-weekday",
+  resourceMonthWeek: "p-scheduler-resource-month-week",
+  resourceMonthWeekLabel: "p-scheduler-resource-month-week-label",
+  resourceMonthDay: "p-scheduler-resource-month-day",
+  resourceMonthDayNumber: "p-scheduler-resource-month-day-number",
+  resourceMonthDayEvents: "p-scheduler-resource-month-day-events",
+  resourceMonthMoreLink: "p-scheduler-resource-month-more-link",
+  // Date grouping views
+  dateView: "p-scheduler-date-view",
+  dateDayView: "p-scheduler-date-day-view",
+  dateWeekView: "p-scheduler-date-week-view",
+  dateMonthView: "p-scheduler-date-month-view",
+  dateScrollContainer: "p-scheduler-date-scroll-container",
+  dateScrollContent: "p-scheduler-date-scroll-content",
+  dateHeaderBand: "p-scheduler-date-header-band",
+  dateBody: "p-scheduler-date-body",
+  dateColumns: "p-scheduler-date-columns",
+  dateColumn: "p-scheduler-date-column",
+  dateSuperColumn: "p-scheduler-date-super-column",
+  dateGrid: "p-scheduler-date-grid",
+  dateGutter: "p-scheduler-date-gutter",
+  dateGutterSlot: "p-scheduler-date-gutter-slot",
+  dateSlots: "p-scheduler-date-slots",
+  dateSlot: "p-scheduler-date-slot",
+  dateSlotHalf: "p-scheduler-date-slot-half",
+  dateDateHeader: "p-scheduler-date-date-header",
+  dateDateHeaderGutter: "p-scheduler-date-date-header-gutter",
+  dateDateHeaderCell: "p-scheduler-date-date-header-cell",
+  dateDateHeaderContent: "p-scheduler-date-date-header-content",
+  dateDateHeaderDayname: "p-scheduler-date-date-header-dayname",
+  dateDateHeaderNumber: "p-scheduler-date-date-header-number",
+  dateResourceHeader: "p-scheduler-date-resource-header",
+  dateResourceHeaderGroup: "p-scheduler-date-resource-header-group",
+  dateResourceHeaderGutter: "p-scheduler-date-resource-header-gutter",
+  dateResourceHeaderCell: "p-scheduler-date-resource-header-cell",
+  dateResourceHeaderContent: "p-scheduler-date-resource-header-content",
+  dateResourceHeaderTitle: "p-scheduler-date-resource-header-title",
+  dateAllday: "p-scheduler-date-allday",
+  dateAlldayGroup: "p-scheduler-date-allday-group",
+  dateAlldayGutter: "p-scheduler-date-allday-gutter",
+  dateAlldayContent: "p-scheduler-date-allday-content",
+  dateAlldayCell: "p-scheduler-date-allday-cell",
+  dateMonthBody: "p-scheduler-date-month-body",
+  dateMonthWeekdays: "p-scheduler-date-month-weekdays",
+  dateMonthWeekday: "p-scheduler-date-month-weekday",
+  dateMonthWeek: "p-scheduler-date-month-week",
+  dateMonthDay: "p-scheduler-date-month-day",
+  dateMonthDayNumber: "p-scheduler-date-month-day-number",
+  dateMonthDayEvents: "p-scheduler-date-month-day-events",
+  dateMonthDayGroup: "p-scheduler-date-month-day-group",
+  dateMonthDayResources: "p-scheduler-date-month-day-resources",
+  dateMonthMoreLink: "p-scheduler-date-month-more-link",
+  dateMonthResourceHeader: "p-scheduler-date-month-resource-header",
+  dateMonthResourceHeaderGroup: "p-scheduler-date-month-resource-header-group",
+  dateMonthResourceHeaderCell: "p-scheduler-date-month-resource-header-cell",
+  dateMonthResourceHeaderTitle: "p-scheduler-date-month-resource-header-title",
+  // Adaptive rendering
+  adaptiveContainer: "p-scheduler-adaptive",
+  adaptiveMobile: "p-scheduler-adaptive-mobile",
+  adaptiveDesktop: "p-scheduler-adaptive-desktop",
+  adaptiveSingle: "p-scheduler-adaptive-single",
+  adaptiveContained: "p-scheduler-adaptive-contained",
+  adaptiveSidebar: "p-scheduler-adaptive-sidebar",
+  adaptiveSidebarOpen: "p-scheduler-adaptive-sidebar-open",
+  adaptiveSidebarLeft: "p-scheduler-adaptive-sidebar-left",
+  adaptiveSidebarRight: "p-scheduler-adaptive-sidebar-right",
+  adaptiveSidebarOverlay: "p-scheduler-adaptive-sidebar-overlay",
+  adaptiveSidebarHeader: "p-scheduler-adaptive-sidebar-header",
+  adaptiveSidebarBody: "p-scheduler-adaptive-sidebar-body",
+  adaptiveSidebarClose: "p-scheduler-adaptive-sidebar-close",
+  adaptiveBreadcrumb: "p-scheduler-adaptive-breadcrumb",
+  adaptiveBreadcrumbList: "p-scheduler-adaptive-breadcrumb-list",
+  adaptiveBreadcrumbItem: "p-scheduler-adaptive-breadcrumb-item",
+  adaptiveBreadcrumbItemWrapper: "p-scheduler-adaptive-breadcrumb-item-wrapper",
+  adaptiveBreadcrumbSeparator: "p-scheduler-adaptive-breadcrumb-separator",
+  adaptiveBreadcrumbCurrent: "p-scheduler-adaptive-breadcrumb-current",
+  adaptiveMenuButton: "p-scheduler-adaptive-menu-button",
+  adaptiveSecondaryToolbar: "p-scheduler-adaptive-secondary-toolbar",
+  adaptiveResourceSelected: "p-scheduler-adaptive-resource-selected",
+  adaptiveSelectorWrapper: "p-scheduler-adaptive-selector-wrapper",
+  adaptiveCheckIcon: "p-scheduler-adaptive-check-icon",
+  // Appointment slots
+  appointmentSlots: "p-scheduler-appointment-slots",
+  appointmentSlot: "p-scheduler-appointment-slot",
+  appointmentSlotAvailable: "p-scheduler-appointment-slot-available",
+  appointmentSlotBooked: "p-scheduler-appointment-slot-booked",
+  appointmentSlotBlocked: "p-scheduler-appointment-slot-blocked",
+  appointmentSlotTentative: "p-scheduler-appointment-slot-tentative",
+  appointmentSlotCapacity: "p-scheduler-appointment-slot-capacity",
+  appointmentSlotIndicator: "p-scheduler-appointment-slot-indicator",
+  appointmentSlotIndicators: "p-scheduler-appointment-slot-indicators",
+  appointmentSlotOverlay: "p-scheduler-appointment-slot-overlay",
+  appointmentSlotGrid: "p-scheduler-appointment-slot-grid",
+  appointmentSlotSelected: "p-scheduler-appointment-slot-selected",
+  // Resource capacity & constraints
+  resourceCapacityIndicator: "p-scheduler-resource-capacity",
+  resourceCapacityFull: "p-scheduler-resource-capacity-full",
+  resourceCapacityNearFull: "p-scheduler-resource-capacity-near-full",
+  resourceCapacityAvailable: "p-scheduler-resource-capacity-available",
+  eventConflict: "p-scheduler-event-conflict",
+  eventDropPreviewInvalid: "p-scheduler-event-drop-preview-invalid",
+  resourceConstrained: "p-scheduler-resource-constrained",
+  // Event categories
+  categoryLegend: "p-scheduler-category-legend",
+  categoryLegendItem: "p-scheduler-category-legend-item",
+  categoryLegendItemActive: "p-scheduler-category-legend-item-active",
+  categoryLegendItemInactive: "p-scheduler-category-legend-item-inactive",
+  categoryLegendColor: "p-scheduler-category-legend-color",
+  categoryLegendIcon: "p-scheduler-category-legend-icon",
+  categoryLegendLabel: "p-scheduler-category-legend-label",
+  categoryLegendCount: "p-scheduler-category-legend-count",
+  categoryHover: "p-scheduler-category-hover",
+  eventCategorized: "p-scheduler-event-categorized",
+  eventCategoryHovered: "p-scheduler-event-category-hovered",
+  eventCategoryIcon: "p-scheduler-event-category-icon",
+  // Density & auto-height
+  densityMinimal: "p-scheduler-density-minimal",
+  densityCompact: "p-scheduler-density-compact",
+  densityStandard: "p-scheduler-density-standard",
+  densityComfortable: "p-scheduler-density-comfortable",
+  autoHeight: "p-scheduler-auto-height",
+  autoHeightAnimated: "p-scheduler-auto-height-animated",
+  autoHeightExpanded: "p-scheduler-auto-height-expanded",
+  autoHeightCollapsed: "p-scheduler-auto-height-collapsed",
+  stackingStack: "p-scheduler-stacking-stack",
+  stackingExpand: "p-scheduler-stacking-expand",
+  stackingCollapse: "p-scheduler-stacking-collapse",
+  eventStacked: "p-scheduler-event-stacked",
+  eventStackedFirst: "p-scheduler-event-stacked-first",
+  eventStackedLast: "p-scheduler-event-stacked-last",
+  overflowContainer: "p-scheduler-overflow-container",
+  overflowScroll: "p-scheduler-overflow-scroll",
+  overflowTooltip: "p-scheduler-overflow-tooltip",
+  overflowIndicator: "p-scheduler-overflow-indicator",
+  cellExpanded: "p-scheduler-cell-expanded",
+  cellCollapsed: "p-scheduler-cell-collapsed",
+  rowAutoHeight: "p-scheduler-row-auto-height",
+  eventCompact: "p-scheduler-event-compact",
+  eventComfortable: "p-scheduler-event-comfortable",
+  // Print
+  printing: "p-scheduler-printing",
+  printPageChromeActive: "p-scheduler-print-page-chrome-active",
+  printOrientationLandscape: "p-scheduler-print-orientation-landscape",
+  printOrientationPortrait: "p-scheduler-print-orientation-portrait",
+  printScaleCompact: "p-scheduler-print-scale-compact",
+  printScaleFit: "p-scheduler-print-scale-fit",
+  printPageChrome: "p-scheduler-print-page-chrome",
+  printPageChromeHeader: "p-scheduler-print-page-chrome-header",
+  printPageChromeBrand: "p-scheduler-print-page-chrome-brand",
+  printPageChromeLogo: "p-scheduler-print-page-chrome-logo",
+  printPageChromeLogoText: "p-scheduler-print-page-chrome-logo-text",
+  printPageChromeTitle: "p-scheduler-print-page-chrome-title",
+  printPageChromeSubtitle: "p-scheduler-print-page-chrome-subtitle",
+  printPageChromeMeta: "p-scheduler-print-page-chrome-meta",
+  printPageChromeFooter: "p-scheduler-print-page-chrome-footer",
+  printPageChromeFooterRight: "p-scheduler-print-page-chrome-footer-right",
+  printPageNumber: "p-scheduler-print-page-number",
+  printActiveBody: "p-scheduler-print-active",
+  printAncestor: "p-scheduler-print-ancestor",
+  printColor: "p-scheduler-print-color",
+  printHidden: "p-scheduler-print-hidden",
+  // Resource column behavior
+  resourceColumnsModeAuto: "p-scheduler-resource-columns-mode-auto",
+  resourceColumnsModeFixed: "p-scheduler-resource-columns-mode-fixed",
+  resourceColumnsModeMinmax: "p-scheduler-resource-columns-mode-minmax",
+  resourceColumnsOverflow: "p-scheduler-resource-columns-overflow",
+  // Adaptive transitions
+  overlayTransition: "p-scheduler-overlay",
+  sidebarTransition: "p-scheduler-sidebar"
+};
+var classes = schedulerClasses;
+
+export { classes, createScheduler, defaultSchedulerRefs, defaultSchedulerState, getSchedulerDefaultProp, resolveSchedulerProps, schedulerClasses, schedulerDefaultFactoryKeys, schedulerDefaultProps, schedulerPropKeys };