@primeui/vue-scheduler 0.0.1-alpha.1

package/dist/Scheduler.context.d.ts

@@ -0,0 +1,625 @@
+import type { InjectionKey, Ref, ComputedRef } from 'vue';
+import type { AdaptiveRenderingOptions, AppointmentSlotIndicator, AppointmentSlotOverlay, AppointmentSlotsOptions, AutoHeightOptions, BlockedInterval, BlockedIntervalsOptions, BusinessHours, SchedulerText, CapacityExceededPayload, ConflictOptions, ConflictDetectedPayload, DateDisplayOptions, DateRange, DensityMode, EventAllowCallback, EventCategory, EventConstraint, EventDragState, EventDropPayload, EventResizeStopPayload, EventResizeState, EventResourceChangePayload, EventSelectionLimitReachedPayload, FlattenedResource, HorizontalResourceColumnMode, InlineEditCancelPayload, InlineEditSavePayload, NormalizedQuickInfoOptions, NormalizedInlineEditOptions, QuickInfoDeletePayload, QuickInfoEditPayload, QuickInfoHidePayload, ResourceCapacityInfo, ResourceRowLayout, RecurrenceDeletePayload, RecurrenceEditOptions, RecurrenceEditPayload, PrintInvocationOptions, ResolvedPrintPageChromeState, SchedulerBulkDeletePayload, SchedulerBulkMovePayload, SchedulerBulkUpdatePayload, SchedulerEvent, SchedulerEventSelectionMode, SchedulerEventSelectionOptions, SchedulerCalendarDisplayConfig, SchedulerCalendarMode, SchedulerHeaderToolbar, SchedulerPermissionAction, SchedulerResource, SchedulerSelectionMode, SchedulerViewType, SchedulerNumberingSystem, SelectAllowCallback, SelectConstraintConfig, SlotBookPayload, SlotCancelPayload, StackingOptions, TimeFormatOptions, TimezoneDisplay, BreadcrumbItem, ConflictWorkflowResult } from '@primeui/scheduler-core';
+import type { MonthGridDayCellViewModel, MonthResizePreviewData } from '@primeui/scheduler-core';
+import type { VueContextMenuContext, VueEventDragPayload, VueEventDragStartPayload, VueEventDragStopPayload, VueEventResizePayload, VueEventResizeStartPayload, VueInlineEditStartPayload, VueMoreClickPayload, VueQuickInfoShowPayload, VueResourceClickPayload, VueSchedulerDateClickPayload, VueSchedulerDateSelectPayload, VueSchedulerEventClickPayload, VueSchedulerEventMousePayload, VueSchedulerPermissionContext, VueSlotClickPayload } from './Scheduler.payloads';
+export declare const SCHEDULER_KEY: InjectionKey<SchedulerContext>;
+export declare const TIMEGRID_KEY: InjectionKey<TimeGridContext>;
+export declare const MONTHGRID_KEY: InjectionKey<MonthGridContext>;
+export declare const TIMELINE_KEY: InjectionKey<TimelineContext>;
+export declare const DAY_COLUMN_KEY: InjectionKey<DayColumnContext>;
+export declare const MONTH_WEEK_KEY: InjectionKey<MonthWeekContext>;
+export declare const TIMELINE_LANE_KEY: InjectionKey<TimelineLaneContext>;
+export interface ResourceStoreContext {
+    visibleResources: ComputedRef<FlattenedResource[]>;
+    resourceLayouts: ComputedRef<ResourceRowLayout[]>;
+    expandResource: (id: string | number) => void;
+    collapseResource: (id: string | number) => void;
+    toggleResourceExpansion: (id: string | number) => void;
+    isResourceExpanded: (id: string | number) => boolean;
+    expandAll: () => void;
+    collapseAll: () => void;
+    resourceFilterQuery: Ref<string>;
+    setResourceFilter: (query: string) => void;
+}
+export interface SchedulerPopoverAnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SchedulerMorePopoverEventDragProps {
+    class?: string;
+    'data-drag-enabled'?: '';
+    onPointerdown?: (event: PointerEvent) => void;
+}
+export interface SchedulerMorePopoverEventDragOptions {
+    sourceElement?: HTMLElement | null;
+    onDragStart?: () => void;
+    emitClickOnCancel?: boolean;
+}
+export type SchedulerMorePopoverEventDragHandler = (event: SchedulerEvent, jsEvent: PointerEvent, options?: SchedulerMorePopoverEventDragOptions) => void;
+export interface SchedulerContext {
+    currentDate: Ref<Date>;
+    currentView: Ref<SchedulerViewType>;
+    prev: () => void;
+    next: () => void;
+    today: () => void;
+    gotoDate: (date: Date) => void;
+    changeView: (view: SchedulerViewType) => void;
+    title: ComputedRef<string>;
+    dateRange: ComputedRef<DateRange>;
+    events: ComputedRef<SchedulerEvent[]>;
+    rawEvents: ComputedRef<SchedulerEvent[]>;
+    expandedEvents: ComputedRef<SchedulerEvent[]>;
+    getEventById: (id: string | number) => SchedulerEvent | undefined;
+    addEvent: (event: SchedulerEvent) => void;
+    updateEvent: (event: SchedulerEvent) => void;
+    removeEvent: (id: string | number) => void;
+    selectedDates: Ref<Date[]>;
+    selectedRange: Ref<DateRange | null>;
+    selectedEventIds: Ref<(string | number)[]>;
+    selectable: ComputedRef<boolean>;
+    selectionMode: ComputedRef<SchedulerSelectionMode>;
+    selectDate: (start: Date, end?: Date) => void;
+    selectEvent: (id: string | number, options?: {
+        ctrlKey?: boolean;
+        shiftKey?: boolean;
+        metaKey?: boolean;
+        toggle?: boolean;
+        resourceId?: string | number;
+    }) => void;
+    selectAllVisibleEvents: () => void;
+    invertVisibleEventSelection: () => void;
+    clearSelection: () => void;
+    clearEventSelection: () => void;
+    editable: ComputedRef<boolean>;
+    disabled: ComputedRef<boolean>;
+    readonly: ComputedRef<boolean>;
+    draggable: ComputedRef<boolean>;
+    resizable: ComputedRef<boolean>;
+    eventStartEditable: ComputedRef<boolean>;
+    eventDurationEditable: ComputedRef<boolean>;
+    resources: ComputedRef<SchedulerResource[]>;
+    resourceStore: ResourceStoreContext;
+    scopedResources: ComputedRef<SchedulerResource[]>;
+    scopedVisibleResources: ComputedRef<FlattenedResource[]>;
+    locale: ComputedRef<string>;
+    calendar: ComputedRef<SchedulerCalendarMode>;
+    numberingSystem: ComputedRef<SchedulerNumberingSystem | undefined>;
+    calendarDisplayConfig: ComputedRef<SchedulerCalendarDisplayConfig>;
+    timezone: ComputedRef<string | undefined>;
+    displayTimezone: ComputedRef<TimezoneDisplay | undefined>;
+    resolvedDisplayTimezone: ComputedRef<string>;
+    timezoneLabel: ComputedRef<string | null>;
+    firstDayOfWeek: ComputedRef<number>;
+    weekNumbers: ComputedRef<boolean>;
+    slotDuration: ComputedRef<number>;
+    slotMinTime: ComputedRef<string>;
+    slotMaxTime: ComputedRef<string>;
+    nowIndicator: ComputedRef<boolean>;
+    businessHours: ComputedRef<BusinessHours>;
+    showBusinessHours: Ref<boolean>;
+    blockedIntervals: ComputedRef<BlockedIntervalsOptions | undefined>;
+    canEventAction: (action: SchedulerPermissionAction, event: SchedulerEvent, extras?: Partial<Omit<VueSchedulerPermissionContext, 'action' | 'event' | 'view'>>) => boolean;
+    canDragEvent: (event: SchedulerEvent) => boolean;
+    canResizeEvent: (event: SchedulerEvent) => boolean;
+    categories: ComputedRef<EventCategory[]>;
+    activeCategoryIds: Ref<(string | number)[]>;
+    formatTime: (date: Date) => string;
+    formatDate: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+    formatDayNumber: (date: Date, format?: 'numeric' | '2-digit') => string;
+    formatWeekdayDayNumber: (date: Date, weekday?: 'long' | 'short' | 'narrow', day?: 'numeric' | '2-digit') => string;
+    formatNumber: (value: number) => string;
+    formatEventTime: (event: SchedulerEvent, edge?: 'start' | 'end') => string;
+    formatEventTimeRange: (event: SchedulerEvent) => string;
+    isTimeGridView: ComputedRef<boolean>;
+    isResourceGridView: ComputedRef<boolean>;
+    isResourceMonthGridView: ComputedRef<boolean>;
+    isDateGridView: ComputedRef<boolean>;
+    isDateMonthGridView: ComputedRef<boolean>;
+    isMonthGridView: ComputedRef<boolean>;
+    isTimelineView: ComputedRef<boolean>;
+    isResourceView: ComputedRef<boolean>;
+    classes: Record<string, string>;
+    props: Record<string, unknown>;
+    emitDateClick: (payload: VueSchedulerDateClickPayload) => void;
+    emitDateDblClick: (payload: VueSchedulerDateClickPayload) => void;
+    emitDateSelect: (payload: VueSchedulerDateSelectPayload) => void;
+    emitEventClick: (payload: VueSchedulerEventClickPayload) => void;
+    emitEventDblClick: (payload: VueSchedulerEventClickPayload) => void;
+    emitEventMouseEnter: (payload: VueSchedulerEventMousePayload) => void;
+    emitEventMouseLeave: (payload: VueSchedulerEventMousePayload) => void;
+    emitEventDragStart: (payload: VueEventDragStartPayload) => void;
+    emitEventDrag: (payload: VueEventDragPayload) => void;
+    emitEventDragStop: (payload: VueEventDragStopPayload) => void;
+    emitEventDrop: (payload: EventDropPayload) => void;
+    emitEventResizeStart: (payload: VueEventResizeStartPayload) => void;
+    emitEventResize: (payload: VueEventResizePayload) => void;
+    emitEventResizeStop: (payload: EventResizeStopPayload) => void;
+    emitEventResourceChange: (payload: EventResourceChangePayload) => void;
+    emitEventSelectionLimitReached: (payload: EventSelectionLimitReachedPayload) => void;
+    emitEventAdd: (event: SchedulerEvent) => void;
+    emitEventChange: (payload: {
+        event: SchedulerEvent;
+        oldEvent: SchedulerEvent;
+    }) => void;
+    emitEventRemove: (payload: {
+        event: SchedulerEvent;
+    }) => void;
+    emitEventTitleChange: (payload: {
+        event: SchedulerEvent;
+        oldTitle: string;
+        newTitle: string;
+        view: SchedulerViewType;
+    }) => void;
+    emitMoreClick: (payload: VueMoreClickPayload) => void;
+    emitBulkMove: (payload: SchedulerBulkMovePayload) => void;
+    emitBulkUpdate: (payload: SchedulerBulkUpdatePayload) => void;
+    emitBulkDelete: (payload: SchedulerBulkDeletePayload) => void;
+    emitResourceClick: (payload: VueResourceClickPayload) => void;
+    emitContextMenuShow: (payload: VueContextMenuContext) => void;
+    contextMenuState: Ref<VueContextMenuContext | null>;
+    hideContextMenu: () => void;
+    scrollDismissRevision: Ref<number>;
+    hideFloatingOverlays: () => void;
+    emitQuickInfoShow: (payload: VueQuickInfoShowPayload) => void;
+    emitQuickInfoHide: (payload: QuickInfoHidePayload) => void;
+    emitQuickInfoEdit: (payload: QuickInfoEditPayload) => void;
+    emitQuickInfoDelete: (payload: QuickInfoDeletePayload) => void;
+    emitRecurrenceEdit: (payload: RecurrenceEditPayload) => void;
+    emitRecurrenceDelete: (payload: RecurrenceDeletePayload) => void;
+    recurrenceDialogEvent: Ref<SchedulerEvent | null>;
+    recurrenceDialogAction: Ref<'edit' | 'delete' | null>;
+    showRecurrenceDialog: (event: SchedulerEvent, action: 'edit' | 'delete') => void;
+    hideRecurrenceDialog: () => void;
+    confirmRecurrenceScope: (scope: 'this' | 'future' | 'all') => void;
+    emitInlineEditStart: (payload: VueInlineEditStartPayload) => void;
+    emitInlineEditSave: (payload: InlineEditSavePayload) => void;
+    emitInlineEditCancel: (payload: InlineEditCancelPayload) => void;
+    emitSlotClick: (payload: VueSlotClickPayload) => void;
+    emitSlotBook: (payload: SlotBookPayload) => void;
+    emitSlotCancel: (payload: SlotCancelPayload) => void;
+    emitConflictDetected: (payload: ConflictDetectedPayload) => void;
+    emitCapacityExceeded: (payload: CapacityExceededPayload) => void;
+    emitAdaptiveAutoSelect: (payload: {
+        resource: SchedulerResource;
+    }) => void;
+    resourceConflictOptions: ComputedRef<ConflictOptions>;
+    conflictedEventIds: Ref<(string | number)[]>;
+    isEventConflicted: (eventId?: string | number | null) => boolean;
+    getResourceCapacityInfo: (resourceId: string | number, date?: Date) => ResourceCapacityInfo | null;
+    getResourceCapacityStatus: (resourceId: string | number, date?: Date) => 'available' | 'near-full' | 'full' | null;
+    getResourceCapacityClass: (resourceId: string | number, date?: Date) => string | null;
+    isResourceSurfaceConstrained: (resourceId: string | number, date?: Date) => boolean;
+    processResourceConflictDecision: (payload: {
+        event: SchedulerEvent;
+        targetResourceId?: string | number;
+        currentDate?: Date;
+    }) => ConflictWorkflowResult;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    print: (options?: PrintInvocationOptions) => void;
+    isDropValid: Ref<boolean>;
+    updateDropValidity: (tentative: {
+        event: SchedulerEvent;
+        start: Date;
+        end: Date;
+        allDay?: boolean;
+        resourceId?: string | number;
+    }) => boolean;
+    resetDropValidity: () => void;
+    categoryCounts: ComputedRef<Record<string | number, number>>;
+    toggleCategory: (id: string | number) => void;
+    isCategoryActive: (id: string | number) => boolean;
+    categoryField: ComputedRef<string>;
+    categoryAutoTextColor: ComputedRef<boolean>;
+    showCategoryLegend: ComputedRef<boolean>;
+    categoryLegendPosition: ComputedRef<'top' | 'bottom' | 'left' | 'right' | 'none'>;
+    categoryFilterable: ComputedRef<boolean>;
+    resolvedViews: ComputedRef<SchedulerViewType[]>;
+    viewOptions: ComputedRef<Array<{
+        label: string;
+        value: SchedulerViewType;
+    }>>;
+    viewLabel: (view: SchedulerViewType) => string;
+    numberOfDays: ComputedRef<number | undefined>;
+    daysOfWeek: ComputedRef<number[] | undefined>;
+    timeFormat: ComputedRef<TimeFormatOptions | undefined>;
+    dateDisplay: ComputedRef<DateDisplayOptions | undefined>;
+    unselectOnOutsideClick: ComputedRef<boolean>;
+    eventOverlap: ComputedRef<boolean>;
+    snapDuration: ComputedRef<number | undefined>;
+    dragMinDistance: ComputedRef<number>;
+    dragScroll: ComputedRef<boolean>;
+    nowIndicatorInterval: ComputedRef<number>;
+    inlineEditOptions: ComputedRef<NormalizedInlineEditOptions>;
+    inlineEditingEvent: Ref<SchedulerEvent | null>;
+    inlineEditingField: Ref<string | null>;
+    inlineEditValue: Ref<string>;
+    inlineIsEditing: Ref<boolean>;
+    startInlineEdit: (event: SchedulerEvent, field?: string) => void;
+    saveInlineEdit: (trigger?: 'blur' | 'enter' | 'programmatic') => boolean;
+    cancelInlineEdit: () => void;
+    appointmentSlots: ComputedRef<AppointmentSlotsOptions | undefined>;
+    quickInfoOptions: ComputedRef<NormalizedQuickInfoOptions>;
+    quickInfoEvent: Ref<SchedulerEvent | null>;
+    quickInfoAnchor: Ref<HTMLElement | null>;
+    quickInfoPosition: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    quickInfoPlacement: ComputedRef<'top' | 'bottom' | 'left' | 'right'>;
+    showQuickInfo: (event: SchedulerEvent, anchor: HTMLElement) => void;
+    hideQuickInfo: () => void;
+    triggerQuickInfoEdit: (event?: SchedulerEvent) => void;
+    triggerQuickInfoDelete: (event?: SchedulerEvent) => void;
+    printClassNames: Ref<string[]>;
+    printPageChromeState: Ref<ResolvedPrintPageChromeState | null>;
+    eventPopoverOptions: ComputedRef<{
+        enabled: boolean;
+        delay: number;
+        hideDelay: number;
+        position: 'top' | 'bottom' | 'left' | 'right';
+        showOnMobile: boolean;
+    }>;
+    eventPopoverEvent: Ref<SchedulerEvent | null>;
+    eventPopoverAnchor: Ref<HTMLElement | null>;
+    eventPopoverAnchorRect: Ref<SchedulerPopoverAnchorRect | null>;
+    eventPopoverVisible: ComputedRef<boolean>;
+    eventPopoverInteractionActive: Ref<boolean>;
+    showEventPopover: (event: SchedulerEvent, anchor: HTMLElement | SchedulerPopoverAnchorRect, trigger?: 'hover' | 'focus' | 'touch') => void;
+    scheduleHideEventPopover: (event?: SchedulerEvent | null) => void;
+    hideEventPopover: (event?: SchedulerEvent | null) => void;
+    cancelHideEventPopover: () => void;
+    recurrenceEditOptions: ComputedRef<boolean | Partial<RecurrenceEditOptions>>;
+    showMorePopover: ComputedRef<boolean>;
+    maxEventsVisible: ComputedRef<number>;
+    morePopoverDate: Ref<Date | null>;
+    morePopoverEvents: Ref<SchedulerEvent[]>;
+    morePopoverPosition: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    openMorePopover: (date: Date, events: SchedulerEvent[], anchor: HTMLElement) => void;
+    hideMorePopover: () => void;
+    morePopoverPartCount: Ref<number>;
+    registerMorePopoverPart: () => void;
+    unregisterMorePopoverPart: () => void;
+    canDragMorePopoverEvent: (event: SchedulerEvent) => boolean;
+    getMorePopoverEventDragProps: (event: SchedulerEvent) => SchedulerMorePopoverEventDragProps;
+    registerMorePopoverEventDragHandler: (handler: SchedulerMorePopoverEventDragHandler) => () => void;
+    resourceAreaWidth: ComputedRef<number | string>;
+    resourcesExpandable: ComputedRef<boolean>;
+    resourcesInitiallyExpanded: ComputedRef<boolean>;
+    showResourceFilter: ComputedRef<boolean>;
+    showAggregatedEvents: ComputedRef<boolean>;
+    resourceRowHeight: ComputedRef<number>;
+    rowAutoHeight: ComputedRef<boolean | undefined>;
+    resourceTimelineOverlapPolicy: ComputedRef<'auto' | 'allow' | 'prevent'>;
+    resourceAreaHeaderContent: ComputedRef<string | undefined>;
+    resourceOrder: ComputedRef<'asc' | 'desc' | ((a: SchedulerResource, b: SchedulerResource) => number) | undefined>;
+    horizontalResourceColumnMode: ComputedRef<HorizontalResourceColumnMode | undefined>;
+    horizontalResourceColumnWidth: ComputedRef<number | string | undefined>;
+    horizontalResourceMinColumnWidth: ComputedRef<number | string | undefined>;
+    horizontalResourceDayMinWidth: ComputedRef<number | string | undefined>;
+    horizontalResourceGroupMinWidth: ComputedRef<number | string | undefined>;
+    horizontalResourceOverflowThreshold: ComputedRef<number | undefined>;
+    byGroupID: ComputedRef<boolean>;
+    resourceGroupField: ComputedRef<string | undefined>;
+    timelineSlotWidth: ComputedRef<number>;
+    timelineSlotWidthMode: ComputedRef<'fixed' | 'fill'>;
+    timelineSlotDuration: ComputedRef<number | undefined>;
+    timelineSnapDuration: ComputedRef<number | undefined>;
+    timelineMinTime: ComputedRef<string | undefined>;
+    timelineMaxTime: ComputedRef<string | undefined>;
+    timelineEventMinHeight: ComputedRef<number | undefined>;
+    timelineVirtualScroll: ComputedRef<'auto' | boolean>;
+    timelineVirtualThreshold: ComputedRef<number>;
+    timelineVirtualOverscan: ComputedRef<number>;
+    timelineVirtualEventBuffer: ComputedRef<number>;
+    density: ComputedRef<DensityMode | undefined>;
+    autoHeight: ComputedRef<boolean | AutoHeightOptions>;
+    stacking: ComputedRef<StackingOptions | undefined>;
+    adaptiveRendering: ComputedRef<AdaptiveRenderingOptions | undefined>;
+    adaptiveMode: ComputedRef<boolean>;
+    selectedResourceId: Ref<string | number | null | undefined>;
+    isAdaptiveResourceView: ComputedRef<boolean>;
+    effectiveSelectedResourceId: ComputedRef<string | number | null>;
+    adaptiveSelectedResource: ComputedRef<SchedulerResource | null>;
+    adaptiveBreadcrumbItems: ComputedRef<BreadcrumbItem[]>;
+    adaptiveSidebarOpen: ComputedRef<boolean>;
+    adaptiveSelectorPanelId: string;
+    adaptiveSelectorResources: ComputedRef<FlattenedResource[]>;
+    adaptiveSelectorFilterQuery: Ref<string>;
+    setAdaptiveSelectorFilter: (query: string) => void;
+    selectAdaptiveResource: (resourceId: string | number, jsEvent?: MouseEvent) => void;
+    navigateAdaptiveResource: (resourceId: string | number) => void;
+    openAdaptiveSelector: () => void;
+    closeAdaptiveSelector: () => void;
+    toggleAdaptiveSelector: () => void;
+    selectConstraint: ComputedRef<SelectConstraintConfig | undefined>;
+    selectAllow: ComputedRef<SelectAllowCallback | undefined>;
+    eventConstraint: ComputedRef<EventConstraint | undefined>;
+    eventAllow: ComputedRef<EventAllowCallback | undefined>;
+    agendaDays: ComputedRef<number>;
+    showEmptyDays: ComputedRef<boolean>;
+    noEventsMessage: ComputedRef<string | undefined>;
+    agendaEventShell: ComputedRef<'default' | 'none' | undefined>;
+    eventShell: ComputedRef<'default' | 'none' | undefined>;
+    eventSelection: ComputedRef<boolean | SchedulerEventSelectionOptions>;
+    eventSelectionEnabled: ComputedRef<boolean>;
+    eventSelectionMode: ComputedRef<SchedulerEventSelectionMode>;
+    eventSelectionLimit: ComputedRef<number | undefined>;
+    eventSelectionModeActive: Ref<boolean>;
+    minDate: ComputedRef<Date | null | undefined>;
+    maxDate: ComputedRef<Date | null | undefined>;
+    text: ComputedRef<SchedulerText>;
+    rtl: Ref<boolean>;
+    navLinks: ComputedRef<boolean>;
+    weekNumbering: ComputedRef<'iso' | 'us' | 'auto'>;
+    headerToolbar: ComputedRef<SchedulerHeaderToolbar | false>;
+    focusedDate: Ref<Date | null>;
+    focusedResourceId: Ref<string | number | undefined>;
+    categoryHoverId: Ref<string | number | null>;
+    setCategoryHover: (id: string | number) => void;
+    clearCategoryHover: () => void;
+}
+export interface TimeGridContext {
+    days: ComputedRef<Date[]>;
+    resources: ComputedRef<SchedulerResource[]>;
+    slotDuration: ComputedRef<number>;
+    slotMinTime: ComputedRef<string>;
+    slotMaxTime: ComputedRef<string>;
+    slotHeight: ComputedRef<number>;
+    totalSlotCount: ComputedRef<number>;
+    totalHeight: ComputedRef<number>;
+    timeSlots: ComputedRef<{
+        time: string;
+        minutes: number;
+    }[]>;
+    getTimedEventsForColumn: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    getAllDayEventsForDay: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    hasAllDayEvents: ComputedRef<boolean>;
+    usesSpanningAllDayRow: ComputedRef<boolean>;
+    getPositionedTimedEvent: (event: SchedulerEvent, date: Date, resourceId?: string | number) => TimeGridTimedEventLayout | null;
+    getEventTopPosition: (event: SchedulerEvent) => number;
+    getEventHeight: (event: SchedulerEvent) => number;
+    getOverlapLayout: (event: SchedulerEvent, date: Date, resourceId?: string | number) => {
+        left: string;
+        width: string;
+        zIndex: number;
+    };
+    getWeekAllDayLayout: (resourceId?: string | number) => TimeGridAllDayWeekLayout;
+    isDragging: Ref<boolean>;
+    isResizing: Ref<boolean>;
+    dragState: Ref<EventDragState | null>;
+    resizeState: Ref<EventResizeState | null>;
+    dragGhostPosition: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    dragSourceSize: Ref<{
+        width: number;
+        height: number;
+    } | null>;
+    onSlotClick: (date: Date, minutes: number, resourceId?: string | number, jsEvent?: MouseEvent) => void;
+    onSlotPointerDown: (date: Date, minutes: number, e: PointerEvent, resourceId?: string | number) => void;
+    onEventPointerDown: (event: SchedulerEvent, e: PointerEvent) => void;
+    onEventTouchStart: (event: SchedulerEvent, e: TouchEvent) => void;
+    nowIndicatorTop: ComputedRef<number | null>;
+    showNowIndicator: ComputedRef<boolean>;
+    getBusinessHoursStyles: (date: Date) => {
+        top: string;
+        height: string;
+    }[];
+    getBlockedIntervalStyle: (interval: BlockedInterval, date: Date, resourceId?: string | number) => Record<string, string> | null;
+    allDayMaxRows: ComputedRef<number>;
+    getVisibleAllDayEventsForDay: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    getOverflowAllDayEventsForDay: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    getAppointmentSlotOverlaysForDay: (date: Date, resourceId?: string | number) => AppointmentSlotOverlay[];
+    getAppointmentSlotIndicatorsForDay: (date: Date, resourceId?: string | number) => AppointmentSlotIndicator[];
+    bodyScrollRef: Ref<HTMLElement | undefined>;
+}
+export interface TimeGridTimedEventLayout {
+    event: SchedulerEvent;
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+    zIndex: number;
+}
+export interface TimeGridAllDayEventLayout {
+    event: SchedulerEvent;
+    row: number;
+    startCol: number;
+    endCol: number;
+    isContinuationStart: boolean;
+    isContinuationEnd: boolean;
+}
+export interface TimeGridAllDayWeekLayout {
+    positioned: TimeGridAllDayEventLayout[];
+    overflowByDay: Record<string, SchedulerEvent[]>;
+    visibleRowCount: number;
+    gridRowCount: number;
+}
+export interface DayColumnContext {
+    date: ComputedRef<Date>;
+    resourceId: ComputedRef<string | number | undefined>;
+    timedEvents: ComputedRef<SchedulerEvent[]>;
+    allDayEvents: ComputedRef<SchedulerEvent[]>;
+    isToday: ComputedRef<boolean>;
+    isWeekend: ComputedRef<boolean>;
+    isSelected: ComputedRef<boolean>;
+}
+export interface WeekEventLayout {
+    positioned: Array<{
+        event: SchedulerEvent;
+        row: number;
+        startCol: number;
+        endCol: number;
+        isContinuationStart: boolean;
+        isContinuationEnd: boolean;
+    }>;
+    overflowByDay: Record<string, SchedulerEvent[]>;
+    timedByDay: Record<string, SchedulerEvent[]>;
+    dayStats: Array<{
+        spanningDepth: number;
+        overflowCount: number;
+    }>;
+}
+export interface MonthGridContext {
+    weeks: ComputedRef<MonthWeekData[]>;
+    weekdays: ComputedRef<string[]>;
+    monthStart: ComputedRef<Date>;
+    monthEnd: ComputedRef<Date>;
+    getEventsForDay: (date: Date) => SchedulerEvent[];
+    getDayCell?: (date: Date) => MonthGridDayCellViewModel | undefined;
+    getDayNumberLabel: (date: Date) => string;
+    getEventLayout: (event: SchedulerEvent, weekStart: Date) => {
+        gridColumnStart: number;
+        gridColumnEnd: number;
+        row: number;
+    } | null;
+    getWeekLayout: (weekStart: Date) => WeekEventLayout;
+    getOverflowCount: (date: Date, maxRows: number) => number;
+    getOverflowEvents: (date: Date) => SchedulerEvent[];
+    isDragging: Ref<boolean>;
+    isResizing: Ref<boolean>;
+    dragState: Ref<EventDragState | null>;
+    resizeState: Ref<(EventResizeState & {
+        resizeEdge: 'start' | 'end';
+        originalRow?: number;
+    }) | null>;
+    resizePreviewData: Ref<MonthResizePreviewData[]>;
+    dragGhostPosition: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    dragSourceSize: Ref<{
+        width: number;
+        height: number;
+    } | null>;
+    dragTargetDate: Ref<Date | null>;
+    measuredEventAreaHeight: Ref<number | null>;
+    spanningRowHeight: ComputedRef<number>;
+    spanningTopOffset: ComputedRef<number>;
+    onDayClick: (date: Date, jsEvent: MouseEvent) => void;
+    onDayDblClick: (date: Date, jsEvent: MouseEvent) => void;
+    onDayPointerDown: (date: Date, e: PointerEvent) => void;
+    onEventPointerDown: (event: SchedulerEvent, e: PointerEvent) => void;
+    onEventResizePointerDown: (event: SchedulerEvent, edge: 'start' | 'end', e: PointerEvent, position: {
+        row: number;
+    }) => void;
+    onMoreLinkClick: (date: Date, events: SchedulerEvent[], jsEvent: MouseEvent | KeyboardEvent) => void;
+    maxVisibleRows: ComputedRef<number>;
+    showWeekNumbers: ComputedRef<boolean>;
+    morePopoverDate: Ref<Date | null>;
+    morePopoverEvents: Ref<SchedulerEvent[]>;
+    morePopoverPosition: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    showMorePopover: (date: Date, events: SchedulerEvent[], anchor: HTMLElement) => void;
+    hideMorePopover: () => void;
+    scrollContainerRef: Ref<HTMLElement | undefined>;
+}
+export interface MonthWeekData {
+    days: Date[];
+    weekNumber: number;
+    events: SchedulerEvent[];
+}
+export interface MonthWeekContext {
+    days: ComputedRef<Date[]>;
+    weekNumber: ComputedRef<number>;
+    events: ComputedRef<SchedulerEvent[]>;
+}
+export interface TimelineContext {
+    cells: ComputedRef<TimelineCellData[]>;
+    totalWidth: ComputedRef<number>;
+    viewStart: ComputedRef<Date>;
+    viewEnd: ComputedRef<Date>;
+    resources: ComputedRef<SchedulerResource[]>;
+    visibleResources: ComputedRef<FlattenedResource[]>;
+    resourceLayouts: ComputedRef<ResourceRowLayout[]>;
+    totalResourceHeight: ComputedRef<number>;
+    expandResource: (id: string | number) => void;
+    collapseResource: (id: string | number) => void;
+    toggleResourceExpansion: (id: string | number) => void;
+    isResourceExpanded: (id: string | number) => boolean;
+    resourceFilterQuery: Ref<string>;
+    setResourceFilter: (query: string) => void;
+    headerTiers: ComputedRef<TimelineHeaderTier[]>;
+    visibleHeaderTiers: ComputedRef<TimelineHeaderTier[]>;
+    getEventsForLane: (resourceId?: string | number) => SchedulerEvent[];
+    getEventLeft: (event: SchedulerEvent) => number;
+    getEventWidth: (event: SchedulerEvent) => number;
+    getEventLane: (event: SchedulerEvent, resourceId?: string | number) => number;
+    getLaneCount: (resourceId?: string | number) => number;
+    isAggregatedRow: (resourceId: string | number | undefined) => boolean;
+    getAggregateEvents: (resourceId: string | number | undefined) => SchedulerEvent[];
+    getAggregateCount: (resourceId: string | number | undefined) => number;
+    isDragging: Ref<boolean>;
+    isResizing: Ref<boolean>;
+    dragState: Ref<EventDragState | null>;
+    resizeState: Ref<EventResizeState | null>;
+    dragGhostPosition: Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    dragGhostDimensions: Ref<{
+        width: number;
+        height: number;
+    } | null>;
+    isEventBeingMultiDragged: (eventId: string | number) => boolean;
+    getMultiDragSnappedEvents: () => Array<{
+        event: SchedulerEvent;
+        left: number;
+        width: number;
+    }>;
+    onCellClick: (date: Date, resourceId?: string | number, jsEvent?: MouseEvent) => void;
+    onCellPointerDown: (date: Date, e: PointerEvent, resourceId?: string | number) => void;
+    onEventPointerDown: (event: SchedulerEvent, e: PointerEvent) => void;
+    onEventTouchStart: (event: SchedulerEvent, e: TouchEvent) => void;
+    nowIndicatorLeft: ComputedRef<number | null>;
+    showNowIndicator: ComputedRef<boolean>;
+    useVirtualScroll: ComputedRef<boolean>;
+    scrollLeft: Ref<number>;
+    contentScrollLeft: Ref<number>;
+    scrollDirection: Ref<'ltr' | 'rtl'>;
+    containerWidth: Ref<number>;
+    visibleCells: ComputedRef<TimelineCellData[]>;
+    visibleEvents: ComputedRef<SchedulerEvent[]>;
+    selectedRangeResourceId: Ref<string | number | undefined>;
+    spacerStyle: ComputedRef<Record<string, string>>;
+    headerStripStyle: ComputedRef<Record<string, string>>;
+    setHeaderHeight: (source: 'timeline' | 'resource', height: number) => void;
+    scrollToNow: (smooth?: boolean) => void;
+    scrollToDate: (date: Date, centerInView?: boolean, smooth?: boolean) => void;
+    handleScroll: (e: Event) => void;
+    handleResourceAreaScroll: (e: Event) => void;
+    scrollContainerRef: Ref<HTMLElement | undefined>;
+    resourceAreaBodyRef: Ref<HTMLElement | undefined>;
+    headerRef: Ref<HTMLElement | undefined>;
+    headerHeight: Ref<number>;
+}
+export interface TimelineCellData {
+    startDate: Date;
+    endDate: Date;
+    width: number;
+    label: string;
+    isToday: boolean;
+    isWeekend: boolean;
+}
+export interface TimelineHeaderTier {
+    cells: {
+        label: string;
+        width: number;
+        left: number;
+        startDate: Date;
+        endDate: Date;
+    }[];
+}
+export interface TimelineLaneContext {
+    resource: ComputedRef<SchedulerResource | undefined>;
+    resourceId: ComputedRef<string | number | undefined>;
+    events: ComputedRef<SchedulerEvent[]>;
+}

