@primeui/scheduler-core 0.0.1-alpha.1

package/dist/utils/index.d.mts

@@ -0,0 +1,494 @@
+export { S as SchedulerGridCell, a as addDays, b as addHours, c as addMinutes, d as addMonths, e as addWeeks, f as addYears, g as applyDaysDelta, h as calculateDaysDelta, i as clampDate, j as differenceInDays, k as differenceInHours, l as differenceInMinutes, m as endOfDay, n as endOfMonth, o as endOfWeek, p as formatDateString, q as formatEventTime12h, r as formatGregorianDayNumber, s as formatGregorianMonthTitle, t as formatGregorianWeekday, u as formatGregorianYear, v as formatMonthYearTitle, w as formatWeekdayName, x as getDatesBetween, y as getDayHours, z as getDaysInMonth, A as getMonthDays, B as getMonthNames, C as getSchedulerGrid, D as getWeekDays, E as getWeekNumber, F as getWeekdayNames, G as getYearMonths, H as isAfter, I as isBefore, J as isBetween, K as isDateInRange, L as isSameDay, M as isSameMonth, N as isSameWeek, O as isSameYear, P as isToday, Q as isWeekend, R as minutesToPixels, T as minutesToTimeString, U as parseDate, V as parseTimeString, W as setTime, X as startOfDay, Y as startOfMonth, Z as startOfWeek, _ as timeStringToMinutes, $ as toDateString, a0 as toDateTimeString, a1 as toTimeString } from '../date-D_CjQPmM.mjs';
+import { SchedulerText } from '@primeui/scheduler-types/locale';
+export { SchedulerText } from '@primeui/scheduler-types/locale';
+import { BusinessHoursConfig, SchedulerViewType, SchedulerEvent, EventConstraint, EventAllowCallback, BusinessHours, BlockedIntervalsOptions, SelectConstraintConfig, SelectAllowCallback, TimeFormatOptions, BlockedInterval, ExpandedBlockedInterval, ConflictOptions, SchedulerResource, ConflictInfo, ResourceCapacityInfo, CategoryOptions, EventCategory, ExportOptions, ExportResult, CsvExportOptions, ICalExportOptions, JsonExportOptions, PdfExportOptions, PdfExportAdapter, XlsxExportOptions, XlsxExportAdapter, ImportMergeOptions, ImportResult, ImportValidationIssue, ImportValidationReport, CsvImportOptions, ICalImportOptions, JsonImportOptions, ImportMergePreview, AdaptiveRenderingOptions, AutoHeightOptions, StackingOptions, DensityMode, DensityConfig, CellRenderingInfo, AdaptiveRenderingState, StackingMode, DateRange, SchedulerCalendarMode, SchedulerDateSelectPayload, EventSlotDensity } from '@primeui/scheduler-types/scheduler';
+import { S as SchedulerCalendarDisplayConfigInput } from '../display-format-CLVvRt4I.mjs';
+export { D as DEFAULT_DATE_DISPLAY_OPTIONS, a as DEFAULT_DISPLAY_OPTIONS, b as DEFAULT_TIME_FORMAT_OPTIONS, c as SchedulerCalendarDisplayConfig, d as SchedulerDateFormatter, _ as __clearDateTimeFormatterCache, e as __getDateTimeFormatterCacheSize, f as createSchedulerDateFormatter, g as formatDate, h as formatDateRange, i as formatDayOfMonth, j as formatEventDateTime, k as formatHeaderTitle, l as formatMonth, m as formatMonthYear, n as formatSlotTime, o as formatTime, p as formatTimeRange, q as formatWeekday, r as getRelativeDay, s as normalizeDateDisplayOptions, t as normalizeDisplayOptions, u as normalizeTimeFormatOptions, v as resolveSchedulerCalendarDisplayConfig } from '../display-format-CLVvRt4I.mjs';
+export { A as AppointmentSlotDisplayLabels, a as AppointmentSlotDisplayOptions, b as AppointmentSlotIndicator, c as AppointmentSlotOverlay, D as DEFAULT_APPOINTMENT_SLOTS_OPTIONS, T as TimedOverlay, d as canBookSlot, e as createSlotFromTimeRange, g as generateAppointmentSlots, f as getAppointmentSlotDisplayLabels, h as getAppointmentSlotIndicators, i as getAppointmentSlotOverlays, j as getAvailableSlots, k as getSlotAtTime, l as getSlotById, m as getSlotCapacityDisplay, n as getSlotOverlayClasses, o as getSlotOverlayStyle, p as getSlotsForDay, q as getSlotsForTimeRange, r as getSlotsInTimeRange, s as getTimedBlockedIntervalsOverlays, t as getTimedBusinessHoursOverlays, u as isSlotInBlockedInterval, v as isSlotInBusinessHours, w as normalizeAppointmentSlotsOptions, x as updateSlotAvailability, y as updateSlotsAvailability } from '../overlay-BYM9B6nC.mjs';
+import { P as ParsedEvent } from '../event.utils-QSNdd-3W.mjs';
+import { ResourceTimelineOverlapPolicy } from '@primeui/scheduler-types/resource-runtime';
+export { ResourceTimelineOverlapPolicy } from '@primeui/scheduler-types/resource-runtime';
+import { SchedulerResource as SchedulerResource$1 } from '@primeui/scheduler-types/resource';
+import { WeekNumbering } from '@primeui/scheduler-types/date';
+export { WeekNumbering } from '@primeui/scheduler-types/date';
+import { e as SelectionState } from '../selection-CO_98HdS.mjs';
+export { S as SchedulerEventSurfaceCategory, a as SchedulerEventSurfaceContext, b as SchedulerEventSurfaceOptions, g as getSchedulerEventSurfaceStyle, r as resolveSchedulerEventSurfaceColor } from '../event-surface-_R_LHD95.mjs';
+
+/**
+ * Timezone utilities for calendar
+ *
+ * Uses native Intl.DateTimeFormat for timezone conversion and formatting.
+ * This avoids external dependencies while providing full timezone support.
+ */
+interface TimezoneInfo {
+    id: string;
+    offset: number;
+    offsetString: string;
+    name: string;
+    abbreviation: string;
+}
+declare function isValidTimezone(timezone: string): boolean;
+declare function getLocalTimezone(): string;
+declare function getTimezoneOffset(date: Date, timezone: string): number;
+declare function getTimezoneOffsetString(date: Date, timezone: string): string;
+declare function getTimezoneAbbreviation(date: Date, timezone: string): string;
+declare function getTimezoneName(date: Date, timezone: string, style?: 'short' | 'long'): string;
+declare function getTimezoneInfo(date: Date, timezone: string): TimezoneInfo;
+declare function formatInTimezone(date: Date, timezone: string, options?: Intl.DateTimeFormatOptions): string;
+declare function formatTimeInTimezone(date: Date, timezone: string, locale?: string): string;
+declare function formatDateInTimezone(date: Date, timezone: string, locale?: string): string;
+declare function formatDateTimeInTimezone(date: Date, timezone: string, locale?: string): string;
+declare function toTimezone(date: Date, fromTimezone: string, toTimezone: string): Date;
+declare function toUTC(date: Date, timezone: string): Date;
+declare function fromUTC(date: Date, timezone: string): Date;
+declare function toLocalTimezone(date: Date, fromTimezone: string): Date;
+declare function fromLocalTimezone(date: Date, targetTimezone: string): Date;
+declare function getDatePartsInTimezone(date: Date, timezone: string): {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    dayOfWeek: number;
+};
+declare function createDateInTimezone(timezone: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number): Date;
+declare function isSameDayInTimezone(d1: Date, d2: Date, timezone: string): boolean;
+declare function isTodayInTimezone(date: Date, timezone: string): boolean;
+declare function startOfDayInTimezone(date: Date, timezone: string): Date;
+declare function endOfDayInTimezone(date: Date, timezone: string): Date;
+declare function convertEventToDisplayTimezone<T extends {
+    start: Date;
+    end: Date;
+    timezone?: string;
+    durationMinutes?: number;
+    isMultiDay?: boolean;
+    spanDays?: number;
+}>(event: T, schedulerTimezone: string): T;
+declare function convertEventsToTimezone<T extends {
+    start: Date;
+    end: Date;
+    timezone?: string;
+    durationMinutes?: number;
+    isMultiDay?: boolean;
+    spanDays?: number;
+}>(events: T[], schedulerTimezone: string | undefined): T[];
+declare function getTimezoneDisplayLabel(timezone: string | undefined, displayTimezone?: string): string | null;
+declare const COMMON_TIMEZONES: string[];
+declare function getCommonTimezones(): TimezoneInfo[];
+declare function parseISOWithTimezone(isoString: string): {
+    date: Date;
+    timezone: string | null;
+};
+declare function toISOWithTimezone(date: Date, timezone: string): string;
+
+/**
+ * Locale utilities for Scheduler internationalization
+ *
+ * Provides Scheduler UI text, direction, and week-start defaults.
+ * Date/time formatting and calendar systems use native Intl.DateTimeFormat (see date.ts).
+ */
+
+interface SchedulerLocaleConfig {
+    code: string;
+    text: SchedulerText;
+    rtl: boolean;
+    firstDayOfWeek: number;
+}
+type LocaleRegistryEntry = Partial<Omit<SchedulerLocaleConfig, 'text'>> & {
+    text?: Partial<SchedulerText>;
+};
+declare function getLocaleConfig(locale: string): SchedulerLocaleConfig;
+declare function getSchedulerText(locale: string): SchedulerText;
+declare function resolveSchedulerText(locale: string, overrides?: Partial<SchedulerText>): SchedulerText;
+declare function isRTL(locale: string): boolean;
+declare function getDefaultFirstDayOfWeek(locale: string): number;
+declare function registerLocale(code: string, config: LocaleRegistryEntry): void;
+declare function getAvailableLocales(): string[];
+declare const defaultSchedulerText: SchedulerText;
+
+declare const DEFAULT_BUSINESS_HOURS: BusinessHoursConfig;
+declare function normalizeBusinessHours(businessHours: BusinessHours): BusinessHoursConfig[];
+declare function isWithinBusinessHours(date: Date, businessHours: BusinessHours): boolean;
+declare function isRangeWithinBusinessHours(start: Date, end: Date, businessHours: BusinessHours): boolean;
+declare function isTimeSlotInBusinessHours(date: Date, slotDuration: number, businessHours: BusinessHours): boolean;
+declare function getBusinessHoursForDay(dayOfWeek: number, businessHours: BusinessHours): {
+    start: string;
+    end: string;
+} | null;
+declare function isDateWithinConstraint(date: Date, constraint: SelectConstraintConfig | undefined): boolean;
+declare function canSelect(start: Date, end: Date, allDay: boolean, view: SchedulerViewType, selectConstraint: SelectConstraintConfig | undefined, selectAllow: SelectAllowCallback | undefined): boolean;
+declare function canDropEvent(start: Date, end: Date, allDay: boolean, view: SchedulerViewType, event: SchedulerEvent, eventConstraint: EventConstraint | undefined, eventAllow: EventAllowCallback | undefined, businessHours: BusinessHours, blockedIntervals?: BlockedIntervalsOptions, resourceId?: string | number): boolean;
+interface TimeSlotBusinessHoursInfo {
+    isBusinessHour: boolean;
+    isBusinessStart: boolean;
+    isBusinessEnd: boolean;
+}
+declare function getTimeSlotBusinessHoursInfo(date: Date, slotDuration: number, businessHours: BusinessHours): TimeSlotBusinessHoursInfo;
+
+interface BlockedIntervalDisplayOptions extends SchedulerCalendarDisplayConfigInput {
+    referenceDate?: Date;
+    timeFormat?: TimeFormatOptions;
+    dateOptions?: Intl.DateTimeFormatOptions;
+    includeDate?: boolean;
+}
+interface BlockedIntervalDisplayLabels {
+    titleLabel: string;
+    dateLabel: string;
+    timeRangeLabel: string;
+    summaryLabel: string;
+    ariaLabel: string;
+}
+declare function getBlockedIntervalDisplayLabels(interval: BlockedInterval | ExpandedBlockedInterval, options?: BlockedIntervalDisplayOptions): BlockedIntervalDisplayLabels;
+declare function expandBlockedInterval(interval: BlockedInterval, rangeStart: Date, rangeEnd: Date, maxOccurrences?: number): ExpandedBlockedInterval[];
+declare function getExpandedBlockedIntervals(options: BlockedIntervalsOptions | undefined, rangeStart: Date, rangeEnd: Date): ExpandedBlockedInterval[];
+declare function getBlockedIntervalsForDay(options: BlockedIntervalsOptions | undefined, date: Date, resourceId?: string | number): ExpandedBlockedInterval[];
+declare function isTimeWithinBlockedInterval(date: Date, options: BlockedIntervalsOptions | undefined, resourceId?: string | number): boolean;
+declare function isRangeWithinBlockedInterval(start: Date, end: Date, options: BlockedIntervalsOptions | undefined, resourceId?: string | number): boolean;
+declare function canDropWithBlockedIntervals(start: Date, end: Date, _allDay: boolean, _view: SchedulerViewType, options: BlockedIntervalsOptions | undefined, resourceId?: string | number): boolean;
+declare function canCreateWithBlockedIntervals(start: Date, end: Date, options: BlockedIntervalsOptions | undefined, resourceId?: string | number): boolean;
+
+declare const DEFAULT_CONFLICT_OPTIONS: ConflictOptions;
+declare function normalizeConflictOptions(options: boolean | Partial<ConflictOptions> | undefined): ConflictOptions;
+declare function checkCapacityConstraint(resource: SchedulerResource, event: SchedulerEvent, allEvents: SchedulerEvent[]): ConflictInfo | null;
+declare function checkDailyHoursConstraint(resource: SchedulerResource, event: SchedulerEvent, allEvents: SchedulerEvent[]): ConflictInfo | null;
+declare function checkDailyEventsConstraint(resource: SchedulerResource, event: SchedulerEvent, allEvents: SchedulerEvent[]): ConflictInfo | null;
+declare function checkOverlapConstraint(resource: SchedulerResource, event: SchedulerEvent, allEvents: SchedulerEvent[]): ConflictInfo | null;
+declare function checkAvailabilityConstraint(resource: SchedulerResource, event: SchedulerEvent): ConflictInfo | null;
+declare function checkEventDurationConstraint(resource: SchedulerResource, event: SchedulerEvent): ConflictInfo | null;
+declare function checkSkillConstraint(resource: SchedulerResource, event: SchedulerEvent): ConflictInfo | null;
+declare function validateResourceConstraints(event: SchedulerEvent, resource: SchedulerResource, allEvents: SchedulerEvent[], options: ConflictOptions): ConflictInfo[];
+declare function getResourceCapacity(resource: SchedulerResource, date: Date, allEvents: SchedulerEvent[]): ResourceCapacityInfo;
+declare function getCapacityStatus(info: ResourceCapacityInfo): 'available' | 'near-full' | 'full';
+declare function canDropEventWithResourceConstraints(event: SchedulerEvent, resource: SchedulerResource | undefined, allEvents: SchedulerEvent[], options: ConflictOptions): {
+    canDrop: boolean;
+    conflicts: ConflictInfo[];
+};
+
+declare const DEFAULT_CATEGORY_OPTIONS: CategoryOptions;
+declare function normalizeCategoryOptions(options: Partial<CategoryOptions> | undefined): CategoryOptions;
+declare function getCategoryById(categories: EventCategory[], id: string | number | undefined): EventCategory | undefined;
+declare function getCategoriesByIds(categories: EventCategory[], ids: (string | number)[] | undefined): EventCategory[];
+declare function getEventCategory(event: SchedulerEvent, categories: EventCategory[], categoryField?: string): EventCategory | undefined;
+declare function getEventCategories(event: SchedulerEvent, categories: EventCategory[], categoryField?: string, allowMultiple?: boolean): EventCategory[];
+declare function getEventCategoryColor(event: SchedulerEvent, categories: EventCategory[], categoryField?: string): string | undefined;
+declare function getEventCategoryTextColor(event: SchedulerEvent, categories: EventCategory[], categoryField?: string): string | undefined;
+declare function getEventCategoryBorderColor(event: SchedulerEvent, categories: EventCategory[], categoryField?: string): string | undefined;
+declare function getEventCategoryIcon(event: SchedulerEvent, categories: EventCategory[], categoryField?: string): string | undefined;
+interface EventCategoryStyle {
+    background?: string;
+    color?: string;
+    borderColor?: string;
+    borderLeftColor?: string;
+}
+declare function getEventCategoryStyle(event: SchedulerEvent, categories: EventCategory[], categoryField?: string): EventCategoryStyle;
+declare function filterEventsByCategory(events: SchedulerEvent[], categoryIds: (string | number)[], categories: EventCategory[], categoryField?: string, allowMultiple?: boolean): SchedulerEvent[];
+declare function filterEventsByCategoryExclude(events: SchedulerEvent[], excludeCategoryIds: (string | number)[], categories: EventCategory[], categoryField?: string, allowMultiple?: boolean): SchedulerEvent[];
+declare function groupEventsByCategory(events: SchedulerEvent[], categories: EventCategory[], categoryField?: string): Map<string | number | 'uncategorized', SchedulerEvent[]>;
+declare function getCategoryCounts(events: SchedulerEvent[], categories: EventCategory[], categoryField?: string): Map<string | number, number>;
+declare function getSortedCategories(categories: EventCategory[]): EventCategory[];
+declare function calculateContrastTextColor(backgroundColor: string): string;
+declare function getCategoryWithAutoTextColor(category: EventCategory): EventCategory;
+declare function getCategoriesWithAutoTextColor(categories: EventCategory[]): EventCategory[];
+declare function markSchedulerAutoTextColor<T extends SchedulerEvent>(event: T): T;
+declare function isSchedulerAutoTextColor(event: SchedulerEvent | undefined): boolean;
+
+declare function exportToIcal(events: SchedulerEvent[], options?: ICalExportOptions): ExportResult;
+declare function exportToJson(events: SchedulerEvent[], options?: JsonExportOptions, resources?: SchedulerResource[], categories?: EventCategory[]): ExportResult;
+declare function exportToCsv(events: SchedulerEvent[], options?: CsvExportOptions): ExportResult;
+declare function prepareXlsxData(events: SchedulerEvent[], options?: XlsxExportOptions, resources?: SchedulerResource[], categories?: EventCategory[]): {
+    sheets: {
+        name: string;
+        headers: string[];
+        rows: (string | number | boolean)[][];
+    }[];
+};
+declare function exportToXlsx(events: SchedulerEvent[], options: XlsxExportOptions | undefined, adapter: XlsxExportAdapter, resources?: SchedulerResource[], categories?: EventCategory[]): Promise<ExportResult>;
+declare function preparePdfData(events: SchedulerEvent[], options?: PdfExportOptions, resources?: SchedulerResource[], categories?: EventCategory[]): {
+    headers: string[];
+    rows: string[][];
+    title?: string;
+    dateRange?: string;
+};
+declare function exportToPdf(events: SchedulerEvent[], options: PdfExportOptions | undefined, adapter: PdfExportAdapter, resources?: SchedulerResource[], categories?: EventCategory[]): Promise<ExportResult>;
+declare function exportScheduler(events: SchedulerEvent[], options: ExportOptions, resources?: SchedulerResource[], categories?: EventCategory[]): ExportResult;
+
+declare function importFromIcal(content: string | File, options?: ICalImportOptions): Promise<ImportResult>;
+declare function importFromCsv(content: string | File, options?: CsvImportOptions): Promise<ImportResult>;
+declare function importFromJson(content: string | File, options?: JsonImportOptions): Promise<ImportResult>;
+type ImportFormat = 'ical' | 'json' | 'csv';
+declare function detectImportFormat(filename: string): ImportFormat | null;
+declare function importScheduler(file: File, options?: ICalImportOptions | CsvImportOptions | JsonImportOptions): Promise<ImportResult>;
+declare function validateImportResult(result: ImportResult): {
+    isValid: boolean;
+    summary: string;
+};
+declare function buildImportValidationReport(result: ImportResult, additionalIssues?: ImportValidationIssue[]): ImportValidationReport;
+declare function previewImportMerge(existingEvents: SchedulerEvent[], importedEvents: SchedulerEvent[], options?: ImportMergeOptions): ImportMergePreview;
+declare function applyImportMerge(existingEvents: SchedulerEvent[], importedEvents: SchedulerEvent[], options?: Omit<ImportMergeOptions, 'dryRun'>): SchedulerEvent[];
+
+declare const DENSITY_CONFIGS: Record<DensityMode, DensityConfig>;
+declare const DEFAULT_AUTO_HEIGHT_OPTIONS: Required<AutoHeightOptions>;
+declare const DEFAULT_STACKING_OPTIONS: Required<StackingOptions>;
+declare const DEFAULT_ADAPTIVE_OPTIONS: Required<AdaptiveRenderingOptions>;
+declare function normalizeAutoHeightOptions(options: boolean | AutoHeightOptions | undefined): Required<AutoHeightOptions>;
+declare function normalizeStackingOptions(options: StackingOptions | undefined): Required<StackingOptions>;
+declare function normalizeAdaptiveOptions(options: AdaptiveRenderingOptions | undefined): Required<AdaptiveRenderingOptions>;
+declare function getDensityConfig(density: DensityMode): DensityConfig;
+declare function getDensityCSSVars(density: DensityMode): Record<string, string>;
+declare function getDensityFromContainerWidth(width: number, breakpoints: {
+    compact?: number;
+    comfortable?: number;
+}): DensityMode;
+declare function calculateAutoHeight(events: (SchedulerEvent | ParsedEvent)[], options: Required<AutoHeightOptions>, densityConfig: DensityConfig): number;
+declare function getVisibleEvents<T extends SchedulerEvent | ParsedEvent>(events: T[], stackingOptions: Required<StackingOptions>, autoHeightOptions: Required<AutoHeightOptions>): {
+    visible: T[];
+    overflow: T[];
+};
+declare function getMoreText(count: number, moreText: string | ((count: number) => string)): string;
+declare function getStackedEventStyle(index: number, totalVisible: number, density: DensityMode, isStacked: boolean): Record<string, string>;
+declare function calculateCellRenderingInfo(date: Date, events: SchedulerEvent[], options: Required<AdaptiveRenderingOptions>): CellRenderingInfo;
+declare function createAdaptiveRenderingState(containerWidth: number, containerHeight: number, events: SchedulerEvent[], options: Required<AdaptiveRenderingOptions>): AdaptiveRenderingState;
+declare function getDensityClasses(density: DensityMode): string;
+declare function getStackingClasses(mode: StackingMode): string;
+declare function getAutoHeightClasses(options: Required<AutoHeightOptions>, isExpanded: boolean): string[];
+declare function getEventDensityClasses(density: DensityMode): string[];
+declare function calculateWeekViewAutoHeight(dayEvents: Map<number, SchedulerEvent[]>, options: Required<AdaptiveRenderingOptions>): number;
+declare function calculateTimelineRowHeight(events: SchedulerEvent[], options: Required<AdaptiveRenderingOptions>): number;
+interface TimelineEventWithPosition {
+    event: SchedulerEvent;
+    left: number;
+    width: number;
+}
+declare function calculateMaxOverlappingEvents(events: TimelineEventWithPosition[]): number;
+declare function assignEventLanes(events: TimelineEventWithPosition[]): Map<string | number, number>;
+declare function calculateResourceRowAutoHeight(maxOverlapping: number, eventHeight: number, eventGap: number, rowPadding: number, minHeight: number): number;
+
+type PrintOrientationMode = 'auto' | 'portrait' | 'landscape';
+type ResolvedPrintOrientation = 'portrait' | 'landscape';
+type PrintScaleMode = 'auto' | 'standard' | 'compact' | 'fit';
+type ResolvedPrintScaleMode = 'standard' | 'compact' | 'fit';
+interface PrintLayoutOptions {
+    orientation?: PrintOrientationMode;
+    scale?: PrintScaleMode | number;
+}
+interface PrintPageChromeOptions {
+    enabled?: boolean;
+    logoText?: string;
+    logoUrl?: string;
+    headerTitle?: string;
+    headerSubtitle?: string;
+    showGeneratedAt?: boolean;
+    generatedAtLabel?: string;
+    showTimezone?: boolean;
+    timezoneLabel?: string;
+    showFilters?: boolean;
+    filters?: string[];
+    filtersLabel?: string;
+    footerLeft?: string;
+    footerCenter?: string;
+    footerRight?: string;
+    showPageNumbers?: boolean;
+}
+interface PrintInvocationOptions {
+    color?: boolean;
+    layout?: PrintLayoutOptions;
+    pageChrome?: boolean | PrintPageChromeOptions;
+}
+interface ResolvedPrintLayoutOptions {
+    orientation: ResolvedPrintOrientation;
+    scaleMode: ResolvedPrintScaleMode;
+    scaleFactor: number;
+}
+interface ResolvedPrintPageChromeState {
+    logoText: string | null;
+    logoUrl: string | null;
+    headerTitle: string;
+    headerSubtitle: string | null;
+    generatedAtText: string | null;
+    timezoneText: string | null;
+    filtersText: string | null;
+    footerLeftText: string;
+    footerCenterText: string;
+    footerRightText: string;
+    showPageNumbers: boolean;
+}
+interface ResolvePrintPageChromeStateInput {
+    pageChrome: boolean | PrintPageChromeOptions | undefined;
+    title: string;
+    view: SchedulerViewType;
+    range: DateRange;
+    locale: string;
+    calendarDisplayConfig?: SchedulerCalendarDisplayConfigInput;
+    timezone?: string;
+    timezoneLabel?: string | null;
+    viewLabel?: string;
+    filters?: string[];
+    now?: Date;
+}
+interface ResolvePrintRuntimeStateInput {
+    view: SchedulerViewType;
+    options?: PrintInvocationOptions;
+    pageChromeContext: Omit<ResolvePrintPageChromeStateInput, 'pageChrome'>;
+}
+interface ResolvedPrintRuntimeState {
+    orientation: ResolvedPrintOrientation;
+    scaleMode: ResolvedPrintScaleMode;
+    scaleFactor: number;
+    pageChromeState: ResolvedPrintPageChromeState | null;
+}
+interface PrintFilterCategoryOption {
+    id: string | number;
+    name: string;
+}
+interface ResolvePrintFiltersInput {
+    pageChromeOptions?: PrintPageChromeOptions;
+    categoryFilterable?: boolean;
+    activeCategoryIds?: (string | number)[];
+    categories?: PrintFilterCategoryOption[];
+}
+declare function clampPrintScaleFactor(value: number): number;
+declare function resolvePrintOrientation(view: SchedulerViewType, layout?: PrintLayoutOptions): ResolvedPrintOrientation;
+declare function resolvePrintScale(view: SchedulerViewType, layout?: PrintLayoutOptions): {
+    mode: ResolvedPrintScaleMode;
+    factor: number;
+};
+declare function formatPrintDateTime(date: Date, locale: string, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatPrintDate(date: Date, locale: string, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatPrintRange(range: DateRange, locale: string, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function resolvePrintFilters(input: ResolvePrintFiltersInput): string[];
+declare function resolvePrintPageStyleRule(orientation: ResolvedPrintOrientation, margin?: string): string;
+declare function resolvePrintPageChromeState(input: ResolvePrintPageChromeStateInput): ResolvedPrintPageChromeState | null;
+declare function resolvePrintRuntimeState(input: ResolvePrintRuntimeStateInput): ResolvedPrintRuntimeState;
+
+interface PrintSessionState {
+    orientation: ResolvedPrintOrientation;
+    scaleMode: ResolvedPrintScaleMode;
+    scaleFactor: number;
+    pageChromeState: ResolvedPrintPageChromeState | null;
+    pageStyleRule: string;
+}
+interface ResolvePrintSessionInput {
+    view: SchedulerViewType;
+    options?: PrintInvocationOptions;
+    pageChromeContext: Omit<ResolvePrintPageChromeStateInput, 'pageChrome'>;
+}
+type PrintColorAction = {
+    type: 'set';
+    restoreAction: 'add' | 'remove';
+} | {
+    type: 'unset';
+    restoreAction: 'add' | 'remove';
+} | {
+    type: 'none';
+};
+declare function resolvePrintSession(input: ResolvePrintSessionInput): PrintSessionState;
+declare function getIdlePrintSessionState(): PrintSessionState;
+declare function resolvePrintColorAction(colorOption: boolean | undefined, hadColorClass: boolean): PrintColorAction;
+
+declare function toCssLength(value: number | string | undefined, fallback: string): string;
+declare function toNumber(value: number | string | undefined, fallback: number): number;
+declare function hasGroupingFieldValue(resourceList: SchedulerResource$1[], fieldName: string): boolean;
+declare function resolveAutoResourceGroupingField(resourceList: SchedulerResource$1[], explicitField?: string): string | undefined;
+declare function getEventResourceIds(event: SchedulerEvent): (string | number)[];
+declare function getPrimaryResourceId(event: SchedulerEvent): string | number | undefined;
+declare function applyDefaultResourceDrop(payload: {
+    event: SchedulerEvent;
+    oldEvent: SchedulerEvent;
+    newResource?: Pick<SchedulerResource$1, 'id'> | undefined;
+}): SchedulerEvent;
+declare function resolveOverlapPolicy(policy: ResourceTimelineOverlapPolicy, rowAutoHeight: boolean): 'allow' | 'prevent';
+declare function eventsTimeOverlap(startA: Date, endA: Date, startB: Date, endB: Date): boolean;
+declare function findOverlappingEventsInResource(candidate: SchedulerEvent, events: SchedulerEvent[], resourceId: string | number, excludeEventIds?: (string | number)[]): SchedulerEvent[];
+declare function hasOverlapInAnyAssignedResource(candidate: SchedulerEvent, events: SchedulerEvent[], excludeEventIds?: (string | number)[]): boolean;
+
+interface ResolveDaysOfWeekForViewInput {
+    view: SchedulerViewType;
+    dateGroupingDaysOfWeek: number[];
+    daysOfWeek?: number[];
+}
+interface ResolveCurrentViewRangeInput {
+    view: SchedulerViewType;
+    currentDate: Date;
+    eventList: SchedulerEvent[];
+    locale: string;
+    firstDayOfWeek: number;
+    weekNumbers: boolean;
+    weekNumbering: WeekNumbering;
+    minDate?: Date | null;
+    maxDate?: Date | null;
+    slotDuration: number;
+    slotMinTime: string;
+    slotMaxTime: string;
+    daysOfWeek?: number[];
+    numberOfDays?: number;
+    dateGroupingDaysOfWeek: number[];
+    calendar?: SchedulerCalendarMode;
+}
+interface ResolveCalendarViewRangeInput {
+    view: SchedulerViewType;
+    currentDate: Date;
+    locale: string;
+    calendar?: SchedulerCalendarMode;
+    firstDayOfWeek: number;
+    daysOfWeek?: number[];
+}
+declare function isTimelineLikeView(view: SchedulerViewType): boolean;
+declare function isResourceLikeView(view: SchedulerViewType): boolean;
+declare function isTimedCreateView(view: SchedulerViewType): boolean;
+declare function isDirectTimeSelectionView(view: SchedulerViewType): boolean;
+declare function getSchedulerWeekendToggleView(view: SchedulerViewType): SchedulerViewType | null;
+declare function resolveClickCreateEnd(start: Date, view: SchedulerViewType, slotDuration: number, timelineSlotDuration: number): Date;
+declare function resolveDaysOfWeekForView(input: ResolveDaysOfWeekForViewInput): number[] | undefined;
+declare function resolveCalendarViewRange(input: ResolveCalendarViewRangeInput): DateRange;
+declare function resolveCurrentViewRange(input: ResolveCurrentViewRangeInput): DateRange;
+
+type SelectionEmitOutcome = {
+    type: 'select';
+    payload: SchedulerDateSelectPayload;
+} | {
+    type: 'unselect';
+    payload: {
+        view: SchedulerViewType;
+    };
+};
+declare function toDateOnlyString(date: Date): string;
+declare function canSelectForView(start: Date, end: Date, allDay: boolean, view: SchedulerViewType, selectConstraint?: SelectConstraintConfig, selectAllow?: SelectAllowCallback): boolean;
+declare function resolveSelectionEmitOutcome(state: SelectionState, fallbackStart: Date, fallbackEnd: Date, allDay: boolean, view: SchedulerViewType): SelectionEmitOutcome;
+
+interface ResolveEventDensityOptions {
+    availableHeight?: number;
+    availableWidth?: number;
+    view?: SchedulerViewType;
+}
+declare function resolveEventDensity(options: ResolveEventDensityOptions): EventSlotDensity;
+type TimelineDefaultTextMode = 'title-only' | 'title-time';
+declare function resolveTimelineDefaultTextMode(_options?: {
+    availableHeight?: number;
+    availableWidth?: number;
+}): TimelineDefaultTextMode;
+type TimedColumnTextMode = 'title-only' | 'title-time';
+declare function resolveTimedColumnTextMode(options: {
+    availableHeight: number;
+}): TimedColumnTextMode;
+
+type LaneGeometryMode = 'date-day' | 'date-week' | 'date-month' | 'resource-day' | 'resource-week' | 'resource-month';
+interface LaneGeometry {
+    groupCount: number;
+    leavesPerGroup: number;
+    totalLeafColumns: number;
+    cssVars: Record<string, string>;
+}
+declare function resolveGroupedLaneGeometry(opts: {
+    dayCount: number;
+    resourceLeafCount: number;
+    mode: LaneGeometryMode;
+    dateColumnMinWidth?: string;
+    resourceColumnMinWidth?: string;
+    resourceGroupMinWidth?: string;
+    resourceDayMinWidth?: string;
+}): LaneGeometry;
+
+declare function sortMorePopoverEvents(events: SchedulerEvent[]): SchedulerEvent[];
+
+export { type BlockedIntervalDisplayLabels, type BlockedIntervalDisplayOptions, COMMON_TIMEZONES, DEFAULT_ADAPTIVE_OPTIONS, DEFAULT_AUTO_HEIGHT_OPTIONS, DEFAULT_BUSINESS_HOURS, DEFAULT_CATEGORY_OPTIONS, DEFAULT_CONFLICT_OPTIONS, DEFAULT_STACKING_OPTIONS, DENSITY_CONFIGS, type EventCategoryStyle, type ImportFormat, type LaneGeometry, type LaneGeometryMode, type PrintColorAction, type PrintFilterCategoryOption, type PrintInvocationOptions, type PrintLayoutOptions, type PrintOrientationMode, type PrintPageChromeOptions, type PrintScaleMode, type PrintSessionState, type ResolveCalendarViewRangeInput, type ResolveCurrentViewRangeInput, type ResolveDaysOfWeekForViewInput, type ResolveEventDensityOptions, type ResolvePrintFiltersInput, type ResolvePrintPageChromeStateInput, type ResolvePrintRuntimeStateInput, type ResolvePrintSessionInput, type ResolvedPrintLayoutOptions, type ResolvedPrintOrientation, type ResolvedPrintPageChromeState, type ResolvedPrintRuntimeState, type ResolvedPrintScaleMode, SchedulerCalendarDisplayConfigInput, type SchedulerLocaleConfig, type SelectionEmitOutcome, type TimeSlotBusinessHoursInfo, type TimedColumnTextMode, type TimelineDefaultTextMode, type TimelineEventWithPosition, type TimezoneInfo, applyDefaultResourceDrop, applyImportMerge, assignEventLanes, buildImportValidationReport, calculateAutoHeight, calculateCellRenderingInfo, calculateContrastTextColor, calculateMaxOverlappingEvents, calculateResourceRowAutoHeight, calculateTimelineRowHeight, calculateWeekViewAutoHeight, canCreateWithBlockedIntervals, canDropEvent, canDropEventWithResourceConstraints, canDropWithBlockedIntervals, canSelect, canSelectForView, checkAvailabilityConstraint, checkCapacityConstraint, checkDailyEventsConstraint, checkDailyHoursConstraint, checkEventDurationConstraint, checkOverlapConstraint, checkSkillConstraint, clampPrintScaleFactor, convertEventToDisplayTimezone, convertEventsToTimezone, createAdaptiveRenderingState, createDateInTimezone, defaultSchedulerText, detectImportFormat, endOfDayInTimezone, eventsTimeOverlap, expandBlockedInterval, exportScheduler, exportToCsv, exportToIcal, exportToJson, exportToPdf, exportToXlsx, filterEventsByCategory, filterEventsByCategoryExclude, findOverlappingEventsInResource, formatDateInTimezone, formatDateTimeInTimezone, formatInTimezone, formatPrintDate, formatPrintDateTime, formatPrintRange, formatTimeInTimezone, fromLocalTimezone, fromUTC, getAutoHeightClasses, getAvailableLocales, getBlockedIntervalDisplayLabels, getBlockedIntervalsForDay, getBusinessHoursForDay, getCapacityStatus, getCategoriesByIds, getCategoriesWithAutoTextColor, getCategoryById, getCategoryCounts, getCategoryWithAutoTextColor, getCommonTimezones, getDatePartsInTimezone, getDefaultFirstDayOfWeek, getDensityCSSVars, getDensityClasses, getDensityConfig, getDensityFromContainerWidth, getEventCategories, getEventCategory, getEventCategoryBorderColor, getEventCategoryColor, getEventCategoryIcon, getEventCategoryStyle, getEventCategoryTextColor, getEventDensityClasses, getEventResourceIds, getExpandedBlockedIntervals, getIdlePrintSessionState, getLocalTimezone, getLocaleConfig, getMoreText, getPrimaryResourceId, getResourceCapacity, getSchedulerText, getSchedulerWeekendToggleView, getSortedCategories, getStackedEventStyle, getStackingClasses, getTimeSlotBusinessHoursInfo, getTimezoneAbbreviation, getTimezoneDisplayLabel, getTimezoneInfo, getTimezoneName, getTimezoneOffset, getTimezoneOffsetString, getVisibleEvents, groupEventsByCategory, hasGroupingFieldValue, hasOverlapInAnyAssignedResource, importFromCsv, importFromIcal, importFromJson, importScheduler, isDateWithinConstraint, isDirectTimeSelectionView, isRTL, isRangeWithinBlockedInterval, isRangeWithinBusinessHours, isResourceLikeView, isSameDayInTimezone, isSchedulerAutoTextColor, isTimeSlotInBusinessHours, isTimeWithinBlockedInterval, isTimedCreateView, isTimelineLikeView, isTodayInTimezone, isValidTimezone, isWithinBusinessHours, markSchedulerAutoTextColor, normalizeAdaptiveOptions, normalizeAutoHeightOptions, normalizeBusinessHours, normalizeCategoryOptions, normalizeConflictOptions, normalizeStackingOptions, parseISOWithTimezone, preparePdfData, prepareXlsxData, previewImportMerge, registerLocale, resolveAutoResourceGroupingField, resolveCalendarViewRange, resolveClickCreateEnd, resolveCurrentViewRange, resolveDaysOfWeekForView, resolveEventDensity, resolveGroupedLaneGeometry, resolveOverlapPolicy, resolvePrintColorAction, resolvePrintFilters, resolvePrintOrientation, resolvePrintPageChromeState, resolvePrintPageStyleRule, resolvePrintRuntimeState, resolvePrintScale, resolvePrintSession, resolveSchedulerText, resolveSelectionEmitOutcome, resolveTimedColumnTextMode, resolveTimelineDefaultTextMode, sortMorePopoverEvents, startOfDayInTimezone, toCssLength, toDateOnlyString, toISOWithTimezone, toLocalTimezone, toNumber, toTimezone, toUTC, validateImportResult, validateResourceConstraints };

package/dist/utils/index.mjs

@@ -0,0 +1,17 @@
+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, canDropEventWithResourceConstraints, checkAvailabilityConstraint, checkCapacityConstraint, checkDailyEventsConstraint, checkDailyHoursConstraint, checkEventDurationConstraint, checkOverlapConstraint, checkSkillConstraint, getCapacityStatus, getResourceCapacity, normalizeConflictOptions, validateResourceConstraints } from '../chunk-NX46LPLF.mjs';
+import '../chunk-ZUKUKGNK.mjs';
+import '../chunk-6PK5WSKT.mjs';
+import '../chunk-6OZAPQZ5.mjs';
+import '../chunk-NMX4BW42.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';
+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';
+import '../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';
+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 '../chunk-DYW6WUHE.mjs';

package/dist/views/index.d.mts

@@ -0,0 +1,51 @@
+import { SchedulerEvent, TimeFormatOptions, SchedulerResource, SchedulerViewType } from '@primeui/scheduler-types/scheduler';
+import { ViewOptions, SchedulerViewModule, AgendaViewData, TimeSlot, NowIndicatorPosition, WeekViewData, DayViewData, MonthViewData, YearViewData, ResourceDayViewData, ResourceWeekViewData } from '@primeui/scheduler-types/view';
+import { f as createSchedulerDateFormatter } from '../display-format-CLVvRt4I.mjs';
+import { F as getWeekdayNames } from '../date-D_CjQPmM.mjs';
+export { calculateTimelineEventPosition, formatTimelineTitle, generateDayCells, generateTimelineCells, generateTimelineHeaderCells, getDefaultTimelineHeaderLevels, getEventsInDateRange, getTimelineDayViewData, getTimelineMonthViewData, getTimelineWeekViewData, getTimelineYearViewData, positionTimelineEvents, positionTimelineEventsForDayGranularity, positionTimelineEventsWithBusinessHours, timelineDayView, timelineMonthView, timelineWeekView, timelineYearView } from './timeline/index.mjs';
+import '@primeui/scheduler-types/date';
+import '@primeui/scheduler-types/timeline';
+
+declare const agendaView: SchedulerViewModule;
+interface AgendaViewOptions extends ViewOptions {
+    agendaDays?: number;
+    showEmptyDays?: boolean;
+}
+declare function getAgendaViewData(date: Date, options: AgendaViewOptions): AgendaViewData;
+declare function formatEventTime(event: SchedulerEvent, locale: string, options?: TimeFormatOptions, timeZone?: string): string;
+
+declare const weekView: SchedulerViewModule;
+declare function getWeekViewData(date: Date, options: ViewOptions): WeekViewData;
+declare function getCustomRangeTitle(date: Date, numberOfDays: number, locale: string, displayConfig?: Parameters<typeof createSchedulerDateFormatter>[0]): string;
+declare function generateTimeSlots(minTime: string, maxTime: string, slotDuration: number, date: Date, locale: string, timeFormat?: TimeFormatOptions, timeZone?: string): TimeSlot[];
+declare function getNowIndicatorPosition(slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number, timezone?: string): NowIndicatorPosition;
+declare function getEventTopPosition(event: SchedulerEvent, slotMinTime: string, slotDuration: number, slotHeight: number): number;
+declare function getEventHeight(event: SchedulerEvent, slotDuration: number, slotHeight: number): number;
+
+declare const dayView: SchedulerViewModule;
+declare function getDayViewData(date: Date, options: ViewOptions): DayViewData;
+
+declare const monthView: SchedulerViewModule;
+declare function getMonthViewData(date: Date, options: ViewOptions): MonthViewData;
+
+declare const yearView: SchedulerViewModule;
+declare function getYearViewData(date: Date, options: ViewOptions): YearViewData;
+declare function getYearViewWeekdayNames(locale: string, firstDayOfWeek: number, displayConfig?: Parameters<typeof getWeekdayNames>[3]): string[];
+
+declare const resourceDayView: SchedulerViewModule;
+interface ResourceDayViewOptions extends ViewOptions {
+    resources: SchedulerResource[];
+}
+declare function getResourceDayViewData(date: Date, options: ResourceDayViewOptions): ResourceDayViewData;
+
+declare const resourceWeekView: SchedulerViewModule;
+interface ResourceWeekViewOptions extends ViewOptions {
+    resources: SchedulerResource[];
+}
+declare function getResourceWeekViewData(date: Date, options: ResourceWeekViewOptions): ResourceWeekViewData;
+
+declare const viewRegistry: Record<SchedulerViewType, SchedulerViewModule>;
+declare function getView(viewType: SchedulerViewType): SchedulerViewModule;
+declare function getAvailableViews(): SchedulerViewType[];
+
+export { type AgendaViewOptions, type ResourceDayViewOptions, type ResourceWeekViewOptions, agendaView, dayView, formatEventTime, generateTimeSlots, getAgendaViewData, getAvailableViews, getCustomRangeTitle, getDayViewData, getEventHeight, getEventTopPosition, getMonthViewData, getNowIndicatorPosition, getResourceDayViewData, getResourceWeekViewData, getView, getWeekViewData, getYearViewData, getYearViewWeekdayNames, monthView, resourceDayView, resourceWeekView, viewRegistry, weekView, yearView };

package/dist/views/index.mjs

@@ -0,0 +1,8 @@
+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';
+import '../chunk-6PK5WSKT.mjs';
+import '../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 '../chunk-QDMZBJDV.mjs';
+import '../chunk-WFUJWDST.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';

package/dist/views/timeline/index.d.mts

@@ -0,0 +1,37 @@
+import { SchedulerEvent, TimeFormatOptions } from '@primeui/scheduler-types/scheduler';
+import { TimelineEventPosition, TimelineCell, TimelineViewOptions, TimelineHeaderLevel, TimelineHeaderCell, TimelineDayViewData, TimelineWeekViewData, TimelineMonthViewData, TimelineYearViewData } from '@primeui/scheduler-types/timeline';
+import { S as SchedulerCalendarDisplayConfigInput } from '../../display-format-CLVvRt4I.mjs';
+import { SchedulerViewModule } from '@primeui/scheduler-types/view';
+
+declare function generateTimelineHeaderCells(startDate: Date, endDate: Date, levels: TimelineHeaderLevel[], locale: string, timeFormat?: TimeFormatOptions, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): TimelineHeaderCell[][];
+declare function generateTimelineCells(startDate: Date, endDate: Date, options: TimelineViewOptions): TimelineCell[];
+declare function generateDayCells(startDate: Date, endDate: Date, cellWidth: number): TimelineCell[];
+declare function calculateTimelineEventPosition(event: SchedulerEvent, viewStart: Date, viewEnd: Date, totalWidth: number, totalDuration: number): TimelineEventPosition | null;
+declare function positionTimelineEvents(events: SchedulerEvent[], viewStart: Date, viewEnd: Date, totalWidth: number): TimelineEventPosition[];
+/**
+ * Position events for timeline views with business hours across multiple days.
+ * This function correctly handles events when only a portion of each day is visible (e.g., 08:00-18:00).
+ */
+declare function positionTimelineEventsWithBusinessHours(events: SchedulerEvent[], viewStart: Date, viewEnd: Date, totalWidth: number, minTimeMinutes: number, maxTimeMinutes: number): TimelineEventPosition[];
+/**
+ * Position events for day-granularity timeline views (month, year).
+ * Events snap to full day columns - a 2pm-4pm event fills the entire day column.
+ */
+declare function positionTimelineEventsForDayGranularity(events: SchedulerEvent[], viewStart: Date, viewEnd: Date, cellWidth: number): TimelineEventPosition[];
+declare function getEventsInDateRange(events: SchedulerEvent[], startDate: Date, endDate: Date): SchedulerEvent[];
+declare function getDefaultTimelineHeaderLevels(viewType: string): TimelineHeaderLevel[];
+declare function formatTimelineTitle(startDate: Date, endDate: Date, viewType: string, locale: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+
+declare const timelineDayView: SchedulerViewModule;
+declare function getTimelineDayViewData(date: Date, options: TimelineViewOptions): TimelineDayViewData;
+
+declare const timelineWeekView: SchedulerViewModule;
+declare function getTimelineWeekViewData(date: Date, options: TimelineViewOptions): TimelineWeekViewData;
+
+declare const timelineMonthView: SchedulerViewModule;
+declare function getTimelineMonthViewData(date: Date, options: TimelineViewOptions): TimelineMonthViewData;
+
+declare const timelineYearView: SchedulerViewModule;
+declare function getTimelineYearViewData(date: Date, options: TimelineViewOptions): TimelineYearViewData;
+
+export { calculateTimelineEventPosition, formatTimelineTitle, generateDayCells, generateTimelineCells, generateTimelineHeaderCells, getDefaultTimelineHeaderLevels, getEventsInDateRange, getTimelineDayViewData, getTimelineMonthViewData, getTimelineWeekViewData, getTimelineYearViewData, positionTimelineEvents, positionTimelineEventsForDayGranularity, positionTimelineEventsWithBusinessHours, timelineDayView, timelineMonthView, timelineWeekView, timelineYearView };

package/dist/views/timeline/index.mjs

@@ -0,0 +1,4 @@
+export { calculateTimelineEventPosition, formatTimelineTitle, generateDayCells, generateTimelineCells, generateTimelineHeaderCells, getDefaultTimelineHeaderLevels, getEventsInDateRange, getTimelineDayViewData, getTimelineMonthViewData, getTimelineWeekViewData, getTimelineYearViewData, positionTimelineEvents, positionTimelineEventsForDayGranularity, positionTimelineEventsWithBusinessHours, timelineDayView, timelineMonthView, timelineWeekView, timelineYearView } from '../../chunk-NMX4BW42.mjs';
+import '../../chunk-WFUJWDST.mjs';
+import '../../chunk-TNKJPFGI.mjs';
+import '../../chunk-DYW6WUHE.mjs';