package/dist/Scheduler.event-context.d.mts

@@ -0,0 +1,54 @@
+import { type ComputedRef, type InjectionKey, type PropType } from 'vue';
+import type { SchedulerEvent } from '@primeui/scheduler-core';
+import type { SchedulerOutletRendererProps } from './shell/outletRenderers';
+export type SchedulerEventContextSurface = 'time-grid' | 'all-day' | 'month' | 'timeline' | 'timeline-year' | 'agenda';
+export interface SchedulerEventContext {
+    surface: SchedulerEventContextSurface;
+    event: SchedulerEvent;
+    title: string;
+    formattedTime?: string;
+    timeText?: string;
+    accentColor?: string;
+    variant?: 'timed' | 'drag-preview' | string;
+    view?: string;
+    density?: 'minimal' | 'compact' | 'default' | 'comfortable' | string;
+    availableHeight?: number;
+    availableWidth?: number;
+    contentOffset?: number;
+    contentMaxWidth?: number;
+    position?: unknown;
+    left?: number;
+    width?: number;
+    isSelected?: boolean;
+    isDragging?: boolean;
+    isResizing?: boolean;
+    isEditing?: boolean;
+    isDropValid?: boolean;
+    isMultiDrag?: boolean;
+    selectedCount?: number;
+}
+export type SchedulerTimeGridEventContext = SchedulerEventContext & {
+    surface: 'time-grid';
+};
+export declare const SCHEDULER_EVENT_CONTEXT_KEY: InjectionKey<ComputedRef<SchedulerEventContext>>;
+export declare function useSchedulerEventContext(options: {
+    optional: true;
+}): ComputedRef<SchedulerEventContext> | null;
+export declare function useSchedulerEventContext(options?: {
+    optional?: false;
+}): ComputedRef<SchedulerEventContext>;
+export declare const SchedulerEventContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerEventContext>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<SchedulerEventContext>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare function createSchedulerEventContext(runtimeProps: SchedulerOutletRendererProps, surface: SchedulerEventContextSurface): SchedulerEventContext | null;
+export declare function createSchedulerTimeGridEventContext(runtimeProps: SchedulerOutletRendererProps): SchedulerEventContext | null;