Event Scheduler

Module Extensions

EventSchedulerConfig

interface EventSchedulerConfig {
  /** Scheduler view. Supports day, week, month, and resource-timeline layouts. */
    readonly view?: EventSchedulerView;
  /** ISO date that anchors week/date generation. */
    readonly weekStartDate: string;
  /** Explicit visible date range for timeline mode. */
    readonly dateRange?: EventSchedulerDateRange;
  /** IANA time zone identifier used by built-in date labels and time-zone aware flows.
     *
     * @example
     * ```ts
     * timeZone: 'Europe/Lisbon'
     * ```
     */
    readonly timeZone?: string;
  /** Locale used by default date/time labels.
     *
     * @example
     * ```ts
     * locale: 'pt-PT'
     * ```
     */
    readonly locale?: string;
  /** First day of the week, where `0` is Sunday and `1` is Monday. */
    readonly weekStartsOn?: number;
  /** Visible weekday indexes.
     *
     * Use this for business-days-only schedules or custom operating calendars.
     *
     * @example
     * ```ts
     * visibleDays: [1, 2, 3, 4, 5]
     * ```
     */
    readonly visibleDays?: readonly number[];
  /** Timeline slot size in minutes. Values below `15` are normalized to `15`.
     *
     * Use `15` or `30` for detailed shifts and `60` or `1440` for higher-level planning.
     */
    readonly slotMinutes?: number;
  /** Drag, resize, create, paste, and keyboard snapping interval in minutes.
     *
     * When omitted, the effective snap follows the active `slotMinutes`, including
     * runtime zoom changes. Set an explicit value when editing precision should
     * remain fixed while the visible timescale zooms.
     *
     * @example
     * ```ts
     * slotMinutes: 60,
     * snapMinutes: 15
     * ```
     */
    readonly snapMinutes?: number;
  /** Visible time-of-day window in `HH:mm` or AM/PM format. `end` can be `24:00`.
     *
     * @example
     * ```ts
     * timeRange: { start: '06:00', end: '22:00' }
     * timeRange: { start: '6 AM', end: '10 PM' }
     * ```
     */
    readonly timeRange?: EventSchedulerTimeRange;
  /** Scheduler timescale zoom levels, or `false` to disable zoom actions and methods. */
    readonly zoom?: boolean | EventSchedulerZoomConfig;
  /** Master edit switch.
     *
     * Set to `false` for read-only browsing while keeping scrolling, selection,
     * tooltips, and custom renderers active.
     */
    readonly editable?: boolean;
  /** Allows creation from slot/range interaction or API helpers. */
    readonly allowCreate?: boolean | ((context: EventSchedulerSlotContext) => boolean);
  /** Allows drag/drop time changes and resource reassignment. */
    readonly allowMove?: boolean | ((context: EventSchedulerPermissionContext) => boolean);
  /** Allows start/end resizing. */
    readonly allowResize?: boolean | ((context: EventSchedulerPermissionContext) => boolean);
  /** Allows delete actions from editor, keyboard, context menu, or API helpers. */
    readonly allowDelete?: boolean | ((context: EventSchedulerPermissionContext) => boolean);
  /** Product access rules layered on top of `editable` and `allow*`. */
    readonly permissions?: EventSchedulerPermissionsConfig;
  /** Grouped visual customization hooks for column sizes, headers, cells, event sections, and create previews. */
    readonly customization?: EventSchedulerCustomizationConfig;
  /** Scheduler row height in pixels. */
    readonly rowSize?: number;
  /** Pinned time-column width in day/week/month views. */
    readonly timeColumnSize?: number;
  /** Day-column width in day/week/month views. */
    readonly dayColumnSize?: number;
  /** Pinned resource-column width in resource-timeline views. */
    readonly resourceColumnSize?: number;
  /** Timeline slot-column width in resource-timeline day, week, and custom ranges. */
    readonly timelineColumnSize?: number;
  /** Enables grouped scheduler headers. Defaults to true. */
    readonly columnGrouping?: boolean;
  /** Ordered resource-timeline header rows, from coarse to fine.
     *
     * Configure one to three rows. Sub-day timelines must end in `time`;
     * day-granularity timelines must end in `day`. When omitted, Scheduler picks
     * compact rows for the active `slotMinutes`.
     *
     * @example
     * ```ts
     * timelineHeaderRows: [
     *   { id: 'day', unit: 'day' },
     *   { id: 'time', unit: 'time' },
     * ]
     * ```
     */
    readonly timelineHeaderRows?: readonly EventSchedulerTimelineHeaderRowConfig[];
  /** Visual layout mode for overlapping event blocks. */
    readonly eventLayout?: EventSchedulerEventLayout;
  /** Maximum stacked lanes before compact rendering should take over. */
    readonly maxStackedEvents?: number;
  /** Lane-count threshold for compact event content. */
    readonly compactThreshold?: number;
  /** Conflict detection and policy settings. */
    readonly conflicts?: EventSchedulerConflictConfig;
  /** Current-time marker configuration or `true` for defaults. */
    readonly currentTimeMarker?: boolean | EventSchedulerCurrentTimeMarkerConfig;
  /** Simple show/hide alias for the current-time marker. `currentTimeMarker.enabled` takes precedence when provided. */
    readonly showCurrentTimeMarker?: boolean;
  /** Live current-time refresh interval in milliseconds. Defaults to 60000. Set `0` to disable automatic live refresh. */
    readonly currentTimeUpdateInterval?: number;
  /** Per-day shift/event count in day headers. Enabled by default. */
    readonly dayHeaderShiftCount?: boolean | EventSchedulerDayHeaderShiftCountConfig;
  /** Today header/cell highlighting. Enabled by default. */
    readonly todayHighlight?: boolean | EventSchedulerTodayHighlightConfig;
  /** Weekend header/cell highlighting. Enabled by default for Saturday/Sunday. */
    readonly weekendHighlight?: boolean | EventSchedulerWeekendHighlightConfig;
  /** Built-in Scheduler context menus for event bars and empty cells. Enabled by default. */
    readonly contextMenu?: boolean | EventSchedulerContextMenuConfig;
  /** Built-in Scheduler keyboard shortcuts and shortcuts panel. Enabled by default. */
    readonly keyboardShortcuts?: boolean | EventSchedulerKeyboardShortcutsConfig;
  /** Cross-day continuation labels on event bars. Enabled by default. */
    readonly continuationLabels?: boolean | EventSchedulerContinuationLabelsConfig;
  /** Non-working day/time background settings. */
    readonly nonWorkingTime?: EventSchedulerNonWorkingTimeConfig;
  /** Working-hour alias for scheduler body availability. Supports global, day-filtered, and per-weekday ranges. */
    readonly workingHours?: EventSchedulerTimeRange | readonly EventSchedulerTimeRange[] | EventSchedulerWorkingHoursConfig;
  /** Closed-hour ranges such as lunch, maintenance, holidays, or blocked planning windows. */
    readonly closedHours?: EventSchedulerClosedHoursConfig | readonly EventSchedulerClosedHoursConfig[];
  /** Product-specific availability rules layered on top of working/closed hours. */
    readonly availabilityRules?: EventSchedulerAvailabilityRule | readonly EventSchedulerAvailabilityRule[];
  /** Named working calendars for global or per-resource working days/hours. */
    readonly calendars?: EventSchedulerCalendarsConfig;
  /** Resource grouping and tree settings. */
    readonly resourceGrouping?: EventSchedulerResourceGroupingConfig;
  /** Active resource/event/conflict/unassigned filters. */
    readonly filters?: EventSchedulerFilterState;
  /** Saved view definitions for reusable filter/range presets. */
    readonly savedViews?: EventSchedulerSavedViewsConfig;
  /** Active saved-view id when controlled by the host product. */
    readonly activeSavedViewId?: EventSchedulerEntityId;
  /** Selection, bulk action, range selection, and clipboard settings. */
    readonly selection?: EventSchedulerSelectionConfig;
  /** Alias for `selection.mode`. */
    readonly selectionMode?: EventSchedulerSelectionConfig['mode'];
  /** External clipboard adapter for product-owned copy/paste state. */
    readonly clipboardAdapter?: EventSchedulerClipboardAdapter;
  /** Reusable event templates for quick creation and recurrence. */
    readonly templates?: readonly EventSchedulerEventTemplateEntity[];
  /** Coverage requirement calculations and summaries. */
    readonly coverage?: EventSchedulerCoverageConfig;
  /** Resource/group workload and utilization calculations. */
    readonly utilization?: EventSchedulerUtilizationConfig;
  /** Unassigned-event row and assignment behavior. */
    readonly unassigned?: EventSchedulerUnassignedConfig;
  /** Remote loading, optimistic update, validation, and rollback hooks. */
    readonly remote?: EventSchedulerRemoteConfig;
  /** Empty-state text when no scheduler rows can be shown. */
    readonly emptyStateText?: string;
  /** i18n labels and label formatter overrides. */
    readonly labels?: Partial<EventSchedulerLabels>;
  /** Formats week-view day headers. */
    readonly dayHeaderFormatter?: (date: Date, dayIndex: number) => string;
  /** Replaces week/day/month day header content. `customization.headers.dayTemplate` takes precedence when both are provided. */
    readonly dayHeaderTemplate?: EventSchedulerHeaderCustomizationConfig['dayTemplate'];
  /** Adds classes, styles, attributes, data fields, or event handlers to week/day/month day headers. */
    readonly dayHeaderProperties?: (context: EventSchedulerHeaderContext) => EventSchedulerElementProps | undefined;
  /** Formats week-view time labels. */
    readonly timeLabelFormatter?: (minutes: number, slotIndex: number) => string;
  /** Replaces week/day/month pinned time-label cell content. `customization.cells.timeTemplate` takes precedence when both are provided. */
    readonly timeLabelTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerTimeCellContext) => EventSchedulerTemplateResult;
  /** Adds classes, styles, attributes, data fields, or event handlers to week/day/month pinned time-label cells. */
    readonly timeRowProperties?: (context: EventSchedulerTimeCellContext) => EventSchedulerElementProps | undefined;
  /** Replaces current-time marker content in week/day/month and resource-timeline cells. */
    readonly currentTimeMarkerTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerCurrentTimeMarkerContext) => EventSchedulerTemplateResult;
  /** Adds classes, styles, attributes, data fields, or event handlers to current-time marker cells. */
    readonly currentTimeMarkerProperties?: (context: EventSchedulerCurrentTimeMarkerContext) => EventSchedulerElementProps | undefined;
  /** Formats the current-time marker label. */
    readonly currentTimeLabelFormatter?: (context: EventSchedulerCurrentTimeMarkerContext) => string;
  /** Replaces empty week/resource-timeline slot content. Event bars remain rendered for occupied slots. */
    readonly slotTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerSlotRenderContext) => EventSchedulerTemplateResult;
  /** Replaces closed-slot content while preserving scheduler-owned event bars. */
    readonly closedSlotTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerClosedSlotContext) => EventSchedulerTemplateResult;
  /** Adds classes, styles, attributes, data fields, or event handlers to scheduler slot cells. */
    readonly slotProperties?: (context: EventSchedulerSlotRenderContext) => EventSchedulerElementProps | undefined;
  /** Adds classes, styles, attributes, data fields, or event handlers to closed scheduler slot cells. */
    readonly closedSlotProperties?: (context: EventSchedulerClosedSlotContext) => EventSchedulerElementProps | undefined;
  /** Formats the native tooltip/title for scheduler slot cells. */
    readonly slotTooltip?: (context: EventSchedulerSlotRenderContext) => string | undefined;
  /** Formats the native tooltip/title for closed scheduler slot cells. */
    readonly closedSlotTooltip?: (context: EventSchedulerClosedSlotContext) => string | undefined;
  /** Called when an empty scheduler slot is clicked, before built-in editor-open behavior. */
    readonly onSlotClick?: (context: EventSchedulerSlotRenderContext, event: MouseEvent) => void;
  /** Called when an empty scheduler slot is double-clicked. */
    readonly onSlotDoubleClick?: (context: EventSchedulerSlotRenderContext, event: MouseEvent) => void;
  /** Called when an empty scheduler slot context menu opens. */
    readonly onSlotContextMenu?: (context: EventSchedulerSlotRenderContext | (EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId }), event: MouseEvent | null) => void;
  /** Marks scheduler slots as disabled for selection/create UX. Disabled slots do not open the built-in create editor. */
    readonly isSlotDisabled?: (context: EventSchedulerSlotRenderContext | (EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId })) => boolean;
  /** Marks scheduler slots as non-selectable for pointer create/selection UX. */
    readonly isSlotSelectable?: (context: EventSchedulerSlotRenderContext | (EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId })) => boolean;
  /** Product availability gate. Return `false` to mark a slot unavailable and block built-in creation. */
    readonly isTimeSlotAvailable?: (context: EventSchedulerSlotRenderContext | (EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId })) => boolean | EventSchedulerAvailabilityRuleResult;
  /** Formats resource names in the pinned resource column. */
    readonly resourceLabelFormatter?: (resource: EventSchedulerResourceEntity) => string;
  /** Formats secondary resource metadata in the pinned resource column. */
    readonly resourceMetaFormatter?: (resource: EventSchedulerResourceEntity) => string | undefined;
  /** Formats resource-timeline header cells. */
    readonly timelineHeaderFormatter?: (context: EventSchedulerTimelineHeaderContext) => string;
  /** Formats the hover label shown over empty slots. */
    readonly hoverTimeFormatter?: (minutes: number, slotIndex: number, date: string) => string;
  /** Formats the drag-create range ghost label. */
    readonly createRangeFormatter?: (context: EventSchedulerCreateRangeDisplayContext) => string;
  /** Replaces the drag-create range ghost preview content. */
    readonly createRangeTemplate?: EventSchedulerCreateRangeTemplate;
  /** Creates deterministic ids for range-created events. */
    readonly createEventId?: (context: EventSchedulerCreateRangeContext) => EventSchedulerEntityId;
  /** Creates deterministic ids for pasted or duplicated events. */
    readonly createCopiedEventId?: (event: EventSchedulerEventEntity, context: { index: number; action: 'paste' | 'duplicate' }) => EventSchedulerEntityId;
  /** Creates deterministic ids for template-created events. */
    readonly createTemplateEventId?: (template: EventSchedulerEventTemplateEntity, context: { startDateTime: string; resourceId?: EventSchedulerEntityId }) => EventSchedulerEntityId;
  /** Creates deterministic ids for recurring template events. */
    readonly createRecurringEventId?: (template: EventSchedulerEventTemplateEntity, context: { index: number; seriesId: EventSchedulerEntityId; startDateTime: string; resourceId?: EventSchedulerEntityId }) => EventSchedulerEntityId;
  /** Builds the draft event used by drag-create or slot-create flows. */
    readonly createEventDraft?: (context: EventSchedulerCreateRangeContext) => EventSchedulerEventEntity | null | undefined;
  /** Custom editor hook, or `false` to disable the default editor. */
    readonly eventEditor?: false | EventSchedulerEventEditorHook;
  /** Opens the editor when an empty slot is clicked. */
    readonly eventEditorOpenOnSlotClick?: boolean;
  /** Opens the editor when an event is double-clicked. */
    readonly eventEditorOpenOnEventDoubleClick?: boolean;
  /** Status options shown by the default editor. */
    readonly eventEditorStatusOptions?: readonly (string | EventSchedulerEventEditorStatusOption)[];
  /** Adds classes, styles, attributes, data fields, or event handlers to event blocks. */
    readonly eventProperties?: (context: EventSchedulerEventSectionContext) => EventSchedulerElementProps | undefined;
  /** Replaces the default event block content renderer. */
    readonly eventTemplate?: EventSchedulerEventTemplate;
  /** Replaces the default event content section. `customization.events.content` takes precedence when both are provided. */
    readonly eventContentTemplate?: EventSchedulerEventSectionTemplate;
  /** Replaces individual event badges. `customization.events.badge` takes precedence when both are provided. */
    readonly eventBadgeTemplate?: EventSchedulerEventSectionTemplate<EventSchedulerEventBadgeContext>;
  /** Replaces event resize handle content. `customization.events.resizeHandle` takes precedence when both are provided. */
    readonly eventResizeHandleTemplate?: EventSchedulerEventSectionTemplate<EventSchedulerEventResizeHandleContext>;
  /** Overrides event tooltip text. `customization.events.tooltip` takes precedence when both are provided. */
    readonly eventTooltipTemplate?: (context: EventSchedulerEventSectionContext) => string | undefined;
  /** Formats tooltip text for event blocks. */
    readonly tooltipFormatter?: (context: EventSchedulerEventSectionContext) => string | undefined;
  /** Resolves event accent colors from status/type/business data. */
    readonly statusColorResolver?: (event: EventSchedulerEventEntity) => string | undefined;
  /** Sorts events before lane placement and rendering. */
    readonly eventSort?: (left: EventSchedulerEventEntity, right: EventSchedulerEventEntity) => number;
  /** Filters resources before projection. */
    readonly resourceFilter?: (resource: EventSchedulerResourceEntity) => boolean;
  /** Label for the synthetic unassigned-demand row. */
    readonly unassignedResourceLabel?: string;
  /** Cancellable hook before event creation. Return `false` or a string message to cancel. */
    readonly beforeEventCreate?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before generic event updates from editor/API/status changes. */
    readonly beforeEventUpdate?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before event move. */
    readonly beforeEventMove?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before event resize. */
    readonly beforeEventResize?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before event delete. */
    readonly beforeEventDelete?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before event duplicate. */
    readonly beforeEventDuplicate?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before event lock/unlock. */
    readonly beforeEventLock?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void;
  /** Cancellable hook before a slot is selected/click-selected. */
    readonly beforeSlotSelect?: (detail: EventSchedulerBeforeSlotSelectDetail) => boolean | string | void;
  /** Final callback after event creation. */
    readonly onEventCreate?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after generic event update. */
    readonly onEventUpdate?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after event move. */
    readonly onEventMove?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after event resize. */
    readonly onEventResize?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after event delete. */
    readonly onEventDelete?: (detail: EventSchedulerEventDeletedDetail) => void;
  /** Final callback after event duplicate. */
    readonly onEventDuplicate?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after event copy. */
    readonly onEventCopy?: (detail: EventSchedulerEventCopiedDetail) => void;
  /** Alias for `onEventCopy`. */
    readonly onCopy?: (detail: EventSchedulerEventCopiedDetail) => void;
  /** Final callback after pasted events are created. */
    readonly onEventPaste?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Alias for `onEventPaste`. */
    readonly onPaste?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Alias for `onEventDuplicate`. */
    readonly onDuplicate?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after event lock/unlock. */
    readonly onEventLock?: (detail: EventSchedulerEventChangedDetail) => void;
  /** Final callback after event selection changes. */
    readonly onSelectionChange?: (detail: EventSchedulerEventSelectedDetail) => void;
  /** Final callback after slot selection/click-selection. */
    readonly onSlotSelect?: (detail: EventSchedulerSlotSelectedDetail) => void;
  /** Final synchronous validation before local mutation commit. */
    readonly validateMutation?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean | string | void
}

---

HTMLRevoGridElementEventMap (Extended from global)

interface HTMLRevoGridElementEventMap {
  [EVENT_SCHEDULER_BEFORE_EVENT_CHANGE_EVENT]: EventSchedulerBeforeEventChangeDetail;
  [EVENT_SCHEDULER_BEFORE_EVENT_SELECT_EVENT]: EventSchedulerEventSelectedDetail;
  [EVENT_SCHEDULER_BEFORE_SLOT_SELECT_EVENT]: EventSchedulerBeforeSlotSelectDetail;
  [EVENT_SCHEDULER_EVENT_CREATED_EVENT]: EventSchedulerEventChangedDetail;
  [EVENT_SCHEDULER_EVENT_CHANGED_EVENT]: EventSchedulerEventChangedDetail;
  [EVENT_SCHEDULER_EVENT_DELETED_EVENT]: EventSchedulerEventDeletedDetail;
  [EVENT_SCHEDULER_EVENT_SELECTED_EVENT]: EventSchedulerEventSelectedDetail;
  [EVENT_SCHEDULER_SLOT_CLICK_EVENT]: EventSchedulerSlotClickDetail;
  [EVENT_SCHEDULER_CONFLICTS_UPDATED_EVENT]: EventSchedulerConflictsUpdatedDetail;
  [EVENT_SCHEDULER_REMOTE_LOAD_START_EVENT]: EventSchedulerRemoteLoadDetail;
  [EVENT_SCHEDULER_REMOTE_LOAD_SUCCESS_EVENT]: EventSchedulerRemoteLoadDetail;
  [EVENT_SCHEDULER_REMOTE_LOAD_ERROR_EVENT]: EventSchedulerRemoteLoadDetail;
  [EVENT_SCHEDULER_REMOTE_MUTATION_PENDING_EVENT]: EventSchedulerRemoteMutationDetail;
  [EVENT_SCHEDULER_REMOTE_MUTATION_COMMITTED_EVENT]: EventSchedulerRemoteMutationDetail;
  [EVENT_SCHEDULER_REMOTE_MUTATION_REJECTED_EVENT]: EventSchedulerRemoteMutationDetail;
  [EVENT_SCHEDULER_REMOTE_STATE_CHANGE_EVENT]: EventSchedulerRemoteStateChangeDetail;
  [EVENT_SCHEDULER_NAVIGATE_REQUEST_EVENT]: EventSchedulerNavigateRequestDetail;
  [EVENT_SCHEDULER_VIEW_REQUEST_EVENT]: EventSchedulerViewRequestDetail;
  [EVENT_SCHEDULER_RESOURCE_REASSIGN_REQUEST_EVENT]: EventSchedulerResourceReassignRequestDetail;
  [EVENT_SCHEDULER_OPEN_SHIFT_ASSIGN_REQUEST_EVENT]: EventSchedulerOpenShiftAssignRequestDetail;
  [EVENT_SCHEDULER_SEARCH_FOCUS_REQUEST_EVENT]: EventSchedulerSearchFocusRequestDetail
}

---

HTMLRevoGridElement (Extended from global)

interface HTMLRevoGridElement {
  eventScheduler?: EventSchedulerConfig;
  eventSchedulerEvents?: readonly EventSchedulerEventEntity[];
  eventSchedulerResources?: readonly EventSchedulerResourceEntity[];
  eventSchedulerAssignments?: readonly EventSchedulerAssignmentEntity[];
  eventSchedulerAvailability?: readonly EventSchedulerAvailabilityEntity[];
  eventSchedulerTemplates?: readonly EventSchedulerEventTemplateEntity[];
  eventSchedulerCoverageRequirements?: readonly EventSchedulerCoverageRequirementEntity[]
}

Plugin API

DEFAULT_EVENT_SCHEDULER_TIME_RANGE

DEFAULT_EVENT_SCHEDULER_TIME_RANGE: {
  start: string;
  end: string;
};

---

normalizeSchedulerConfig

export function normalizeSchedulerConfig(config: EventSchedulerConfig): EventSchedulerResolvedConfig;

---

EventSchedulerPlugin

Enterprise scheduler plugin for week and resource-timeline planning.

Register it in grid.plugins, then drive data through side-channel grid props: eventScheduler, eventSchedulerEvents, eventSchedulerResources, eventSchedulerAssignments, eventSchedulerAvailability, and eventSchedulerCoverageRequirements.

Example:

const grid = document.querySelector('revo-grid');
grid.plugins = [EventSchedulerPlugin];
grid.eventScheduler = {
  view: 'resourceTimeline',
  weekStartDate: '2026-06-08',
  allowCreate: true
};
grid.eventSchedulerResources = [{ id: 'room-a', name: 'Room A' }];
grid.eventSchedulerEvents = [{
  id: 'booking-1',
  resourceId: 'room-a',
  title: 'Booking',
  startDateTime: '2026-06-08T09:00:00.000Z',
  endDateTime: '2026-06-08T10:00:00.000Z'
}];

Dependencies

• Auto-installed EventManagerPlugin, HistoryPlugin, TooltipPlugin, ContextMenuPlugin, RowZIndexPlugin: Installs shared Pro infrastructure for Event Scheduler edits, history, tooltips, menus, and row stacking when absent.
• Event integration BEFORE_HEADER_RENDER_EVENT: Keeps generated Scheduler time-axis columns at their configured widths.
• Event integration BEFORE_GROUP_HEADER_RENDER_EVENT: Keeps generated Scheduler time-axis header groups at their configured widths.

class EventSchedulerPlugin {
  /** Returns whether the Scheduler can move to a finer time-slot granularity. */
  canZoomIn(): boolean;

  /** Returns whether the Scheduler can move to a coarser time-slot granularity. */
  canZoomOut(): boolean;

  /** Moves to the next finer time-slot granularity. */
  zoomIn(): boolean;

  /** Moves to the next coarser time-slot granularity. */
  zoomOut(): boolean;

  /** Returns the active projected time-slot granularity. */
  getZoomSlotMinutes(): number | null;

  /** Creates an event through the scheduler mutation pipeline.
     *
     * The call respects `editable`, `allowCreate`, `permissions`, conflicts,
     * cancelable before-change events, and remote optimistic commit hooks.
     */
  createEvent(event: EventSchedulerEventEntity): EventSchedulerEventEntity;

  /** Updates an event by id and returns the updated entity. */
  editEvent(eventId: EventSchedulerEntityId, changes: EventSchedulerEventEditChanges): EventSchedulerEventEntity;

  /** Deletes an event by id when delete permissions and validation allow it. */
  deleteEvent(eventId: EventSchedulerEntityId): void;

  /** Returns the current event selection as stable event ids. */
  getSelectedEventIds(): readonly EventSchedulerEntityId[];

  /** Replaces the current event selection and returns the normalized selected ids. */
  setSelectedEventIds(eventIds: readonly EventSchedulerEntityId[]): readonly EventSchedulerEntityId[];

  /** Returns the currently selected slot, when an empty scheduler slot is selected. */
  getSelectedSlot(): (EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId }) | null;

  /** Sets the selected slot from host-provided state. */
  setSelectedSlot(slot: (EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId }) | null): void;

  /** Returns the currently selected time range, usually from drag-create or slot create context. */
  getSelectedRange(): EventSchedulerCreateRangeContext | null;

  /** Sets the selected time range from host-provided state. */
  setSelectedRange(range: EventSchedulerCreateRangeContext | null): void;

  /** Clears the current scheduler event selection. */
  clearSelectedEvents(): void;

  /** Copies selected events into the scheduler clipboard payload and browser clipboard when available. */
  copySelectedEvents(): EventSchedulerClipboardPayload | null;

  /**
     * Pastes copied events, optionally overriding target start/resource.
     *
     * The target base follows the active projection snap interval, including an
     * implicit snap interval changed by runtime Scheduler zoom.
     */
  pasteCopiedEvents(options: EventSchedulerPasteOptions = {}): readonly EventSchedulerEventEntity[];

  /** Duplicates selected events by an offset in days. */
  duplicateSelectedEvents(offsetDays?: number): readonly EventSchedulerEventEntity[];

  /** Copies every event in a source date range into a target date range. */
  duplicateScheduleRange(options: EventSchedulerDuplicateRangeOptions): readonly EventSchedulerEventEntity[];

  /** Returns configured scheduler templates. */
  getTemplates(): readonly EventSchedulerEventTemplateEntity[];

  /** Creates one event from a reusable template. */
  createEventFromTemplate(options: EventSchedulerTemplateCreateOptions): readonly EventSchedulerEventEntity[];

  /** Expands a template into daily or weekly recurring events. */
  createRecurringEvents(options: EventSchedulerRecurrenceCreateOptions): readonly EventSchedulerEventEntity[];

  /** Applies a change to all matching events in a recurrence series. */
  editRecurrenceSeries(options: EventSchedulerRecurrenceSeriesEditOptions): readonly EventSchedulerEventEntity[];

  /** Deletes all matching events in a recurrence series. */
  deleteRecurrenceSeries(options: EventSchedulerRecurrenceSeriesDeleteOptions): void;

  /** Deletes all selected events when bulk delete is permitted. */
  bulkDeleteSelectedEvents(): void;

  /** Updates the status of all selected events. */
  bulkUpdateSelectedEventStatus(status: string): readonly EventSchedulerEventEntity[];

  /** Returns the latest normalized projection used for rows, columns, segments, and summaries. */
  getProjection(): EventSchedulerProjection | null;

  /** Returns current remote loading, error, pending, and pagination state. */
  getRemoteState(): EventSchedulerRemoteState;

  /** Forces remote mode to reload the current visible date/resource range. */
  async refreshVisibleRange(): Promise<void>;

  /** Requests the next remote resource page when progressive resource loading is enabled. */
  async loadMoreResources(): Promise<void>;

  /** Exports currently visible/filtered scheduler events as CSV or JSON. */
  exportEvents(options: EventSchedulerExportOptions = {}): EventSchedulerExportResult;

  /** Exports resource workload and utilization rows for the current projection. */
  exportResourceWorkload(options: EventSchedulerExportOptions = {}): EventSchedulerExportResult;

  /** Exports current conflict rows as CSV or JSON. */
  exportConflicts(options: EventSchedulerExportOptions = {}): EventSchedulerExportResult;

  /** Exports coverage gaps by default, or all coverage requirements when `gapsOnly` is false. */
  exportCoverage(options: EventSchedulerCoverageExportOptions = {}): EventSchedulerExportResult;

  /** Exports visible event segments, including clipped/split schedule geometry. */
  exportVisibleSchedule(options: EventSchedulerExportOptions = {}): EventSchedulerExportResult;

  /** Creates a print-friendly scheduler HTML document without mutating the grid. */
  createPrintView(options: EventSchedulerPrintOptions = {}): EventSchedulerPrintResult;
}

---

EVENT_SCHEDULER_BEFORE_EVENT_CHANGE_EVENT

EVENT_SCHEDULER_BEFORE_EVENT_CHANGE_EVENT: string;

---

EVENT_SCHEDULER_BEFORE_EVENT_SELECT_EVENT

EVENT_SCHEDULER_BEFORE_EVENT_SELECT_EVENT: string;

---

EVENT_SCHEDULER_BEFORE_SLOT_SELECT_EVENT

EVENT_SCHEDULER_BEFORE_SLOT_SELECT_EVENT: string;

---

EVENT_SCHEDULER_EVENT_CREATED_EVENT

EVENT_SCHEDULER_EVENT_CREATED_EVENT: string;

---

EVENT_SCHEDULER_EVENT_CHANGED_EVENT

EVENT_SCHEDULER_EVENT_CHANGED_EVENT: string;

---

EVENT_SCHEDULER_EVENT_DELETED_EVENT

EVENT_SCHEDULER_EVENT_DELETED_EVENT: string;

---

EVENT_SCHEDULER_EVENT_SELECTED_EVENT

EVENT_SCHEDULER_EVENT_SELECTED_EVENT: string;

---

EVENT_SCHEDULER_SLOT_CLICK_EVENT

EVENT_SCHEDULER_SLOT_CLICK_EVENT: string;

---

EVENT_SCHEDULER_CONFLICTS_UPDATED_EVENT

EVENT_SCHEDULER_CONFLICTS_UPDATED_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_LOAD_START_EVENT

EVENT_SCHEDULER_REMOTE_LOAD_START_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_LOAD_SUCCESS_EVENT

EVENT_SCHEDULER_REMOTE_LOAD_SUCCESS_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_LOAD_ERROR_EVENT

EVENT_SCHEDULER_REMOTE_LOAD_ERROR_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_MUTATION_PENDING_EVENT

EVENT_SCHEDULER_REMOTE_MUTATION_PENDING_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_MUTATION_COMMITTED_EVENT

EVENT_SCHEDULER_REMOTE_MUTATION_COMMITTED_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_MUTATION_REJECTED_EVENT

EVENT_SCHEDULER_REMOTE_MUTATION_REJECTED_EVENT: string;

---

EVENT_SCHEDULER_REMOTE_STATE_CHANGE_EVENT

EVENT_SCHEDULER_REMOTE_STATE_CHANGE_EVENT: string;

---

EVENT_SCHEDULER_NAVIGATE_REQUEST_EVENT

EVENT_SCHEDULER_NAVIGATE_REQUEST_EVENT: string;

---

EVENT_SCHEDULER_VIEW_REQUEST_EVENT

EVENT_SCHEDULER_VIEW_REQUEST_EVENT: string;

---

EVENT_SCHEDULER_RESOURCE_REASSIGN_REQUEST_EVENT

EVENT_SCHEDULER_RESOURCE_REASSIGN_REQUEST_EVENT: string;

---

EVENT_SCHEDULER_OPEN_SHIFT_ASSIGN_REQUEST_EVENT

EVENT_SCHEDULER_OPEN_SHIFT_ASSIGN_REQUEST_EVENT: string;

---

EVENT_SCHEDULER_SEARCH_FOCUS_REQUEST_EVENT

EVENT_SCHEDULER_SEARCH_FOCUS_REQUEST_EVENT: string;

---

EventSchedulerView

export type EventSchedulerView = 'day' | 'week' | 'month' | 'resourceTimeline';

---

EventSchedulerEventLayout

export type EventSchedulerEventLayout = 'stack' | 'overlap' | 'compact';

---

EventSchedulerConflictPolicy

export type EventSchedulerConflictPolicy = 'mark' | 'prevent' | 'allow';

---

EventSchedulerConflictScope

export type EventSchedulerConflictScope = 'same-resource' | 'global';

---

EventSchedulerConflictType

export type EventSchedulerConflictType =
  | 'overlap'
  | 'outside-availability'
  | 'blocked-time'
  | 'missing-resource'
  | 'invalid-duration'
  | 'locked-change'
  | 'resource-over-capacity'
  | 'duplicate-assignment';

---

EventSchedulerConflictSeverity

export type EventSchedulerConflictSeverity = 'warning' | 'error' | 'confirm';

---

EventSchedulerConflictRulePolicy

export type EventSchedulerConflictRulePolicy = EventSchedulerConflictSeverity | 'allow' | 'ignore';

---

EventSchedulerMutationAction

export type EventSchedulerMutationAction =
  | 'create'
  | 'move'
  | 'resize'
  | 'edit'
  | 'delete'
  | 'bulk-move'
  | 'bulk-edit'
  | 'bulk-delete'
  | 'paste'
  | 'duplicate'
  | 'template-create'
  | 'recurrence-create'
  | 'recurrence-edit-series'
  | 'recurrence-delete-series';

---

EventSchedulerResizeEdge

export type EventSchedulerResizeEdge = 'start' | 'end';

---

EventSchedulerStatus

export type EventSchedulerStatus = 'draft' | 'planned' | 'confirmed' | 'completed' | 'cancelled' | 'blocked';

---

EventSchedulerAvailabilityKind

export type EventSchedulerAvailabilityKind = 'working' | 'blocked' | 'holiday' | 'break';

---

EventSchedulerEntityId

export type EventSchedulerEntityId = string | number;

---

EventSchedulerTimeRange

Time-of-day range in HH:mm or AM/PM format. 24:00 is accepted for end.

interface EventSchedulerTimeRange {
  readonly start: string;
  readonly end: string
}

---

EventSchedulerDateRange

Inclusive start and exclusive end date range used by timeline and remote loading APIs.

interface EventSchedulerDateRange {
  readonly start: string;
  readonly end: string
}

---

EventSchedulerCurrentTimeMarkerConfig

interface EventSchedulerCurrentTimeMarkerConfig {
  readonly enabled?: boolean;
  readonly dateTime?: string;
  readonly className?: string
}

---

EventSchedulerResolvedCurrentTimeMarkerConfig

interface EventSchedulerResolvedCurrentTimeMarkerConfig {
  readonly enabled: boolean;
  readonly dateTime?: string;
  readonly className?: string
}

---

EventSchedulerNonWorkingTimeConfig

interface EventSchedulerNonWorkingTimeConfig {
  /** Enables non-working day/hour marking. Defaults to true. */
    readonly enabled?: boolean;
  /**
     * Working weekdays using JavaScript indexes, where Sunday is 0 and Saturday is 6.
     * Days outside this set are marked as closed when no calendar overrides the slot.
     */
    readonly workingDays?: readonly number[];
  /**
     * Working time windows inside visible scheduler days. Slots outside these windows
     * are marked as closed/outside working hours and receive non-working styling.
     */
    readonly workingHours?: EventSchedulerTimeRange | readonly EventSchedulerTimeRange[];
  /** Optional CSS class applied to non-working cells. */
    readonly className?: string
}

---

EventSchedulerCalendarsConfig

interface EventSchedulerCalendarsConfig {
  /** Enables named calendar resolution. Defaults to true when calendars are provided. */
    readonly enabled?: boolean;
  /** Shared calendar id used when a resource has no calendar override. */
    readonly primaryCalendarId?: CalendarId;
  /** Shared Gantt/Scheduler calendars. Working days use ISO weekdays: 1 = Monday ... 7 = Sunday. */
    readonly calendars?: readonly CalendarEntity[];
  /** Optional resolver for resource-specific shared calendars. */
    readonly resourceCalendarId?: (resource: { readonly id: EventSchedulerEntityId; readonly calendarId?: CalendarId; readonly metadata?: Record<string, unknown> }) => CalendarId | undefined;
  readonly className?: string
}

---

EventSchedulerResolvedWorkingHoursRange

export type EventSchedulerResolvedWorkingHoursRange = CalendarResolvedWorkingTimeRange;

---

EventSchedulerResolvedNonWorkingTimeConfig

interface EventSchedulerResolvedNonWorkingTimeConfig {
  readonly enabled: boolean;
  readonly workingDays: readonly number[];
  readonly workingHours: readonly EventSchedulerResolvedWorkingHoursRange[];
  readonly className?: string
}

---

EventSchedulerResolvedCalendarEntity

export type EventSchedulerResolvedCalendarEntity = ResolvedCalendarEntity;

---

EventSchedulerResolvedCalendarsConfig

interface EventSchedulerResolvedCalendarsConfig {
  readonly enabled: boolean;
  readonly primaryCalendarId?: CalendarId;
  readonly items: ReadonlyMap<string, EventSchedulerResolvedCalendarEntity>;
  readonly resourceCalendarId?: EventSchedulerCalendarsConfig['resourceCalendarId'];
  readonly className?: string
}

---

EventSchedulerEventEntity

interface EventSchedulerEventEntity {
  readonly id: EventSchedulerEntityId;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resourceIds?: readonly EventSchedulerEntityId[];
  readonly assignmentIds?: readonly EventSchedulerEntityId[];
  readonly title?: string;
  readonly startDateTime: string;
  readonly endDateTime: string;
  readonly status?: EventSchedulerStatus | string;
  readonly type?: string;
  readonly category?: string;
  readonly locked?: boolean;
  readonly readonly?: boolean;
  readonly notes?: string;
  readonly color?: string;
  readonly className?: string;
  readonly recurrenceId?: EventSchedulerEntityId;
  readonly recurrenceSeriesId?: EventSchedulerEntityId;
  readonly recurrenceOccurrenceDate?: string;
  readonly recurrenceException?: 'edited' | 'deleted';
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerEventEditChanges (Extended from index.ts)

export type EventSchedulerEventEditChanges =
  Partial<Omit<EventSchedulerEventEntity, 'resourceId' | 'resourceIds'>> & {
    readonly resourceId?: EventSchedulerEntityId | null;
    readonly resourceIds?: readonly EventSchedulerEntityId[] | null;
  };

---

EventSchedulerRecurrenceFrequency

export type EventSchedulerRecurrenceFrequency = 'daily' | 'weekly';

---

EventSchedulerRecurrenceRule

interface EventSchedulerRecurrenceRule {
  readonly frequency: EventSchedulerRecurrenceFrequency;
  readonly interval?: number;
  readonly weekdays?: readonly number[];
  readonly count?: number;
  readonly untilDateTime?: string
}

---

EventSchedulerEventTemplateEntity

Reusable event shape used by template and recurrence helpers.

interface EventSchedulerEventTemplateEntity {
  readonly id: EventSchedulerEntityId;
  readonly title: string;
  readonly durationMinutes: number;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resourceIds?: readonly EventSchedulerEntityId[];
  readonly status?: EventSchedulerStatus | string;
  readonly type?: string;
  readonly category?: string;
  readonly locked?: boolean;
  readonly readonly?: boolean;
  readonly notes?: string;
  readonly color?: string;
  readonly className?: string;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerTemplateCreateOptions

interface EventSchedulerTemplateCreateOptions {
  readonly templateId: EventSchedulerEntityId;
  readonly startDateTime: string;
  readonly resourceId?: EventSchedulerEntityId;
  readonly title?: string;
  readonly status?: EventSchedulerStatus | string;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerRecurrenceCreateOptions (Extended from index.ts)

interface EventSchedulerRecurrenceCreateOptions {
  readonly recurrence: EventSchedulerRecurrenceRule;
  readonly seriesId?: EventSchedulerEntityId
}

---

EventSchedulerRecurrenceSeriesEditOptions

interface EventSchedulerRecurrenceSeriesEditOptions {
  readonly seriesId: EventSchedulerEntityId;
  readonly changes: Partial<EventSchedulerEventEntity>;
  readonly includeExceptions?: boolean
}

---

EventSchedulerRecurrenceSeriesDeleteOptions

interface EventSchedulerRecurrenceSeriesDeleteOptions {
  readonly seriesId: EventSchedulerEntityId;
  readonly includeExceptions?: boolean
}

---

EventSchedulerSelectionConfig

interface EventSchedulerSelectionConfig {
  readonly mode?: 'single' | 'multiple' | 'range';
  readonly selectedEventIds?: readonly EventSchedulerEntityId[];
  readonly selectedSlot?: EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId };
  readonly selectedRange?: EventSchedulerCreateRangeContext;
  readonly multi?: boolean;
  readonly range?: boolean;
  readonly bulkActions?: boolean;
  readonly clipboard?: boolean;
  readonly copyOffsetDays?: number;
  readonly onChange?: (detail: EventSchedulerEventSelectedDetail) => void
}

---

EventSchedulerClipboardAdapter

interface EventSchedulerClipboardAdapter {
  readonly read?: () => EventSchedulerClipboardPayload | null | undefined | Promise<EventSchedulerClipboardPayload | null | undefined>;
  readonly write?: (payload: EventSchedulerClipboardPayload) => void | Promise<void>;
  readonly clear?: () => void | Promise<void>;
  readonly hasPayload?: () => boolean
}

---

EventSchedulerCopiedEvent

interface EventSchedulerCopiedEvent {
  readonly event: EventSchedulerEventEntity;
  readonly offsetMinutes: number
}

---

EventSchedulerClipboardPayload

interface EventSchedulerClipboardPayload {
  readonly type: 'event-scheduler-events';
  readonly version: 1;
  readonly copiedAt: string;
  readonly baseStartDateTime: string;
  readonly events: readonly EventSchedulerCopiedEvent[]
}

---

EventSchedulerPasteOptions

interface EventSchedulerPasteOptions {
  /** Requested target base. Scheduler snaps it to the active edit interval. */
    readonly startDateTime?: string;
  /** Optional resource override applied to every pasted event. */
    readonly resourceId?: EventSchedulerEntityId;
  /** Optional suffix used while generating collision-free copied event ids. */
    readonly idSuffix?: string
}

---

EventSchedulerDuplicateRangeOptions

interface EventSchedulerDuplicateRangeOptions {
  readonly sourceStartDateTime: string;
  readonly sourceEndDateTime: string;
  readonly targetStartDateTime: string;
  readonly resourceIds?: readonly EventSchedulerEntityId[]
}

---

EventSchedulerResourceEntity

Resource row in resource-timeline mode.

A resource can represent a person, room, vehicle, machine, location, team, or any other schedulable capacity. locked, readonly, or disabled resources reject create/drop/reassign actions.

interface EventSchedulerResourceEntity {
  readonly id: EventSchedulerEntityId;
  readonly parentId?: EventSchedulerEntityId;
  readonly name: string;
  /** Optional profile image URL used by the built-in resource cell. */
    readonly avatarUrl?: string;
  readonly role?: string;
  readonly group?: string;
  readonly color?: string;
  readonly calendarId?: CalendarId;
  readonly capacity?: number;
  readonly disabled?: boolean;
  readonly locked?: boolean;
  readonly readonly?: boolean;
  readonly hidden?: boolean;
  readonly active?: boolean;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerCoverageStatus

export type EventSchedulerCoverageStatus = 'under' | 'met' | 'over';

---

EventSchedulerCoverageRequirementEntity

Required capacity or headcount over a time range for coverage planning.

interface EventSchedulerCoverageRequirementEntity {
  readonly id: EventSchedulerEntityId;
  readonly startDateTime: string;
  readonly endDateTime: string;
  readonly required: number;
  readonly label?: string;
  readonly role?: string;
  readonly group?: string;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resourceIds?: readonly EventSchedulerEntityId[];
  readonly className?: string;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerCoverageRequirementContext

interface EventSchedulerCoverageRequirementContext {
  readonly requirement: EventSchedulerCoverageRequirementEntity;
  readonly resource: EventSchedulerResourceEntity
}

---

EventSchedulerCoverageCountContext

interface EventSchedulerCoverageCountContext {
  readonly requirement: EventSchedulerCoverageRequirementEntity;
  readonly event: EventSchedulerEventEntity;
  readonly segment: EventSchedulerEventSegment;
  readonly resource: EventSchedulerResourceEntity
}

---

EventSchedulerCoverageConfig

interface EventSchedulerCoverageConfig {
  readonly enabled?: boolean;
  readonly capacityField?: keyof EventSchedulerResourceEntity | string;
  readonly resourceMatchesRequirement?: (context: EventSchedulerCoverageRequirementContext) => boolean;
  readonly countEvent?: (context: EventSchedulerCoverageCountContext) => number | boolean;
  readonly summaryFormatter?: (summary: EventSchedulerCoverageSummary) => string
}

---

EventSchedulerCoverageResult

interface EventSchedulerCoverageResult {
  readonly id: string;
  readonly requirementId: EventSchedulerEntityId;
  readonly requirement: EventSchedulerCoverageRequirementEntity;
  readonly label: string;
  readonly date: string;
  readonly startDateTime: string;
  readonly endDateTime: string;
  readonly required: number;
  readonly assigned: number;
  readonly missing: number;
  readonly surplus: number;
  readonly status: EventSchedulerCoverageStatus;
  readonly resourceIds: readonly EventSchedulerEntityId[];
  readonly eventIds: readonly EventSchedulerEntityId[]
}

---

EventSchedulerCoverageSummary

interface EventSchedulerCoverageSummary {
  readonly requirementCount: number;
  readonly underCount: number;
  readonly overCount: number;
  readonly metCount: number;
  readonly missingTotal: number;
  readonly surplusTotal: number
}

---

EventSchedulerUtilizationStatus

export type EventSchedulerUtilizationStatus = 'under' | 'balanced' | 'over';

---

EventSchedulerUtilizationTargetContext

interface EventSchedulerUtilizationTargetContext {
  readonly resource: EventSchedulerResourceEntity;
  readonly config: EventSchedulerResolvedConfig;
  readonly segments: readonly EventSchedulerEventSegment[];
  readonly dates: readonly string[]
}

---

EventSchedulerUtilizationCountContext

interface EventSchedulerUtilizationCountContext {
  readonly event: EventSchedulerEventEntity;
  readonly segment: EventSchedulerEventSegment;
  readonly resource: EventSchedulerResourceEntity;
  readonly defaultMinutes: number
}

---

EventSchedulerUtilizationConfig

interface EventSchedulerUtilizationConfig {
  readonly enabled?: boolean;
  readonly targetHours?: number | ((context: EventSchedulerUtilizationTargetContext) => number | undefined);
  readonly minHours?: number | ((context: EventSchedulerUtilizationTargetContext) => number | undefined);
  readonly maxHours?: number | ((context: EventSchedulerUtilizationTargetContext) => number | undefined);
  readonly targetHoursField?: keyof EventSchedulerResourceEntity | string;
  readonly minHoursField?: keyof EventSchedulerResourceEntity | string;
  readonly maxHoursField?: keyof EventSchedulerResourceEntity | string;
  readonly includeStatuses?: readonly string[];
  readonly excludeStatuses?: readonly string[];
  readonly countEvent?: (context: EventSchedulerUtilizationCountContext) => number | boolean;
  readonly summaryFormatter?: (summary: EventSchedulerUtilizationSummary) => string
}

---

EventSchedulerUtilizationResult

interface EventSchedulerUtilizationResult {
  readonly resourceId: EventSchedulerEntityId;
  readonly resource: EventSchedulerResourceEntity;
  readonly eventCount: number;
  readonly totalMinutes: number;
  readonly totalHours: number;
  readonly targetHours?: number;
  readonly minHours?: number;
  readonly maxHours?: number;
  readonly utilizationPercent?: number;
  readonly status?: EventSchedulerUtilizationStatus;
  readonly eventIds: readonly EventSchedulerEntityId[]
}

---

EventSchedulerUtilizationSummary

interface EventSchedulerUtilizationSummary {
  readonly resourceCount: number;
  readonly measuredResourceCount: number;
  readonly eventCount: number;
  readonly totalMinutes: number;
  readonly totalHours: number;
  readonly targetHours: number;
  readonly minHours: number;
  readonly maxHours: number;
  readonly utilizationPercent?: number;
  readonly underCount: number;
  readonly balancedCount: number;
  readonly overCount: number
}

---

EventSchedulerUnassignedFilterConfig

interface EventSchedulerUnassignedFilterConfig {
  readonly dateRange?: EventSchedulerDateRange;
  readonly type?: string | readonly string[];
  readonly role?: string | readonly string[];
  readonly status?: string | readonly string[]
}

---

EventSchedulerUnassignedSummary

interface EventSchedulerUnassignedSummary {
  readonly totalCount: number;
  readonly visibleCount: number;
  readonly hiddenCount: number;
  readonly totalMinutes: number;
  readonly totalHours: number;
  readonly requiredRoles: readonly string[];
  readonly eventIds: readonly EventSchedulerEntityId[];
  readonly filteredEventIds: readonly EventSchedulerEntityId[]
}

---

EventSchedulerUnassignedRoleContext

interface EventSchedulerUnassignedRoleContext {
  readonly event: EventSchedulerEventEntity
}

---

EventSchedulerUnassignedRoleFormatterContext (Extended from index.ts)

interface EventSchedulerUnassignedRoleFormatterContext {
  readonly role: string;
  readonly labels: EventSchedulerLabels
}

---

EventSchedulerUnassignedAssignmentContext

interface EventSchedulerUnassignedAssignmentContext {
  readonly event: EventSchedulerEventEntity;
  readonly previousEvent: EventSchedulerEventEntity;
  readonly resource: EventSchedulerResourceEntity;
  readonly resourceId: EventSchedulerEntityId;
  readonly startDateTime: string;
  readonly endDateTime: string
}

---

EventSchedulerUnassignedConfig

Unassigned-demand settings for events without resourceId or resourceIds.

interface EventSchedulerUnassignedConfig {
  readonly enabled?: boolean;
  readonly showCount?: boolean;
  readonly filter?: EventSchedulerUnassignedFilterConfig;
  readonly requiredRoleField?: keyof EventSchedulerEventEntity | string;
  readonly requiredRoleResolver?: (context: EventSchedulerUnassignedRoleContext) => string | undefined;
  readonly requiredRoleFormatter?: (context: EventSchedulerUnassignedRoleFormatterContext) => string;
  readonly counterFormatter?: (summary: EventSchedulerUnassignedSummary) => string;
  readonly assignmentValidator?: (context: EventSchedulerUnassignedAssignmentContext) => boolean | string | void
}

---

EventSchedulerFilterState

interface EventSchedulerFilterState {
  readonly search?: string;
  readonly resourceIds?: readonly EventSchedulerEntityId[];
  readonly resourceRoles?: string | readonly string[];
  readonly resourceGroups?: string | readonly string[];
  readonly resourceLocations?: string | readonly string[];
  readonly eventTypes?: string | readonly string[];
  readonly eventStatuses?: string | readonly string[];
  readonly eventCategories?: string | readonly string[];
  readonly conflictTypes?: EventSchedulerConflictType | readonly EventSchedulerConflictType[];
  readonly conflictSeverities?: EventSchedulerConflictSeverity | readonly EventSchedulerConflictSeverity[];
  readonly conflictsOnly?: boolean;
  readonly unassignedOnly?: boolean;
  readonly dateRange?: EventSchedulerDateRange
}

---

EventSchedulerSavedView

Named scheduler filter/range preset that products can expose as saved views.

interface EventSchedulerSavedView {
  readonly id: EventSchedulerEntityId;
  readonly label: string;
  readonly description?: string;
  readonly view?: EventSchedulerView;
  readonly weekStartDate?: string;
  readonly dateRange?: EventSchedulerDateRange;
  readonly visibleDays?: readonly number[];
  readonly slotMinutes?: number;
  readonly timeRange?: EventSchedulerTimeRange;
  readonly filters?: EventSchedulerFilterState;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerSavedViewsConfig

interface EventSchedulerSavedViewsConfig {
  readonly views?: readonly EventSchedulerSavedView[];
  readonly activeViewId?: EventSchedulerEntityId
}

---

EventSchedulerFilterSummary

interface EventSchedulerFilterSummary {
  readonly activeSavedViewId?: EventSchedulerEntityId;
  readonly search: string;
  readonly resourcesTotal: number;
  readonly resourcesVisible: number;
  readonly resourcesHidden: number;
  readonly eventsTotal: number;
  readonly eventsVisible: number;
  readonly eventsHidden: number;
  readonly resourceIds: readonly EventSchedulerEntityId[];
  readonly eventIds: readonly EventSchedulerEntityId[];
  readonly filteredResourceIds: readonly EventSchedulerEntityId[];
  readonly filteredEventIds: readonly EventSchedulerEntityId[]
}

---

EventSchedulerResourceGroupBy

export type EventSchedulerResourceGroupBy =
  | keyof EventSchedulerResourceEntity
  | string
  | ((resource: EventSchedulerResourceEntity) => EventSchedulerEntityId | readonly EventSchedulerEntityId[] | null | undefined);

---

EventSchedulerResourceGroupSummary

interface EventSchedulerResourceGroupSummary {
  readonly eventCount: number;
  readonly totalMinutes: number;
  readonly totalHours: number;
  readonly resourceCount: number;
  readonly coverage?: EventSchedulerCoverageSummary;
  readonly utilization?: EventSchedulerUtilizationSummary
}

---

EventSchedulerResourceGroupContext

interface EventSchedulerResourceGroupContext {
  readonly id: string;
  readonly key: EventSchedulerEntityId;
  readonly label: string;
  readonly depth: number;
  readonly path: readonly string[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly summary: EventSchedulerResourceGroupSummary
}

---

EventSchedulerResourceGroupingConfig

interface EventSchedulerResourceGroupingConfig {
  readonly enabled?: boolean;
  readonly groupBy?: EventSchedulerResourceGroupBy | readonly EventSchedulerResourceGroupBy[];
  readonly tree?: boolean;
  readonly parentIdField?: keyof EventSchedulerResourceEntity | string;
  readonly collapsed?: boolean;
  readonly collapsedGroupIds?: readonly EventSchedulerEntityId[];
  readonly expandedGroupIds?: readonly EventSchedulerEntityId[];
  readonly sort?: (left: EventSchedulerResourceEntity, right: EventSchedulerResourceEntity) => number;
  readonly groupSort?: (left: EventSchedulerResourceGroupContext, right: EventSchedulerResourceGroupContext) => number;
  readonly groupLabelFormatter?: (context: EventSchedulerResourceGroupContext) => string;
  readonly groupSummaryFormatter?: (context: EventSchedulerResourceGroupContext) => string
}

---

EventSchedulerAssignmentEntity

interface EventSchedulerAssignmentEntity {
  readonly id: EventSchedulerEntityId;
  readonly eventId: EventSchedulerEntityId;
  readonly resourceId: EventSchedulerEntityId;
  readonly status?: EventSchedulerStatus | string;
  readonly locked?: boolean;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerAvailabilityEntity

Working, blocked, holiday, or break interval used as timeline background and conflict input.

interface EventSchedulerAvailabilityEntity {
  readonly id: EventSchedulerEntityId;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resourceIds?: readonly EventSchedulerEntityId[];
  readonly startDateTime: string;
  readonly endDateTime: string;
  readonly kind: EventSchedulerAvailabilityKind;
  readonly title?: string;
  readonly reason?: string;
  readonly status?: EventSchedulerStatus | string;
  readonly className?: string;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerConflictConfig

Conflict engine configuration for warning, blocking, confirm, allow, or ignore behavior.

interface EventSchedulerConflictConfig {
  readonly enabled?: boolean;
  readonly policy?: EventSchedulerConflictPolicy;
  readonly scope?: EventSchedulerConflictScope;
  readonly rules?: Partial<Record<EventSchedulerConflictType, EventSchedulerConflictRulePolicy>>;
  readonly minDurationMinutes?: number;
  readonly maxDurationMinutes?: number;
  readonly messages?: Partial<Record<EventSchedulerConflictType, string>>
}

---

EventSchedulerPermissionContext

interface EventSchedulerPermissionContext {
  readonly event: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  readonly action: EventSchedulerMutationAction
}

---

EventSchedulerPermissionDecision

export type EventSchedulerPermissionDecision =
  | boolean
  | string
  | void
  | {
      readonly allowed?: boolean;
      readonly message?: string;
    };

---

EventSchedulerCreatePermissionContext

interface EventSchedulerCreatePermissionContext {
  readonly action: 'create' | 'paste' | 'duplicate' | 'template-create' | 'recurrence-create';
  readonly event?: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  readonly resourceId?: EventSchedulerEntityId;
  readonly startDateTime: string;
  readonly endDateTime: string
}

---

EventSchedulerMutationPermissionContext

interface EventSchedulerMutationPermissionContext {
  readonly action: EventSchedulerMutationAction;
  readonly event: EventSchedulerEventEntity;
  readonly nextEvent?: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  readonly targetResource?: EventSchedulerResourceEntity;
  readonly changes?: Partial<EventSchedulerEventEntity>
}

---

EventSchedulerPermissionsConfig

Access-control settings for embedded products.

This is evaluated in addition to legacy editable and allow* flags. It covers read-only mode, resource locks, date locks, status locks, and product-specific checks.

Example:

eventScheduler: {
  weekStartDate: '2026-06-08',
  permissions: {
    lockedStatuses: ['completed'],
    lockedBeforeDateTime: '2026-06-08T00:00:00.000Z',
    canMutate: ({ action, targetResource }) =>
      targetResource?.locked ? 'This resource is locked.' : action !== 'delete'
  }
}

interface EventSchedulerPermissionsConfig {
  /** Makes the whole scheduler non-editable while keeping selection, tooltips, and scrolling active. */
    readonly readOnly?: boolean;
  /** Event statuses that cannot be moved, resized, edited, or deleted. */
    readonly lockedStatuses?: readonly string[];
  /** Date-time ranges where create, move, resize, edit, and delete are rejected. */
    readonly lockedDateRanges?: readonly EventSchedulerDateRange[];
  /** Rejects edits whose start time is before this ISO date-time. */
    readonly lockedBeforeDateTime?: string;
  /** Product hook for create/paste/template/recurrence creation decisions. */
    readonly canCreate?: (context: EventSchedulerCreatePermissionContext) => EventSchedulerPermissionDecision;
  /** Product hook for move/resize/reassign/edit/delete/bulk/recurrence mutation decisions. */
    readonly canMutate?: (context: EventSchedulerMutationPermissionContext) => EventSchedulerPermissionDecision
}

---

EventSchedulerTemplateResult

export type EventSchedulerTemplateResult = VNode | string | null | undefined;

---

EventSchedulerTemplateH

export type EventSchedulerTemplateH = (
  tag: string,
  props?: Record<string, unknown>,
  children?: unknown,
) => VNode;

---

EventSchedulerElementProps

export type EventSchedulerElementProps = Record<string, unknown>;

---

EventSchedulerRenderContext

interface EventSchedulerRenderContext {
  readonly event: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  /** First real projected segment represented by this visual bar. */
    readonly segment: EventSchedulerEventSegment;
  /** Ordered projected segments represented by this visual bar. */
    readonly segments: readonly EventSchedulerEventSegment[]
}

---

EventSchedulerEventRenderMode

export type EventSchedulerEventRenderMode = 'week' | 'timeline';

---

EventSchedulerEventSectionContext (Extended from index.ts)

interface EventSchedulerEventSectionContext {
  /** Event hooks run once for this visual assignment bar. */
    readonly mode: EventSchedulerEventRenderMode;
  /** @deprecated Event hooks now run once per bar, so this is always `true`. */
    readonly first: boolean;
  /** @deprecated Event hooks now run once per bar, so this is always `true`. */
    readonly last: boolean;
  /** @deprecated Use `segment.startSlot` or inspect `segments`. */
    readonly sliceSlot: number;
  readonly start: string;
  readonly end: string;
  readonly day: string;
  readonly duration: number;
  readonly status?: string;
  readonly type?: string;
  readonly isSelected: boolean;
  readonly isDragging: boolean;
  readonly isResizing: boolean;
  readonly isLocked: boolean;
  readonly hasConflict: boolean;
  readonly isReadonly: boolean;
  readonly isFromPreviousDay: boolean;
  readonly isContinuedToNextDay: boolean;
  readonly isShortEvent: boolean
}

---

EventSchedulerEventBadgeContext (Extended from index.ts)

interface EventSchedulerEventBadgeContext {
  readonly kind: 'status' | 'type' | 'category' | 'requiredRole';
  readonly label: string
}

---

EventSchedulerEventResizeHandleContext (Extended from index.ts)

interface EventSchedulerEventResizeHandleContext {
  readonly edge: 'start' | 'end'
}

---

EventSchedulerConflictDisplayContext (Extended from index.ts)

interface EventSchedulerConflictDisplayContext {
  /** Highest conflict severity across the rendered event bar. */
    readonly severity: EventSchedulerConflictSeverity;
  /** Conflict rule types across the rendered event bar, such as `overlap` or `blocked-time`. */
    readonly conflictTypes: readonly EventSchedulerConflictType[];
  /** Stable conflict ids across the rendered event bar. */
    readonly conflictIds: readonly string[];
  /** Human-readable conflict label built from scheduler labels and conflict types. */
    readonly label: string
}

---

EventSchedulerEventSectionTemplate

export type EventSchedulerEventSectionTemplate<TContext extends EventSchedulerEventSectionContext = EventSchedulerEventSectionContext> = (
  createElement: EventSchedulerTemplateH,
  context: TContext,
) => EventSchedulerTemplateResult;

---

EventSchedulerTimelineHeaderContext

interface EventSchedulerTimelineHeaderContext {
  readonly date: string;
  readonly dayIndex: number;
  readonly slotIndex: number;
  readonly timelineSlotIndex: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly startDateTime: string;
  readonly endDateTime: string
}

---

EventSchedulerHeaderKind

export type EventSchedulerHeaderKind = 'time' | 'resource' | 'day' | 'timeline' | 'group';

---

EventSchedulerHeaderGroupKind

export type EventSchedulerHeaderGroupKind = 'day' | 'range' | 'timeline';

---

EventSchedulerHeaderContext

interface EventSchedulerHeaderContext {
  readonly kind: EventSchedulerHeaderKind;
  readonly view: EventSchedulerView;
  readonly defaultLabel: string;
  readonly date?: string;
  readonly dayIndex?: number;
  readonly slotIndex?: number;
  readonly timelineSlotIndex?: number;
  readonly startMinutes?: number;
  readonly endMinutes?: number;
  readonly startDateTime?: string;
  readonly endDateTime?: string;
  readonly eventCount?: number;
  readonly today?: boolean;
  readonly weekend?: boolean;
  readonly holiday?: boolean;
  readonly holidayLabel?: string;
  readonly groupKind?: EventSchedulerHeaderGroupKind
}

---

EventSchedulerCellContext

interface EventSchedulerCellContext {
  readonly view: EventSchedulerView;
  readonly row: EventSchedulerGridRow
}

---

EventSchedulerTimeCellContext (Extended from index.ts)

interface EventSchedulerTimeCellContext {
  readonly slotIndex: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly timeLabel: string;
  readonly currentTimeLabel?: string
}

---

EventSchedulerCurrentTimeMarkerContext

interface EventSchedulerCurrentTimeMarkerContext {
  readonly view: EventSchedulerView;
  readonly date: string;
  readonly dayIndex: number;
  readonly slotIndex: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly dateTime: string;
  readonly label: string;
  readonly position: number;
  readonly orientation: 'horizontal' | 'vertical';
  readonly row?: EventSchedulerGridRow;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resource?: EventSchedulerResourceEntity
}

---

EventSchedulerSlotContext

interface EventSchedulerSlotContext {
  readonly date: string;
  readonly dayIndex: number;
  readonly slotIndex: number;
  readonly startDateTime: string;
  readonly endDateTime: string
}

---

EventSchedulerSlotRenderContext (Extended from index.ts)

interface EventSchedulerSlotRenderContext {
  readonly view: EventSchedulerView;
  readonly row: EventSchedulerGridRow;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly segmentCount: number;
  readonly today: boolean;
  readonly weekend: boolean;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resource?: EventSchedulerResourceEntity;
  readonly disabled: boolean;
  readonly selectable: boolean
}

---

EventSchedulerDayCellContext (Extended from index.ts)

interface EventSchedulerDayCellContext {

}

---

EventSchedulerClosedSlotContext (Extended from index.ts)

interface EventSchedulerClosedSlotContext {
  readonly available: boolean;
  readonly availabilityKind: EventSchedulerAvailabilityKind | 'closed';
  readonly availabilityId?: EventSchedulerEntityId;
  readonly title?: string;
  readonly reason?: string
}

---

EventSchedulerResourceCellContext (Extended from index.ts)

interface EventSchedulerResourceCellContext {
  readonly resource?: EventSchedulerResourceEntity;
  readonly resourceId?: EventSchedulerEntityId;
  readonly depth: number;
  readonly unassigned: boolean
}

---

EventSchedulerResourceGroupCellContext (Extended from index.ts)

interface EventSchedulerResourceGroupCellContext {
  readonly groupId?: string;
  readonly groupLabel?: string;
  readonly depth: number;
  readonly expanded: boolean
}

---

EventSchedulerTimelineCellContext (Extended from index.ts)

interface EventSchedulerTimelineCellContext {
  readonly column: EventSchedulerTimelineColumn;
  readonly date: string;
  readonly dayIndex: number;
  readonly slotIndex: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly segmentCount: number
}

---

EventSchedulerCreateRangeContext (Extended from index.ts)

interface EventSchedulerCreateRangeContext {
  readonly startSlot: number;
  readonly endSlot: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly durationMinutes: number;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resource?: EventSchedulerResourceEntity
}

---

EventSchedulerCreateRangeDisplayContext (Extended from index.ts)

interface EventSchedulerCreateRangeDisplayContext {
  readonly title: string;
  readonly startLabel: string;
  readonly endLabel: string;
  readonly durationLabel: string;
  readonly label: string
}

---

EventSchedulerEmptyStateKind

export type EventSchedulerEmptyStateKind = 'loading' | 'refreshing' | 'saving' | 'empty' | 'error';

---

EventSchedulerEmptyStateContext

interface EventSchedulerEmptyStateContext {
  /** Current state rendered in the scheduler overlay. */
    readonly kind: EventSchedulerEmptyStateKind;
  /** Default text resolved from `labels` and `emptyStateText`. */
    readonly label: string;
  /** Remote or loading error message when `kind` is `error`. */
    readonly error?: string
}

---

EventSchedulerEmptyStateTemplate

Replaces the scheduler loading, error, or empty overlay content.

Example:

customization: {
  emptyState: {
    template: ({ kind, label }) => `${kind}: ${label}`,
  },
}

/** Replaces the scheduler loading, error, or empty overlay content.
 *
 * @example
 * ```ts
 * customization: {
 *   emptyState: {
 *     template: ({ kind, label }) = > `${kind}: ${label}`,
 *   },
 * }
 * ```
 */
export type EventSchedulerEmptyStateTemplate = (
  context: EventSchedulerEmptyStateContext,
) => string | Node | null | undefined;

---

EventSchedulerCreateRangeTemplate

export type EventSchedulerCreateRangeTemplate = (
  context: EventSchedulerCreateRangeDisplayContext,
) => string | Node | null | undefined;

---

EventSchedulerColumnSizeConfig

interface EventSchedulerColumnSizeConfig {
  readonly timeColumnSize?: number;
  readonly dayColumnSize?: number;
  readonly resourceColumnSize?: number;
  readonly timelineColumnSize?: number
}

---

EventSchedulerViewColumnSizeConfig

export type EventSchedulerViewColumnSizeConfig = Partial<Record<EventSchedulerView, EventSchedulerColumnSizeConfig>>;

---

EventSchedulerHeaderCustomizationConfig

interface EventSchedulerHeaderCustomizationConfig {
  readonly timeTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerHeaderContext) => EventSchedulerTemplateResult;
  readonly timeProperties?: (context: EventSchedulerHeaderContext) => EventSchedulerElementProps | undefined;
  readonly resourceTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerHeaderContext) => EventSchedulerTemplateResult;
  readonly resourceProperties?: (context: EventSchedulerHeaderContext) => EventSchedulerElementProps | undefined;
  readonly dayTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerHeaderContext) => EventSchedulerTemplateResult;
  readonly dayProperties?: (context: EventSchedulerHeaderContext) => EventSchedulerElementProps | undefined;
  readonly timelineTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerHeaderContext) => EventSchedulerTemplateResult;
  readonly timelineProperties?: (context: EventSchedulerHeaderContext) => EventSchedulerElementProps | undefined;
  readonly groupTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerHeaderContext) => EventSchedulerTemplateResult;
  readonly groupProperties?: (context: EventSchedulerHeaderContext) => EventSchedulerElementProps | undefined
}

---

EventSchedulerCellCustomizationConfig

interface EventSchedulerCellCustomizationConfig {
  readonly timeTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerTimeCellContext) => EventSchedulerTemplateResult;
  readonly timeProperties?: (context: EventSchedulerTimeCellContext) => EventSchedulerElementProps | undefined;
  readonly dayTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerDayCellContext) => EventSchedulerTemplateResult;
  readonly dayProperties?: (context: EventSchedulerDayCellContext) => EventSchedulerElementProps | undefined;
  readonly resourceTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerResourceCellContext) => EventSchedulerTemplateResult;
  readonly resourceProperties?: (context: EventSchedulerResourceCellContext) => EventSchedulerElementProps | undefined;
  readonly resourceGroupTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerResourceGroupCellContext) => EventSchedulerTemplateResult;
  readonly resourceGroupProperties?: (context: EventSchedulerResourceGroupCellContext) => EventSchedulerElementProps | undefined;
  readonly timelineTemplate?: (createElement: EventSchedulerTemplateH, context: EventSchedulerTimelineCellContext) => EventSchedulerTemplateResult;
  readonly timelineProperties?: (context: EventSchedulerTimelineCellContext) => EventSchedulerElementProps | undefined
}

---

EventSchedulerEventCustomizationConfig

interface EventSchedulerEventCustomizationConfig {
  readonly className?: string | ((context: EventSchedulerEventSectionContext) => string | undefined);
  readonly style?: (context: EventSchedulerEventSectionContext) => Record<string, string | number | undefined> | undefined;
  readonly properties?: (context: EventSchedulerEventSectionContext) => EventSchedulerElementProps | undefined;
  readonly content?: EventSchedulerEventSectionTemplate;
  readonly continuationLabels?: EventSchedulerEventSectionTemplate;
  readonly badgeTray?: EventSchedulerEventSectionTemplate;
  readonly badge?: EventSchedulerEventSectionTemplate<EventSchedulerEventBadgeContext>;
  readonly resizeHandle?: EventSchedulerEventSectionTemplate<EventSchedulerEventResizeHandleContext>;
  readonly tooltip?: (context: EventSchedulerEventSectionContext) => string | undefined;
  readonly ariaLabel?: (context: EventSchedulerEventSectionContext) => string | undefined
}

---

EventSchedulerCreatePreviewCustomizationConfig

interface EventSchedulerCreatePreviewCustomizationConfig {
  readonly hoverTimeProperties?: (context: EventSchedulerSlotContext) => EventSchedulerElementProps | undefined;
  readonly createRangeTemplate?: (context: EventSchedulerCreateRangeDisplayContext) => string | Node | null | undefined;
  readonly createRangeProperties?: (context: EventSchedulerCreateRangeDisplayContext) => EventSchedulerElementProps | undefined
}

---

EventSchedulerConflictCustomizationConfig

interface EventSchedulerConflictCustomizationConfig {
  /** Adds classes to conflicted event blocks.
     *
     * @example
     * ```ts
     * className: ({ severity }) => `booking-conflict--${severity}`
     * ```
     */
    readonly className?: string | ((context: EventSchedulerConflictDisplayContext) => string | undefined);
  /** Adds attributes, classes, styles, or data fields to conflicted event blocks. */
    readonly properties?: (context: EventSchedulerConflictDisplayContext) => EventSchedulerElementProps | undefined;
  /** Renders a custom conflict indicator inside the event block. */
    readonly indicator?: EventSchedulerEventSectionTemplate<EventSchedulerConflictDisplayContext>;
  /** Overrides the event tooltip when a segment has conflicts. */
    readonly tooltip?: (context: EventSchedulerConflictDisplayContext) => string | undefined
}

---

EventSchedulerEmptyStateCustomizationConfig

interface EventSchedulerEmptyStateCustomizationConfig {
  /** Replaces the scheduler loading, empty, saving, refreshing, or error overlay content. */
    readonly template?: EventSchedulerEmptyStateTemplate;
  /** Adds classes, style variables, ARIA attributes, or data fields to the overlay element. */
    readonly properties?: (context: EventSchedulerEmptyStateContext) => EventSchedulerElementProps | undefined
}

---

EventSchedulerCustomizationConfig

interface EventSchedulerCustomizationConfig {
  /** Per-view generated column size overrides. */
    readonly columnSizes?: EventSchedulerViewColumnSizeConfig;
  /** Generated scheduler header templates and properties. */
    readonly headers?: EventSchedulerHeaderCustomizationConfig;
  /** Generated scheduler cell templates and properties. */
    readonly cells?: EventSchedulerCellCustomizationConfig;
  /** Event block content, badges, handles, classes, styles, tooltips, and ARIA hooks. */
    readonly events?: EventSchedulerEventCustomizationConfig;
  /** Empty-slot hover and drag-create range preview hooks. */
    readonly createPreview?: EventSchedulerCreatePreviewCustomizationConfig;
  /** Conflict-specific event block classes, attributes, indicators, and tooltips. */
    readonly conflicts?: EventSchedulerConflictCustomizationConfig;
  /** Loading, empty, saving, refreshing, and error overlay customization. */
    readonly emptyState?: EventSchedulerEmptyStateCustomizationConfig
}

---

EventSchedulerEventEditorMode

export type EventSchedulerEventEditorMode = 'create' | 'edit';

---

EventSchedulerEventEditorStatusOption

interface EventSchedulerEventEditorStatusOption {
  readonly value: string;
  readonly label?: string
}

---

EventSchedulerLabels

interface EventSchedulerLabels {
  readonly resourceColumn: string;
  readonly noResources: string;
  readonly unassignedResource: string;
  readonly unassignedCountLabel: (count: number) => string;
  readonly requiredRolePrefix: string;
  readonly newEvent: string;
  readonly createEvent: string;
  readonly editEvent: string;
  readonly closeEditor: string;
  readonly closeEditorAriaLabel: string;
  readonly titleField: string;
  readonly startField: string;
  readonly endField: string;
  readonly resourceField: string;
  readonly resourceSearchPlaceholder: string;
  readonly resourceSearchAriaLabel: string;
  readonly noMatchingResources: string;
  readonly statusField: string;
  readonly notesField: string;
  readonly noStatus: string;
  readonly deleteAction: string;
  readonly copyAction: string;
  readonly pasteAction: string;
  readonly duplicateAction: string;
  readonly createEventHereAction: string;
  readonly assignOpenEventAction: string;
  readonly editEventAction: string;
  readonly confirmEventAction: string;
  readonly markPlannedAction: string;
  readonly reassignResourceAction: string;
  readonly lockAction: string;
  readonly unlockAction: string;
  readonly zoomInAction: string;
  readonly zoomOutAction: string;
  readonly emptyClipboard: string;
  readonly bulkStatusAction: string;
  readonly cancelAction: string;
  readonly saveAction: string;
  readonly lockedEditorMessage: string;
  readonly titleRequiredMessage: string;
  readonly dateTimeRequiredMessage: string;
  readonly endAfterStartMessage: string;
  readonly closed: string;
  readonly outsideWorkingHours: string;
  readonly closedDay: string;
  readonly statusPrefix: string;
  readonly typePrefix: string;
  readonly categoryPrefix: string;
  readonly conflict: string;
  readonly locked: string;
  readonly remoteLoading: string;
  readonly remoteRefreshing: string;
  readonly remoteSaving: string;
  readonly remoteEmpty: string;
  readonly remoteError: string;
  readonly remoteRetry: string;
  readonly statusLabel: (status: string) => string;
  readonly typeLabel: (type: string) => string;
  readonly categoryLabel: (category: string) => string
}

---

EventSchedulerEventEditorOpenContext

Context passed to a custom event editor.

interface EventSchedulerEventEditorOpenContext {
  readonly mode: EventSchedulerEventEditorMode;
  readonly event: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly labels: EventSchedulerLabels;
  readonly readonly: boolean;
  readonly validationMessage?: string;
  readonly submit: (changes: EventSchedulerEventEditChanges) => void;
  readonly delete: () => void;
  readonly close: () => void
}

---

EventSchedulerEventEditorHook

export type EventSchedulerEventEditorHook = (context: EventSchedulerEventEditorOpenContext) => boolean | void;

---

EventSchedulerEventTemplate

export type EventSchedulerEventTemplate = (
  createElement: (tag: string, props?: Record<string, unknown>, children?: unknown) => VNode,
  context: EventSchedulerEventSectionContext,
) => VNode | string | null | undefined;

---

EventSchedulerRemoteMode

export type EventSchedulerRemoteMode = 'local' | 'remote' | 'hybrid';

---

EventSchedulerRemoteLoadTarget

export type EventSchedulerRemoteLoadTarget = 'events' | 'resources' | 'availability' | 'coverage' | 'unassigned' | 'resource-children';

---

EventSchedulerRemoteMutationStatus

export type EventSchedulerRemoteMutationStatus = 'pending' | 'committed' | 'rejected';

---

EventSchedulerRemoteRangeRequest

interface EventSchedulerRemoteRangeRequest {
  readonly requestId: string;
  readonly dateRange: EventSchedulerDateRange;
  readonly timelineDates: readonly string[];
  readonly view: EventSchedulerView;
  readonly filters: EventSchedulerFilterState;
  readonly resourceIds?: readonly EventSchedulerEntityId[];
  readonly signal: AbortSignal
}

---

EventSchedulerRemoteResourceRequest (Extended from index.ts)

interface EventSchedulerRemoteResourceRequest {
  readonly parentId?: EventSchedulerEntityId;
  readonly cursor?: string;
  readonly offset?: number;
  readonly limit?: number
}

---

EventSchedulerRemoteEventsResult

interface EventSchedulerRemoteEventsResult {
  readonly events: readonly EventSchedulerEventEntity[];
  readonly assignments?: readonly EventSchedulerAssignmentEntity[];
  readonly rangeComplete?: boolean;
  readonly partial?: boolean
}

---

EventSchedulerRemoteResourcesResult

interface EventSchedulerRemoteResourcesResult {
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly cursor?: string;
  readonly hasMore?: boolean;
  readonly rangeComplete?: boolean;
  readonly partial?: boolean
}

---

EventSchedulerRemoteAvailabilityResult

interface EventSchedulerRemoteAvailabilityResult {
  readonly availability: readonly EventSchedulerAvailabilityEntity[];
  readonly rangeComplete?: boolean;
  readonly partial?: boolean
}

---

EventSchedulerRemoteCoverageResult

interface EventSchedulerRemoteCoverageResult {
  readonly coverageRequirements: readonly EventSchedulerCoverageRequirementEntity[];
  readonly rangeComplete?: boolean;
  readonly partial?: boolean
}

---

EventSchedulerRemoteValidationResult

interface EventSchedulerRemoteValidationResult {
  readonly accepted: boolean;
  readonly message?: string;
  readonly conflicts?: readonly EventSchedulerConflict[];
  readonly events?: readonly EventSchedulerEventEntity[];
  readonly assignments?: readonly EventSchedulerAssignmentEntity[]
}

---

EventSchedulerRemoteCommitResult (Extended from index.ts)

interface EventSchedulerRemoteCommitResult {
  readonly event?: EventSchedulerEventEntity;
  readonly deletedEventId?: EventSchedulerEntityId
}

---

EventSchedulerRemoteMutationRequest

interface EventSchedulerRemoteMutationRequest {
  readonly requestId: string;
  readonly action: EventSchedulerMutationAction;
  readonly eventId: EventSchedulerEntityId | null;
  readonly event: EventSchedulerEventEntity | null;
  readonly previousEvent?: EventSchedulerEventEntity;
  readonly previousEvents: readonly EventSchedulerEventEntity[];
  readonly events: readonly EventSchedulerEventEntity[];
  readonly changes: EventSchedulerEventEditChanges;
  readonly conflicts?: readonly EventSchedulerConflict[];
  readonly dateRange: EventSchedulerDateRange;
  readonly timelineDates: readonly string[];
  readonly signal: AbortSignal
}

---

EventSchedulerRemoteConfig

Remote-data hooks for server-backed or partially-loaded scheduler datasets.

Example:

eventScheduler: {
  view: 'resourceTimeline',
  weekStartDate: '2026-06-08',
  remote: {
    enabled: true,
    mode: 'remote',
    loadEvents: ({ dateRange, signal }) => api.loadEvents(dateRange, { signal }),
    commitMutation: ({ action, event, previousEvent }) => api.saveScheduleChange({ action, event, previousEvent })
  }
}

interface EventSchedulerRemoteConfig {
  readonly mode?: EventSchedulerRemoteMode;
  readonly enabled?: boolean;
  readonly debounceMs?: number;
  readonly overscanDays?: number;
  readonly resourcePageSize?: number;
  readonly loadEvents?: (request: EventSchedulerRemoteRangeRequest) => Promise<EventSchedulerRemoteEventsResult> | EventSchedulerRemoteEventsResult;
  readonly loadResources?: (request: EventSchedulerRemoteResourceRequest) => Promise<EventSchedulerRemoteResourcesResult> | EventSchedulerRemoteResourcesResult;
  readonly loadAvailability?: (request: EventSchedulerRemoteRangeRequest) => Promise<EventSchedulerRemoteAvailabilityResult> | EventSchedulerRemoteAvailabilityResult;
  readonly loadCoverage?: (request: EventSchedulerRemoteRangeRequest) => Promise<EventSchedulerRemoteCoverageResult> | EventSchedulerRemoteCoverageResult;
  readonly loadUnassignedEvents?: (request: EventSchedulerRemoteRangeRequest) => Promise<EventSchedulerRemoteEventsResult> | EventSchedulerRemoteEventsResult;
  readonly loadResourceChildren?: (request: EventSchedulerRemoteResourceRequest) => Promise<EventSchedulerRemoteResourcesResult> | EventSchedulerRemoteResourcesResult;
  readonly validateMutation?: (request: EventSchedulerRemoteMutationRequest) => Promise<EventSchedulerRemoteValidationResult> | EventSchedulerRemoteValidationResult;
  readonly commitMutation?: (request: EventSchedulerRemoteMutationRequest) => Promise<EventSchedulerRemoteCommitResult> | EventSchedulerRemoteCommitResult;
  readonly refreshPolicy?: 'visible-range' | 'changed-range' | 'none';
  readonly optimistic?: boolean;
  readonly rollbackOnError?: boolean
}

---

EventSchedulerRemoteState

Current remote-data lifecycle state exposed through plugin.getRemoteState().

interface EventSchedulerRemoteState {
  readonly enabled: boolean;
  readonly mode: EventSchedulerRemoteMode;
  readonly dateRange?: EventSchedulerDateRange;
  readonly loading: Readonly<Record<EventSchedulerRemoteLoadTarget | 'initial' | 'refresh' | 'mutation', boolean>>;
  readonly loaded: Readonly<Partial<Record<EventSchedulerRemoteLoadTarget, boolean>>>;
  readonly partial: boolean;
  readonly empty: boolean;
  readonly error?: string;
  readonly errorTarget?: EventSchedulerRemoteLoadTarget | 'mutation';
  readonly requestId?: string;
  readonly pendingEventIds: readonly EventSchedulerEntityId[];
  readonly failedEventIds: readonly EventSchedulerEntityId[];
  readonly resourceCursor?: string;
  readonly hasMoreResources: boolean
}

---

EventSchedulerDayHeaderShiftCountConfig

interface EventSchedulerDayHeaderShiftCountConfig {
  /** Enables per-day event counts in week/day/month headers. Defaults to true. */
    readonly enabled?: boolean;
  /** Formats the count label shown under the day/date header. */
    readonly formatter?: (count: number, context: { readonly date: string; readonly dayIndex: number }) => string
}

---

EventSchedulerTodayHighlightConfig

interface EventSchedulerTodayHighlightConfig {
  /** Enables today header/cell highlighting. Defaults to true. */
    readonly enabled?: boolean;
  /** Optional CSS class applied to today headers/cells. */
    readonly className?: string
}

---

EventSchedulerWeekendHighlightConfig

interface EventSchedulerWeekendHighlightConfig {
  /** Enables weekend header/cell highlighting. Defaults to true. */
    readonly enabled?: boolean;
  /** Weekday indexes treated as weekends. Defaults to Saturday/Sunday. */
    readonly days?: readonly number[];
  /** Optional CSS class applied to weekend headers/cells. */
    readonly className?: string
}

---

EventSchedulerWorkingHoursConfig

interface EventSchedulerWorkingHoursConfig {
  /** Weekdays where the ranges apply. Defaults to every visible day. */
    readonly days?: readonly number[];
  /** Working ranges for the configured days. */
    readonly ranges?: EventSchedulerTimeRange | readonly EventSchedulerTimeRange[];
  /** Per-weekday working ranges, where Sunday is 0 and Saturday is 6. Use `false` for a closed day. */
    readonly byDay?: Partial<Record<number, EventSchedulerTimeRange | readonly EventSchedulerTimeRange[] | false>>
}

---

EventSchedulerClosedHoursConfig

interface EventSchedulerClosedHoursConfig {
  readonly id?: EventSchedulerEntityId;
  readonly days?: readonly number[];
  readonly dates?: readonly string[];
  readonly ranges?: EventSchedulerTimeRange | readonly EventSchedulerTimeRange[];
  readonly title?: string;
  readonly reason?: string;
  readonly className?: string
}

---

EventSchedulerAvailabilityRuleContext (Extended from index.ts)

interface EventSchedulerAvailabilityRuleContext {
  readonly resourceId?: EventSchedulerEntityId
}

---

EventSchedulerAvailabilityRuleResult

interface EventSchedulerAvailabilityRuleResult {
  readonly available?: boolean;
  readonly title?: string;
  readonly reason?: string;
  readonly className?: string
}

---

EventSchedulerAvailabilityRule

export type EventSchedulerAvailabilityRule =
  | ((context: EventSchedulerAvailabilityRuleContext) => boolean | EventSchedulerAvailabilityRuleResult | null | undefined)
  | {
      readonly available?: boolean;
      readonly days?: readonly number[];
      readonly dates?: readonly string[];
      readonly ranges?: EventSchedulerTimeRange | readonly EventSchedulerTimeRange[];
      readonly title?: string;
      readonly reason?: string;
      readonly className?: string;
    };

---

EventSchedulerContextMenuTarget

export type EventSchedulerContextMenuTarget = 'event' | 'slot' | 'dayHeader' | 'timeRow' | 'background';

---

EventSchedulerContextMenuItemId

export type EventSchedulerContextMenuItemId =
  | 'event-title'
  | 'event-title-divider'
  | 'edit'
  | 'copy'
  | 'duplicate'
  | 'lock'
  | 'event-edit-divider'
  | 'confirm'
  | 'event-status-divider'
  | 'delete'
  | 'slot-title'
  | 'slot-title-divider'
  | 'create'
  | 'slot-create-divider'
  | 'paste'
  | 'zoom-divider'
  | 'zoomIn'
  | 'zoomOut';

---

EventSchedulerContextMenuItemMap

export type EventSchedulerContextMenuItemMap = Partial<Record<EventSchedulerContextMenuItemId, boolean>>;

---

EventSchedulerContextMenuItemsContext

interface EventSchedulerContextMenuItemsContext {
  /** Which scheduler surface opened the menu. */
    readonly target: EventSchedulerContextMenuTarget;
  /** Active scheduler projection when the menu opens. */
    readonly projection: EventSchedulerProjection;
  /** Event segment for event-bar menus. */
    readonly segment?: EventSchedulerEventSegment;
  /** Slot context for empty-cell menus. */
    readonly slot?: EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId };
  /** Resource id resolved from the clicked slot or event segment when available. */
    readonly resourceId?: EventSchedulerEntityId
}

---

EventSchedulerContextMenuActionContext (Extended from index.ts)

interface EventSchedulerContextMenuActionContext {
  /** Scheduler item id selected by the user. */
    readonly itemId: string;
  /** Original scheduler menu item when the item was produced from the scheduler-specific item API. */
    readonly item?: EventSchedulerContextMenuItem
}

---

EventSchedulerContextMenuItemHidden

export type EventSchedulerContextMenuItemHidden =
  | boolean
  | ((context: EventSchedulerContextMenuItemsContext) => boolean);

---

EventSchedulerContextMenuItemDisabled

export type EventSchedulerContextMenuItemDisabled =
  | boolean
  | ((context: EventSchedulerContextMenuItemsContext) => boolean);

---

EventSchedulerContextMenuItemAction

export type EventSchedulerContextMenuItemAction = (
  context: EventSchedulerContextMenuActionContext
) => void;

---

EventSchedulerContextMenuItem

interface EventSchedulerContextMenuItem {
  /** Stable action id emitted through `onContextMenuAction`. */
    readonly id: string;
  /** Visible item label. */
    readonly label?: string;
  /** CSS icon classes or inline SVG markup. */
    readonly icon?: string;
  /** Keyboard shortcut text rendered at the trailing edge. */
    readonly shortcut?: string;
  /** Keep item visible but disabled. */
    readonly disabled?: EventSchedulerContextMenuItemDisabled;
  /** Hide item for the current scheduler context. */
    readonly hidden?: EventSchedulerContextMenuItemHidden;
  /** Apply destructive styling. */
    readonly danger?: boolean;
  /** Render item as a separator. */
    readonly separator?: boolean;
  /** Optional group name/class suffix for visual grouping. */
    readonly group?: string;
  /** Run when selected. `onContextMenuAction` is also emitted after this callback. */
    readonly action?: EventSchedulerContextMenuItemAction;
  /** Keep the menu open after the action runs. */
    readonly keepOpen?: boolean;
  /** Raw Pro context-menu escape hatch for advanced cases. */
    readonly item?: ContextMenuItem
}

---

EventSchedulerContextMenuItemLike

export type EventSchedulerContextMenuItemLike = ContextMenuItem | EventSchedulerContextMenuItem;

---

EventSchedulerContextMenuItemContext (Extended from index.ts)

interface EventSchedulerContextMenuItemContext {
  /** Built-in Scheduler context-menu item id being transformed. */
    readonly itemId: EventSchedulerContextMenuItemId
}

---

EventSchedulerContextMenuItemsFactory

export type EventSchedulerContextMenuItemsFactory = (
  context: EventSchedulerContextMenuItemsContext
) => readonly EventSchedulerContextMenuItemLike[];

---

EventSchedulerContextMenuTemplate

export type EventSchedulerContextMenuTemplate = (
  h: EventSchedulerTemplateH,
  item: EventSchedulerContextMenuItem,
  context: EventSchedulerContextMenuItemsContext
) => EventSchedulerTemplateResult;

---

EventSchedulerContextMenuItemFilter

export type EventSchedulerContextMenuItemFilter = (
  item: ContextMenuItem,
  context: EventSchedulerContextMenuItemContext
) => ContextMenuItem | false | null | undefined;

---

EventSchedulerContextMenuConfig

interface EventSchedulerContextMenuConfig {
  /** Enables built-in Scheduler context menus. Defaults to true. */
    readonly enabled?: boolean;
  /** Append host row and header context-menu items after built-in Scheduler items. Defaults to true. */
    readonly includeHostItems?: boolean;
  /** Hide specific built-in Scheduler context-menu items by id. */
    readonly hiddenItems?: EventSchedulerContextMenuItemMap;
  /** Keep specific built-in Scheduler context-menu items visible but disabled by id. */
    readonly disabledItems?: EventSchedulerContextMenuItemMap;
  /** Extra Scheduler context-menu items appended after built-in Scheduler items. */
    readonly items?: readonly EventSchedulerContextMenuItemLike[] | EventSchedulerContextMenuItemsFactory;
  /** Slot/empty-cell menu items. Return items to replace the default slot menu for that target. */
    readonly getSlotContextMenuItems?: EventSchedulerContextMenuItemsFactory;
  /** Event-bar menu items. Return items to replace the default event menu for that target. */
    readonly getEventContextMenuItems?: EventSchedulerContextMenuItemsFactory;
  /** Optional day-header menu items for products that expose header commands. */
    readonly getDayHeaderContextMenuItems?: EventSchedulerContextMenuItemsFactory;
  /** Background menu items for empty scheduler space or slot backgrounds. */
    readonly getBackgroundContextMenuItems?: EventSchedulerContextMenuItemsFactory;
  /** Replace the content renderer for scheduler-specific menu items. */
    readonly contextMenuTemplate?: EventSchedulerContextMenuTemplate;
  /** Called after a scheduler-specific menu item action is selected. */
    readonly onContextMenuAction?: (context: EventSchedulerContextMenuActionContext) => void;
  /** Advanced hook for transforming or removing generated built-in Scheduler items. */
    readonly itemFilter?: EventSchedulerContextMenuItemFilter;
  /** Optional base context-menu config merged into the generated row menu. */
    readonly row?: Partial<ContextMenuConfig>;
  /** Optional base context-menu config merged into the generated Scheduler header menu. */
    readonly column?: Partial<ContextMenuConfig>
}

---

EventSchedulerKeyboardShortcutsConfig

interface EventSchedulerKeyboardShortcutsConfig {
  /** Enables built-in Scheduler keyboard shortcuts. Defaults to true. */
    readonly enabled?: boolean;
  /** Enables the built-in shortcuts help panel. Defaults to true. */
    readonly helpPanel?: boolean;
  /** Command-to-shortcut map. Set a command to `false` to disable it. */
    readonly shortcuts?: Partial<Record<EventSchedulerKeyboardCommand, string | readonly string[] | false>>
}

---

EventSchedulerKeyboardCommand

export type EventSchedulerKeyboardCommand =
  | 'escape'
  | 'help'
  | 'today'
  | 'search'
  | 'previous'
  | 'next'
  | 'cyclePrevious'
  | 'cycleNext'
  | 'open'
  | 'create'
  | 'edit'
  | 'lock'
  | 'delete'
  | 'copy'
  | 'paste'
  | 'duplicate'
  | 'viewWeek';

---

EventSchedulerContinuationLabelsConfig

interface EventSchedulerContinuationLabelsConfig {
  /** Enables labels on cross-day event segments. Defaults to true. */
    readonly enabled?: boolean;
  /** Label shown when the visible segment continues from a previous day. */
    readonly previousLabel?: string;
  /** Label shown when the visible segment continues into the next day. */
    readonly nextLabel?: string;
  /** Optional CSS class applied to continuation labels. */
    readonly className?: string;
  /** Custom formatter for continuation labels. Return an empty string to hide a label. */
    readonly formatter?: (direction: 'previous' | 'next', context: EventSchedulerRenderContext) => string
}

---

EventSchedulerTimelineHeaderUnit

Calendar unit rendered by one resource-timeline header row.

/** Calendar unit rendered by one resource-timeline header row. */
export type EventSchedulerTimelineHeaderUnit = 'year' | 'month' | 'day' | 'time';

---

EventSchedulerTimelineHeaderRowContext

Values available while formatting a configurable resource-timeline header row.

interface EventSchedulerTimelineHeaderRowContext {
  readonly id: string;
  readonly unit: EventSchedulerTimelineHeaderUnit;
  readonly date: string;
  readonly rowIndex: number;
  readonly isLeafRow: boolean;
  readonly defaultLabel: string;
  readonly dayIndex?: number;
  readonly slotIndex?: number;
  readonly timelineSlotIndex?: number;
  readonly startMinutes?: number;
  readonly endMinutes?: number;
  readonly startDateTime?: string;
  readonly endDateTime?: string
}

---

EventSchedulerTimelineHeaderRowConfig

One ordered resource-timeline header row, from the coarsest unit to the leaf unit.

interface EventSchedulerTimelineHeaderRowConfig {
  /** Stable row id used by formatters and future row-level customization. */
    readonly id: string;
  /** Calendar unit represented by this row. */
    readonly unit: EventSchedulerTimelineHeaderUnit;
  /** Overrides the built-in compact label for this row. */
    readonly formatter?: (context: EventSchedulerTimelineHeaderRowContext) => string
}

---

EventSchedulerZoomConfig

interface EventSchedulerZoomConfig {
  /** Enables Scheduler timescale zoom. Defaults to true. */
    readonly enabled?: boolean;
  /** Ordered or unordered slot sizes, in minutes, available to zoom actions. */
    readonly levels?: readonly number[]
}

---

EventSchedulerResolvedConfig

interface EventSchedulerResolvedConfig {
  readonly view: EventSchedulerView;
  readonly weekStartDate: string;
  readonly dateRange: EventSchedulerDateRange;
  readonly timelineDates: readonly string[];
  readonly timeZone?: string;
  readonly locale: string;
  readonly weekStartsOn: number;
  readonly visibleDays: readonly number[];
  readonly slotMinutes: number;
  readonly snapMinutes: number;
  readonly timeRange: EventSchedulerTimeRange;
  readonly zoom: Required<Pick<EventSchedulerZoomConfig, 'enabled'>> & {
      readonly levels?: readonly number[];
    };
  readonly editable: boolean;
  readonly allowCreate: EventSchedulerConfig['allowCreate'];
  readonly allowMove: EventSchedulerConfig['allowMove'];
  readonly allowResize: EventSchedulerConfig['allowResize'];
  readonly allowDelete: EventSchedulerConfig['allowDelete'];
  readonly rowSize: number;
  readonly timeColumnSize: number;
  readonly dayColumnSize: number;
  readonly resourceColumnSize: number;
  readonly timelineColumnSize: number;
  readonly customization?: EventSchedulerCustomizationConfig;
  readonly columnGrouping: boolean;
  readonly timelineHeaderRows: readonly EventSchedulerTimelineHeaderRowConfig[];
  readonly eventLayout: EventSchedulerEventLayout;
  readonly maxStackedEvents: number;
  readonly compactThreshold: number;
  readonly conflicts: Required<Omit<EventSchedulerConflictConfig, 'rules' | 'messages' | 'minDurationMinutes' | 'maxDurationMinutes'>> & {
      readonly rules: Readonly<Partial<Record<EventSchedulerConflictType, EventSchedulerConflictRulePolicy>>>;
      readonly minDurationMinutes?: number;
      readonly maxDurationMinutes?: number;
      readonly messages: Readonly<Partial<Record<EventSchedulerConflictType, string>>>;
    };
  readonly currentTimeMarker: EventSchedulerResolvedCurrentTimeMarkerConfig;
  readonly dayHeaderShiftCount: Required<Pick<EventSchedulerDayHeaderShiftCountConfig, 'enabled'>> & {
      readonly formatter?: EventSchedulerDayHeaderShiftCountConfig['formatter'];
    };
  readonly todayHighlight: Required<Pick<EventSchedulerTodayHighlightConfig, 'enabled'>> & {
      readonly className?: string;
    };
  readonly weekendHighlight: Required<Pick<EventSchedulerWeekendHighlightConfig, 'enabled' | 'days'>> & {
      readonly className?: string;
    };
  readonly contextMenu: Required<Pick<EventSchedulerContextMenuConfig, 'enabled' | 'includeHostItems'>>
      & Omit<EventSchedulerContextMenuConfig, 'enabled' | 'includeHostItems'>;
  readonly keyboardShortcuts: Required<Pick<EventSchedulerKeyboardShortcutsConfig, 'enabled' | 'helpPanel'>> & {
      readonly shortcuts: Readonly<Record<EventSchedulerKeyboardCommand, readonly string[] | false>>;
    };
  readonly continuationLabels: Required<Pick<EventSchedulerContinuationLabelsConfig, 'enabled' | 'previousLabel' | 'nextLabel'>> & {
      readonly className?: string;
      readonly formatter?: EventSchedulerContinuationLabelsConfig['formatter'];
    };
  readonly nonWorkingTime: EventSchedulerResolvedNonWorkingTimeConfig;
  readonly calendars: EventSchedulerResolvedCalendarsConfig;
  readonly resourceGrouping: EventSchedulerResourceGroupingConfig;
  readonly filters: EventSchedulerFilterState;
  readonly activeSavedViewId?: EventSchedulerEntityId;
  readonly selection: EventSchedulerSelectionConfig;
  readonly coverage: Required<Pick<EventSchedulerCoverageConfig, 'enabled'>>;
  readonly utilization: Required<Pick<EventSchedulerUtilizationConfig, 'enabled'>>;
  readonly unassigned: Required<Pick<EventSchedulerUnassignedConfig, 'enabled' | 'showCount'>>;
  readonly labels: EventSchedulerLabels;
  readonly source: EventSchedulerConfig
}

---

EventSchedulerGridRow (Extended from index.ts)

interface EventSchedulerGridRow {
  readonly __eventSchedulerSlot?: true;
  readonly __eventSchedulerResource?: true;
  readonly __eventSchedulerResourceGroup?: true;
  readonly __eventSchedulerEmpty?: true;
  readonly slotIndex: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly timeLabel: string;
  readonly currentTimeLabel?: string;
  readonly currentTimeTop?: number;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resource?: EventSchedulerResourceEntity;
  readonly resourceLabel?: string;
  readonly resourceDepth?: number;
  readonly resourceParentId?: EventSchedulerEntityId;
  readonly resourceGroupId?: string;
  readonly resourceGroupKey?: EventSchedulerEntityId;
  readonly resourceGroupLabel?: string;
  readonly resourceGroupPath?: readonly string[];
  readonly resourceGroupDepth?: number;
  readonly resourceGroupExpanded?: boolean;
  readonly resourceGroupSummary?: EventSchedulerResourceGroupSummary;
  readonly resourceGroupSummaryLabel?: string;
  readonly coverageSummary?: EventSchedulerCoverageSummary;
  readonly coverageSummaryLabel?: string;
  readonly utilization?: EventSchedulerUtilizationResult;
  readonly utilizationSummary?: EventSchedulerUtilizationSummary;
  readonly utilizationSummaryLabel?: string;
  readonly unassignedSummary?: EventSchedulerUnassignedSummary;
  readonly unassignedSummaryLabel?: string;
  readonly unassignedRequiredRolesLabel?: string;
  readonly [key: string]: unknown
}

---

EventSchedulerDayColumn (Extended from index.ts)

interface EventSchedulerDayColumn {
  readonly eventSchedulerDayIndex: number;
  readonly eventSchedulerDate: string;
  readonly eventSchedulerEventCount?: number;
  readonly eventSchedulerToday?: boolean;
  readonly eventSchedulerWeekend?: boolean;
  readonly eventSchedulerHoliday?: boolean;
  readonly eventSchedulerHolidayLabel?: string
}

---

EventSchedulerTimelineColumn (Extended from index.ts)

interface EventSchedulerTimelineColumn {
  readonly eventSchedulerDayIndex: number;
  readonly eventSchedulerDate: string;
  readonly eventSchedulerSlotIndex: number;
  readonly eventSchedulerTimelineSlotIndex: number;
  readonly eventSchedulerStartMinutes: number;
  readonly eventSchedulerEndMinutes: number;
  readonly eventSchedulerStartDateTime: string;
  readonly eventSchedulerEndDateTime: string
}

---

EventSchedulerTimeSlot

interface EventSchedulerTimeSlot {
  readonly index: number;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly label: string
}

---

EventSchedulerDay

interface EventSchedulerDay {
  readonly dayIndex: number;
  readonly date: string;
  readonly label: string;
  readonly columnProp: string;
  readonly eventCount: number;
  readonly today: boolean;
  readonly weekend: boolean;
  readonly holiday: boolean;
  readonly holidayLabel?: string
}

---

EventSchedulerEventSegment

interface EventSchedulerEventSegment {
  readonly id: string;
  readonly eventId: EventSchedulerEntityId;
  readonly event: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  readonly dayIndex: number;
  readonly date: string;
  readonly columnProp: string;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resourceIds: readonly EventSchedulerEntityId[];
  readonly assignmentIds: readonly EventSchedulerEntityId[];
  readonly unassigned: boolean;
  readonly startDateTime: string;
  readonly endDateTime: string;
  readonly startMinutes: number;
  readonly endMinutes: number;
  readonly startSlot: number;
  readonly endSlot: number;
  readonly laneIndex: number;
  readonly laneCount: number;
  readonly conflict: boolean;
  readonly conflictSeverity?: EventSchedulerConflictSeverity;
  readonly conflictTypes: readonly EventSchedulerConflictType[];
  readonly conflictIds: readonly string[];
  readonly clippedStart: boolean;
  readonly clippedEnd: boolean;
  readonly continuesFromPreviousDay: boolean;
  readonly continuesToNextDay: boolean
}

---

EventSchedulerConflict

interface EventSchedulerConflict {
  readonly id: string;
  readonly type: EventSchedulerConflictType;
  readonly severity: EventSchedulerConflictSeverity;
  readonly policy: EventSchedulerConflictRulePolicy;
  readonly message: string;
  readonly eventIds: readonly EventSchedulerEntityId[];
  readonly segmentIds: readonly string[];
  readonly resourceId?: EventSchedulerEntityId;
  readonly availabilityId?: EventSchedulerEntityId;
  readonly date: string;
  readonly startDateTime?: string;
  readonly endDateTime?: string;
  readonly metadata?: Record<string, unknown>
}

---

EventSchedulerNormalizedAvailability

interface EventSchedulerNormalizedAvailability {
  readonly id: EventSchedulerEntityId;
  readonly availability: EventSchedulerAvailabilityEntity;
  readonly resourceId?: EventSchedulerEntityId;
  readonly resourceIds: readonly EventSchedulerEntityId[];
  readonly unassigned: boolean;
  readonly startDateTime: string;
  readonly endDateTime: string;
  readonly kind: EventSchedulerAvailabilityKind;
  readonly date: string
}

---

EventSchedulerProjection

interface EventSchedulerProjection {
  readonly config: EventSchedulerResolvedConfig;
  readonly days: readonly EventSchedulerDay[];
  readonly slots: readonly EventSchedulerTimeSlot[];
  readonly rows: readonly EventSchedulerGridRow[];
  readonly columns: ColumnData;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly assignments: readonly EventSchedulerAssignmentEntity[];
  readonly availability: readonly EventSchedulerNormalizedAvailability[];
  readonly coverageRequirements: readonly EventSchedulerCoverageRequirementEntity[];
  readonly coverageResults: readonly EventSchedulerCoverageResult[];
  readonly utilizationResults: readonly EventSchedulerUtilizationResult[];
  readonly unassignedSummary: EventSchedulerUnassignedSummary;
  readonly filterSummary: EventSchedulerFilterSummary;
  readonly segments: readonly EventSchedulerEventSegment[];
  readonly conflicts: readonly EventSchedulerConflict[]
}

---

EventSchedulerBeforeEventChangeDetail

interface EventSchedulerBeforeEventChangeDetail {
  readonly action: EventSchedulerMutationAction;
  readonly eventId: EventSchedulerEntityId | null;
  readonly event: EventSchedulerEventEntity | null;
  readonly changes: Partial<EventSchedulerEventEntity>;
  readonly previousValues: Partial<EventSchedulerEventEntity>;
  readonly conflicts?: readonly EventSchedulerConflict[];
  readonly reason?: string
}

---

EventSchedulerEventChangedDetail

interface EventSchedulerEventChangedDetail {
  readonly action: EventSchedulerMutationAction;
  readonly eventId: EventSchedulerEntityId;
  readonly event: EventSchedulerEventEntity;
  readonly previousEvent?: EventSchedulerEventEntity;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly conflicts?: readonly EventSchedulerConflict[]
}

---

EventSchedulerEventDeletedDetail

interface EventSchedulerEventDeletedDetail {
  readonly eventId: EventSchedulerEntityId;
  readonly event: EventSchedulerEventEntity;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly conflicts?: readonly EventSchedulerConflict[]
}

---

EventSchedulerEventCopiedDetail

interface EventSchedulerEventCopiedDetail {
  readonly eventIds: readonly EventSchedulerEntityId[];
  readonly events: readonly EventSchedulerEventEntity[]
}

---

EventSchedulerEventSelectedDetail

interface EventSchedulerEventSelectedDetail {
  readonly eventId: EventSchedulerEntityId | null;
  readonly event: EventSchedulerEventEntity | null;
  readonly eventIds: readonly EventSchedulerEntityId[];
  readonly events: readonly EventSchedulerEventEntity[];
  readonly selectionMode: 'replace' | 'toggle' | 'range' | 'clear' | 'api'
}

---

EventSchedulerSlotSelectedDetail (Extended from index.ts)

interface EventSchedulerSlotSelectedDetail {
  readonly resourceId?: EventSchedulerEntityId;
  readonly selectionMode: 'replace' | 'toggle' | 'range' | 'clear' | 'api'
}

---

EventSchedulerBeforeSlotSelectDetail (Extended from index.ts)

interface EventSchedulerBeforeSlotSelectDetail {
  readonly resourceId?: EventSchedulerEntityId;
  readonly selectionMode: EventSchedulerSlotSelectedDetail['selectionMode']
}

---

EventSchedulerSlotClickDetail (Extended from index.ts)

interface EventSchedulerSlotClickDetail {
  readonly resourceId?: EventSchedulerEntityId
}

---

EventSchedulerConflictsUpdatedDetail

interface EventSchedulerConflictsUpdatedDetail {
  readonly conflicts: readonly EventSchedulerConflict[]
}

---

EventSchedulerRemoteLoadDetail

interface EventSchedulerRemoteLoadDetail {
  readonly target: EventSchedulerRemoteLoadTarget;
  readonly requestId: string;
  readonly dateRange?: EventSchedulerDateRange;
  readonly state: EventSchedulerRemoteState;
  readonly error?: string
}

---

EventSchedulerRemoteMutationDetail

interface EventSchedulerRemoteMutationDetail {
  readonly status: EventSchedulerRemoteMutationStatus;
  readonly requestId: string;
  readonly action: EventSchedulerMutationAction;
  readonly eventId: EventSchedulerEntityId | null;
  readonly event: EventSchedulerEventEntity | null;
  readonly previousEvent?: EventSchedulerEventEntity;
  /** Event collection before the optimistic mutation, used by domain history and rollback integrations. */
    readonly previousEvents: readonly EventSchedulerEventEntity[];
  readonly events: readonly EventSchedulerEventEntity[];
  readonly conflicts?: readonly EventSchedulerConflict[];
  readonly message?: string;
  readonly state: EventSchedulerRemoteState
}

---

EventSchedulerRemoteStateChangeDetail

interface EventSchedulerRemoteStateChangeDetail {
  readonly state: EventSchedulerRemoteState
}

---

EventSchedulerNavigateRequestDetail

interface EventSchedulerNavigateRequestDetail {
  readonly action: 'previous' | 'next' | 'today'
}

---

EventSchedulerViewRequestDetail

interface EventSchedulerViewRequestDetail {
  readonly view: EventSchedulerView
}

---

EventSchedulerResourceReassignRequestDetail

interface EventSchedulerResourceReassignRequestDetail {
  readonly eventId: EventSchedulerEntityId;
  readonly event: EventSchedulerEventEntity
}

---

EventSchedulerOpenShiftAssignRequestDetail (Extended from index.ts)

interface EventSchedulerOpenShiftAssignRequestDetail {
  readonly resourceId?: EventSchedulerEntityId
}

---

EventSchedulerSearchFocusRequestDetail

interface EventSchedulerSearchFocusRequestDetail {
  readonly reason: 'keyboard'
}

---

EventSchedulerColumnTypeMap

interface EventSchedulerColumnTypeMap {
  readonly eventSchedulerTime: ColumnType;
  readonly eventSchedulerDay: ColumnType;
  readonly eventSchedulerResource: ColumnType;
  readonly eventSchedulerTimeline: ColumnType
}

---

createEventSchedulerProjection

export function createEventSchedulerProjection(
  config: EventSchedulerConfig,
  events: readonly EventSchedulerEventEntity[] = [],
  resources: readonly EventSchedulerResourceEntity[] = [],
  assignments: readonly EventSchedulerAssignmentEntity[] = [],
  availability: readonly EventSchedulerAvailabilityEntity[] = [],
  coverageRequirements: readonly EventSchedulerCoverageRequirementEntity[] = [],
): EventSchedulerProjection;

---

createSlotContext

export function createSlotContext(
  projection: EventSchedulerProjection,
  dayIndex: number,
  slotIndex: number,
);

---

createRangeContext

export function createRangeContext(
  projection: EventSchedulerProjection,
  dayIndex: number,
  startSlot: number,
  endSlot: number,
  resourceId?: EventSchedulerEntityId,
  options: {
    readonly startMinutes?: number;
    readonly endMinutes?: number;
  } = {},
): EventSchedulerCreateRangeContext | null;

---

formatSchedulerDisplayTime

export function formatSchedulerDisplayTime(config: EventSchedulerResolvedConfig, minutes: number, slotIndex?: number): string;

---

EVENT_SCHEDULER_UNASSIGNED_RESOURCE_ID

EVENT_SCHEDULER_UNASSIGNED_RESOURCE_ID: string;

---

resolveUnassignedRequiredRole

export function resolveUnassignedRequiredRole(
  config: EventSchedulerResolvedConfig,
  event: EventSchedulerEventEntity,
): string | undefined;

---

moveEvent

Moves an event while preserving duration and optionally reassigning its resource.

export function moveEvent(
  context: EventSchedulerMutationContext,
  eventId: EventSchedulerEntityId,
  nextStartDateTime: string,
  nextResourceId?: EventSchedulerEntityId,
): EventSchedulerMutationResult;

---

resizeEvent

Resizes one event boundary while preserving the opposite boundary.

export function resizeEvent(
  context: EventSchedulerMutationContext,
  eventId: EventSchedulerEntityId,
  edge: EventSchedulerResizeEdge,
  nextDateTime: string,
  options: EventSchedulerResizeMutationOptions = {},
): EventSchedulerMutationResult;

---

editEvent

Applies editable event fields such as title, time, resource, status, and notes.

export function editEvent(
  context: EventSchedulerMutationContext,
  eventId: EventSchedulerEntityId,
  changes: EventSchedulerEventEditChanges,
): EventSchedulerMutationResult;

---

createEvent

Adds one event after permission, conflict, and before-change validation.

export function createEvent(
  context: EventSchedulerMutationContext,
  event: EventSchedulerEventEntity,
): EventSchedulerMutationResult;

---

deleteEvent

Removes one event after permission and before-change validation.

export function deleteEvent(
  context: EventSchedulerMutationContext,
  eventId: EventSchedulerEntityId,
): EventSchedulerMutationResult;

---

createEventFromSlot

Creates an event draft from a single scheduler slot.

export function createEventFromSlot(
  context: EventSchedulerMutationContext,
  options: {
    readonly id: EventSchedulerEntityId;
    readonly resourceId?: EventSchedulerEntityId;
    readonly title: string;
    readonly date: string;
    readonly startMinutes: number;
    readonly durationMinutes?: number;
  },
): EventSchedulerMutationResult;

---

createEventFromRange

Creates an event from a selected scheduler range.

export function createEventFromRange(
  context: EventSchedulerMutationContext,
  range: EventSchedulerCreateRangeContext,
): EventSchedulerMutationResult;

---

EventSchedulerMutationContext

interface EventSchedulerMutationContext {
  readonly config: EventSchedulerConfig;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly assignments?: readonly EventSchedulerAssignmentEntity[];
  readonly availability?: readonly EventSchedulerAvailabilityEntity[];
  readonly emitCancelable?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean
}

---

EventSchedulerMutationResult

Result of one scheduler event mutation.

interface EventSchedulerMutationResult {
  readonly events: readonly EventSchedulerEventEntity[];
  readonly event: EventSchedulerEventEntity;
  readonly previousEvent?: EventSchedulerEventEntity;
  readonly action: EventSchedulerMutationAction;
  readonly conflicts: NonNullable<EventSchedulerBeforeEventChangeDetail['conflicts']>
}

---

EventSchedulerResizeMutationOptions

interface EventSchedulerResizeMutationOptions {
  /**
     * Whether to snap the supplied boundary to the configured interval.
     *
     * Public API calls snap by default. Pointer interactions pass `false`
     * because their preview boundary was already snapped and range-clamped.
     */
    readonly snap?: boolean
}

---

uniqueEventIds

Returns unique event ids while preserving input order.

export function uniqueEventIds(ids: Iterable<EventSchedulerEntityId>): EventSchedulerEntityId[];

---

updateSelectedEventIds

Computes the next selected event ids for replace, toggle, range, or API selection modes.

export function updateSelectedEventIds(
  currentIds: readonly EventSchedulerEntityId[],
  eventId: EventSchedulerEntityId,
  mode: 'replace' | 'toggle' | 'range' | 'api',
  orderedEventIds: readonly EventSchedulerEntityId[],
  anchorId?: EventSchedulerEntityId,
): readonly EventSchedulerEntityId[];

---

buildEventSchedulerClipboardPayload

Builds the internal clipboard payload from selected events.

export function buildEventSchedulerClipboardPayload(
  events: readonly EventSchedulerEventEntity[],
  copiedAt = new Date().toISOString(),
): EventSchedulerClipboardPayload | null;

---

bulkMoveEvents

Moves selected events together while preserving their relative offsets.

export function bulkMoveEvents(
  context: EventSchedulerBulkContext,
  eventIds: readonly EventSchedulerEntityId[],
  anchorEventId: EventSchedulerEntityId,
  nextAnchorStartDateTime: string,
  nextResourceId?: EventSchedulerEntityId,
): EventSchedulerBulkResult;

---

bulkDeleteEvents

Deletes selected events atomically.

export function bulkDeleteEvents(
  context: EventSchedulerBulkContext,
  eventIds: readonly EventSchedulerEntityId[],
): EventSchedulerBulkResult;

---

bulkUpdateEventStatus

Updates status for selected events atomically.

export function bulkUpdateEventStatus(
  context: EventSchedulerBulkContext,
  eventIds: readonly EventSchedulerEntityId[],
  status: string,
): EventSchedulerBulkResult;

---

pasteCopiedEvents

Pastes copied events at a target start/resource when provided.

The requested target base is snapped once to the context’s effective edit interval; relative offsets within a multi-event clipboard payload are kept.

export function pasteCopiedEvents(
  context: EventSchedulerBulkContext,
  payload: EventSchedulerClipboardPayload,
  options: EventSchedulerPasteOptions = {},
): EventSchedulerBulkResult;

---

duplicateEvents

Duplicates selected events by an offset in days.

export function duplicateEvents(
  context: EventSchedulerBulkContext,
  eventIds: readonly EventSchedulerEntityId[],
  offsetDays = context.config.selection?.copyOffsetDays ?? 1,
): EventSchedulerBulkResult;

---

duplicateScheduleRange

Copies all events from one date range into another date range.

export function duplicateScheduleRange(
  context: EventSchedulerBulkContext,
  options: EventSchedulerDuplicateRangeOptions,
): EventSchedulerBulkResult;

---

EventSchedulerBulkContext

interface EventSchedulerBulkContext {
  readonly config: EventSchedulerConfig;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly assignments?: readonly EventSchedulerAssignmentEntity[];
  readonly availability?: readonly EventSchedulerAvailabilityEntity[];
  readonly emitCancelable?: (detail: EventSchedulerBeforeEventChangeDetail) => boolean
}

---

EventSchedulerBulkResult

Result of a bulk scheduler operation.

interface EventSchedulerBulkResult {
  readonly action: EventSchedulerMutationAction;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly changedEvents: readonly EventSchedulerEventEntity[];
  readonly previousEvents: readonly EventSchedulerEventEntity[];
  readonly conflicts: NonNullable<EventSchedulerBeforeEventChangeDetail['conflicts']>
}

---

idKey

export function idKey(id: EventSchedulerEntityId | null | undefined): string;

---

createEventFromTemplate

Creates one event from a configured scheduler template.

export function createEventFromTemplate(
  context: EventSchedulerTemplateContext,
  options: EventSchedulerTemplateCreateOptions,
): EventSchedulerBulkResult;

---

createRecurringEvents

Expands a template into daily or weekly recurring events.

export function createRecurringEvents(
  context: EventSchedulerTemplateContext,
  options: EventSchedulerRecurrenceCreateOptions,
): EventSchedulerBulkResult;

---

editRecurrenceSeries

Applies changes to every matching event in a recurrence series.

export function editRecurrenceSeries(
  context: EventSchedulerTemplateContext,
  options: EventSchedulerRecurrenceSeriesEditOptions,
): EventSchedulerBulkResult;

---

deleteRecurrenceSeries

Deletes every matching event in a recurrence series.

export function deleteRecurrenceSeries(
  context: EventSchedulerTemplateContext,
  options: EventSchedulerRecurrenceSeriesDeleteOptions,
): EventSchedulerBulkResult;

---

expandRecurrenceStartDateTimes

Expands a simple recurrence rule into ISO start date-times.

export function expandRecurrenceStartDateTimes(
  startDateTime: string,
  recurrence: EventSchedulerRecurrenceRule,
): readonly string[];

---

EventSchedulerTemplateContext (Extended from index.ts)

Context used by template and recurrence helper functions.

interface EventSchedulerTemplateContext {
  readonly templates: readonly EventSchedulerEventTemplateEntity[]
}

---

resolveEventSchedulerLabels

export function resolveEventSchedulerLabels(
  labels: Partial<EventSchedulerLabels> | undefined,
): EventSchedulerLabels;

---

DEFAULT_EVENT_SCHEDULER_LABELS

DEFAULT_EVENT_SCHEDULER_LABELS: {
  resourceColumn: string;
  noResources: string;
  unassignedResource: string;
  unassignedCountLabel: (count: number) => string;
  requiredRolePrefix: string;
  newEvent: string;
  createEvent: string;
  editEvent: string;
  closeEditor: string;
  closeEditorAriaLabel: string;
  titleField: string;
  startField: string;
  endField: string;
  resourceField: string;
  resourceSearchPlaceholder: string;
  resourceSearchAriaLabel: string;
  noMatchingResources: string;
  statusField: string;
  notesField: string;
  noStatus: string;
  deleteAction: string;
  copyAction: string;
  pasteAction: string;
  duplicateAction: string;
  createEventHereAction: string;
  assignOpenEventAction: string;
  editEventAction: string;
  confirmEventAction: string;
  markPlannedAction: string;
  reassignResourceAction: string;
  lockAction: string;
  unlockAction: string;
  zoomInAction: string;
  zoomOutAction: string;
  emptyClipboard: string;
  bulkStatusAction: string;
  cancelAction: string;
  saveAction: string;
  lockedEditorMessage: string;
  titleRequiredMessage: string;
  dateTimeRequiredMessage: string;
  endAfterStartMessage: string;
  closed: string;
  outsideWorkingHours: string;
  closedDay: string;
  statusPrefix: string;
  typePrefix: string;
  categoryPrefix: string;
  conflict: string;
  locked: string;
  remoteLoading: string;
  remoteRefreshing: string;
  remoteSaving: string;
  remoteEmpty: string;
  remoteError: string;
  remoteRetry: string;
  statusLabel: typeof toDisplayLabel;
  typeLabel: typeof toDisplayLabel;
  categoryLabel: typeof toDisplayLabel;
};

---

resolveEventSchedulerSavedViewConfig

export function resolveEventSchedulerSavedViewConfig(config: EventSchedulerConfig): EventSchedulerConfig;

---

applyEventSchedulerFilters

export function applyEventSchedulerFilters(options: {
  readonly config: EventSchedulerResolvedConfig;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly assignments: readonly EventSchedulerAssignmentEntity[];
  readonly conflicts: readonly EventSchedulerConflict[];
}): EventSchedulerFilterResult;

---

EventSchedulerFilterResult

interface EventSchedulerFilterResult {
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly summary: EventSchedulerFilterSummary
}

---

createEventSchedulerConflicts

export function createEventSchedulerConflicts(input: EventSchedulerConflictEngineInput): EventSchedulerConflictEngineResult;

---

hasBlockingConflictsForEvent

export function hasBlockingConflictsForEvent(
  conflicts: readonly EventSchedulerConflict[],
  eventId: EventSchedulerEntityId,
): boolean;

---

EventSchedulerConflictEngineInput

interface EventSchedulerConflictEngineInput {
  readonly config: EventSchedulerResolvedConfig;
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly assignments: readonly EventSchedulerAssignmentEntity[];
  readonly availability: readonly EventSchedulerNormalizedAvailability[];
  readonly segments: readonly EventSchedulerEventSegment[]
}

---

EventSchedulerConflictEngineResult

interface EventSchedulerConflictEngineResult {
  readonly conflicts: readonly EventSchedulerConflict[];
  readonly conflictsBySegmentId: ReadonlyMap<string, readonly EventSchedulerConflict[]>
}

---

normalizeCoverageRequirements

export function normalizeCoverageRequirements(
  requirements: readonly EventSchedulerCoverageRequirementEntity[],
  resources: readonly EventSchedulerResourceEntity[],
): readonly EventSchedulerCoverageRequirementEntity[];

---

createEventSchedulerCoverageResults

export function createEventSchedulerCoverageResults(input: EventSchedulerCoverageInput): readonly EventSchedulerCoverageResult[];

---

summarizeCoverageResults

export function summarizeCoverageResults(results: readonly EventSchedulerCoverageResult[]): EventSchedulerCoverageSummary;

---

getTimelineCoverageState

export function getTimelineCoverageState(
  column: EventSchedulerTimelineColumn,
  row: EventSchedulerGridRow,
  projection: EventSchedulerProjection,
): EventSchedulerTimelineCoverageState | null;

---

formatCoverageSummary

export function formatCoverageSummary(summary: EventSchedulerCoverageSummary): string;

---

EventSchedulerCoverageInput

interface EventSchedulerCoverageInput {
  readonly config: EventSchedulerResolvedConfig;
  readonly requirements: readonly EventSchedulerCoverageRequirementEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly segments: readonly EventSchedulerEventSegment[]
}

---

EventSchedulerTimelineCoverageState

interface EventSchedulerTimelineCoverageState {
  readonly status: EventSchedulerCoverageStatus;
  readonly results: readonly EventSchedulerCoverageResult[];
  readonly required: number;
  readonly assigned: number;
  readonly missing: number;
  readonly surplus: number;
  readonly label: string
}

---

createEventSchedulerUtilizationResults

export function createEventSchedulerUtilizationResults(input: EventSchedulerUtilizationInput): readonly EventSchedulerUtilizationResult[];

---

summarizeUtilizationResults

export function summarizeUtilizationResults(results: readonly EventSchedulerUtilizationResult[]): EventSchedulerUtilizationSummary;

---

formatUtilizationResult

export function formatUtilizationResult(result: EventSchedulerUtilizationResult): string;

---

formatUtilizationSummary

export function formatUtilizationSummary(summary: EventSchedulerUtilizationSummary): string;

---

EventSchedulerUtilizationInput

interface EventSchedulerUtilizationInput {
  readonly config: EventSchedulerResolvedConfig;
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly segments: readonly EventSchedulerEventSegment[]
}

---

createRemoteState

export function createRemoteState(patch: Partial<EventSchedulerRemoteState> = {}): EventSchedulerRemoteState;

---

EventSchedulerRemoteDataSnapshot

interface EventSchedulerRemoteDataSnapshot {
  readonly events: readonly EventSchedulerEventEntity[];
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly assignments: readonly EventSchedulerAssignmentEntity[];
  readonly availability: readonly EventSchedulerAvailabilityEntity[];
  readonly coverageRequirements: readonly EventSchedulerCoverageRequirementEntity[]
}

---

EventSchedulerRemoteLoadContext

interface EventSchedulerRemoteLoadContext {
  readonly config: EventSchedulerConfig;
  readonly snapshot: EventSchedulerRemoteDataSnapshot;
  readonly visibleResourceIds?: readonly EventSchedulerEntityId[]
}

---

EventSchedulerRemoteMutationContext (Extended from index.ts)

interface EventSchedulerRemoteMutationContext {
  readonly action: EventSchedulerMutationAction;
  readonly eventId: EventSchedulerEntityId | null;
  readonly event: EventSchedulerEventEntity | null;
  readonly previousEvent?: EventSchedulerEventEntity;
  readonly previousEvents: readonly EventSchedulerEventEntity[];
  readonly events: readonly EventSchedulerEventEntity[];
  readonly changes?: EventSchedulerEventEditChanges;
  readonly conflicts?: EventSchedulerRemoteMutationRequest['conflicts']
}

---

EventSchedulerRemoteControllerCallbacks

interface EventSchedulerRemoteControllerCallbacks {
  readonly applyData: (data: Partial<EventSchedulerRemoteDataSnapshot>) => void;
  readonly stateChanged?: (detail: EventSchedulerRemoteStateChangeDetail) => void;
  readonly loadStarted?: (detail: EventSchedulerRemoteLoadDetail) => void;
  readonly loadSucceeded?: (detail: EventSchedulerRemoteLoadDetail) => void;
  readonly loadFailed?: (detail: EventSchedulerRemoteLoadDetail) => void;
  readonly mutationChanged?: (detail: EventSchedulerRemoteMutationDetail) => void
}

---

EventSchedulerRemoteController

class EventSchedulerRemoteController {
  getState(): EventSchedulerRemoteState;

  isEnabled(config: EventSchedulerConfig | null | undefined): boolean;

  updateConfig(config: EventSchedulerConfig | null | undefined): void;

  async loadVisibleRange(context: EventSchedulerRemoteLoadContext, options: { readonly force?: boolean } = {}): Promise<void>;

  async loadMoreResources(context: EventSchedulerRemoteLoadContext): Promise<void>;

  commitMutation(context: EventSchedulerRemoteMutationContext): void;

  resetRangeCache(): void;

  destroy(): void;
}

---

assertCanCreateEvent

Throws when an event creation is not allowed by scheduler access rules.

Example:

assertCanCreateEvent({ config, resources }, { event: draft, action: 'create' });

export function assertCanCreateEvent(
  context: EventSchedulerPermissionDataContext,
  options: EventSchedulerCreatePermissionOptions,
): void;

---

canCreateEvent

Checks whether an event creation is allowed without throwing.

export function canCreateEvent(
  context: EventSchedulerPermissionDataContext,
  options: EventSchedulerCreatePermissionOptions,
): EventSchedulerPermissionCheckResult;

---

assertCanMutateEvent

Throws when a mutation is not allowed by scheduler access rules.

export function assertCanMutateEvent(
  context: EventSchedulerPermissionDataContext,
  options: EventSchedulerMutationPermissionOptions,
): void;

---

canMutateEvent

Checks whether move, resize, edit, delete, bulk, or recurrence mutation is allowed.

export function canMutateEvent(
  context: EventSchedulerPermissionDataContext,
  options: EventSchedulerMutationPermissionOptions,
): EventSchedulerPermissionCheckResult;

---

isEventReadonly

Returns true when an existing event should be presented as read-only in UI.

export function isEventReadonly(
  context: EventSchedulerPermissionDataContext,
  event: EventSchedulerEventEntity,
): boolean;

---

isResourceLocked

Returns true when a resource cannot accept create/drop/reassign actions.

export function isResourceLocked(resource: EventSchedulerResourceEntity): boolean;

---

EventSchedulerPermissionDataContext

interface EventSchedulerPermissionDataContext {
  readonly config: EventSchedulerConfig;
  readonly resources: readonly EventSchedulerResourceEntity[]
}

---

EventSchedulerPermissionCheckResult

Result returned by scheduler permission checks.

interface EventSchedulerPermissionCheckResult {
  readonly allowed: boolean;
  readonly message?: string
}

---

EventSchedulerCreatePermissionOptions

Inputs for evaluating create permissions from slots, drafts, templates, or paste.

interface EventSchedulerCreatePermissionOptions {
  readonly event?: EventSchedulerEventEntity;
  readonly range?: EventSchedulerCreateRangeContext;
  readonly action?: EventSchedulerCreatePermissionContext['action'];
  readonly resourceId?: EventSchedulerEntityId;
  readonly startDateTime?: string;
  readonly endDateTime?: string
}

---

EventSchedulerMutationPermissionOptions

Inputs for evaluating event mutation permissions.

interface EventSchedulerMutationPermissionOptions {
  readonly event: EventSchedulerEventEntity;
  readonly action: EventSchedulerMutationAction;
  readonly nextEvent?: EventSchedulerEventEntity;
  readonly changes?: Partial<EventSchedulerEventEntity>;
  readonly targetResourceId?: EventSchedulerEntityId
}

---

exportEventSchedulerEvents

export function exportEventSchedulerEvents(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions = {},
): EventSchedulerExportResult;

---

exportEventSchedulerResourceWorkload

export function exportEventSchedulerResourceWorkload(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions = {},
): EventSchedulerExportResult;

---

exportEventSchedulerConflicts

export function exportEventSchedulerConflicts(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions = {},
): EventSchedulerExportResult;

---

exportEventSchedulerCoverage

export function exportEventSchedulerCoverage(
  projection: EventSchedulerProjection,
  options: EventSchedulerCoverageExportOptions = {},
): EventSchedulerExportResult;

---

exportEventSchedulerVisibleSchedule

export function exportEventSchedulerVisibleSchedule(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions = {},
): EventSchedulerExportResult;

---

createEventSchedulerPrintView

export function createEventSchedulerPrintView(
  projection: EventSchedulerProjection,
  options: EventSchedulerPrintOptions = {},
): EventSchedulerPrintResult;

---

EventSchedulerExportFormat

export type EventSchedulerExportFormat = 'csv' | 'json';

---

EventSchedulerExportScope

export type EventSchedulerExportScope =
  | 'events'
  | 'resource-workload'
  | 'conflicts'
  | 'coverage'
  | 'visible-schedule';

---

EventSchedulerReportValue

export type EventSchedulerReportValue = string | number | boolean | null;

---

EventSchedulerReportRow

export type EventSchedulerReportRow = Record<string, EventSchedulerReportValue>;

---

EventSchedulerExportOptions

Options shared by scheduler CSV/JSON export helpers.

Example:

const report = plugin.exportEvents({ format: 'csv' });
download(report.content, report.fileName, report.mimeType);

interface EventSchedulerExportOptions {
  readonly format?: EventSchedulerExportFormat;
  readonly includeHeaders?: boolean;
  readonly delimiter?: string;
  readonly lineBreak?: string;
  readonly fileName?: string
}

---

EventSchedulerCoverageExportOptions (Extended from index.ts)

Options for coverage reporting.

gapsOnly defaults to true because the public coverage export is intended to share planning gaps first. Set it to false for a full requirement report.

interface EventSchedulerCoverageExportOptions {
  readonly gapsOnly?: boolean
}

---

EventSchedulerExportResult

Result returned by scheduler export helpers.

interface EventSchedulerExportResult {
  readonly scope: EventSchedulerExportScope;
  readonly format: EventSchedulerExportFormat;
  readonly fileName: string;
  readonly mimeType: string;
  readonly rows: readonly Row[];
  readonly content: string
}

---

EventSchedulerPrintOptions

Options for creating a print-friendly scheduler document.

Example:

const print = plugin.createPrintView({ title: 'Security Scheduler JavaScript Calendar' });
printWindow.document.write(print.html);
printWindow.print();

interface EventSchedulerPrintOptions {
  readonly title?: string;
  readonly includeEvents?: boolean;
  readonly includeWorkload?: boolean;
  readonly includeConflicts?: boolean;
  readonly includeCoverage?: boolean;
  readonly generatedAt?: string
}

---

EventSchedulerPrintResult

HTML document and source rows for a first-version print/share view.

interface EventSchedulerPrintResult {
  readonly title: string;
  readonly generatedAt: string;
  readonly html: string;
  readonly events: readonly EventSchedulerReportRow[];
  readonly workload: readonly EventSchedulerReportRow[];
  readonly conflicts: readonly EventSchedulerReportRow[];
  readonly coverage: readonly EventSchedulerReportRow[]
}

---

getEventSchedulerZoomLevels

Returns the slot granularities that can represent the complete visible range. A custom active slot size remains part of the sequence when it is valid.

export function getEventSchedulerZoomLevels(
  context: EventSchedulerZoomContext,
): readonly number[];

---

getNextEventSchedulerZoomLevel

Returns the next finer/coarser slot size, or null at the zoom boundary.

export function getNextEventSchedulerZoomLevel(
  context: EventSchedulerZoomContext,
  direction: EventSchedulerZoomDirection,
): number | null;

---

resolveEventSchedulerZoomCoordinate

Maps a timeline scroll coordinate to the same visible day/time after zoom.

export function resolveEventSchedulerZoomCoordinate(
  previous: EventSchedulerProjection,
  next: EventSchedulerProjection,
  coordinate: number,
): number;

---

DEFAULT_EVENT_SCHEDULER_ZOOM_LEVELS

Built-in Scheduler slot granularities ordered from finest to coarsest.

DEFAULT_EVENT_SCHEDULER_ZOOM_LEVELS: readonly [15, 30, 60, 120, 240, 480, 720, 1440];

---

EventSchedulerZoomDirection

export type EventSchedulerZoomDirection = 'in' | 'out';

---

EventSchedulerZoomContext

interface EventSchedulerZoomContext {
  readonly slotMinutes: number;
  readonly timeRange: EventSchedulerTimeRange;
  readonly enabled?: boolean;
  readonly levels?: readonly number[]
}

---

availabilityRangeOverlapsSlot

export function availabilityRangeOverlapsSlot(
  availability: EventSchedulerNormalizedAvailability,
  slotStart: number,
  slotEnd: number,
): boolean;

---

availabilityOverlapsDate

export function availabilityOverlapsDate(
  availability: EventSchedulerNormalizedAvailability,
  date: string,
): boolean;

---

availabilityAppliesToResource

export function availabilityAppliesToResource(
  availability: EventSchedulerNormalizedAvailability,
  resourceId: EventSchedulerGridRow['resourceId'] | EventSchedulerEntityId | undefined,
): boolean;

---

getTimelineAvailabilityState

export function getTimelineAvailabilityState(
  column: EventSchedulerTimelineColumn,
  row: EventSchedulerGridRow,
  projection: EventSchedulerProjection,
): EventSchedulerAvailabilitySlotState | null;

---

getConfiguredAvailabilitySlotState

export function getConfiguredAvailabilitySlotState(
  projection: EventSchedulerProjection,
  date: string,
  dayIndex: number,
  slotIndex: number,
  startMinutes: number,
  endMinutes: number,
  resourceId?: EventSchedulerEntityId,
): EventSchedulerAvailabilitySlotState | null;

---

getNonWorkingTimeSlotState

export function getNonWorkingTimeSlotState(
  projection: EventSchedulerProjection,
  date: string,
  startMinutes: number,
  endMinutes: number,
  options: { readonly includeClosedDays?: boolean; readonly resourceId?: EventSchedulerEntityId } = {},
): EventSchedulerAvailabilitySlotState | null;

---

isCurrentTimelineDay

export function isCurrentTimelineDay(
  column: EventSchedulerTimelineColumn,
  projection: EventSchedulerProjection,
): boolean;

---

EventSchedulerAvailabilitySlotKind

export type EventSchedulerAvailabilitySlotKind = EventSchedulerAvailabilityKind | 'closed';

---

EventSchedulerAvailabilitySlotState

interface EventSchedulerAvailabilitySlotState {
  readonly available: boolean;
  readonly kind: EventSchedulerAvailabilitySlotKind;
  readonly id?: EventSchedulerEntityId;
  readonly title?: string;
  readonly reason?: string;
  readonly className?: string
}

---

getCalendarSlotState

export function getCalendarSlotState(
  context: EventSchedulerCalendarResolveContext,
  date: string,
  startMinutes: number,
  endMinutes: number,
  resourceId?: EventSchedulerEntityId,
  options: { readonly includeClosedDays?: boolean } = {},
): EventSchedulerCalendarSlotState | null;

---

isCalendarDateSchedulable

export function isCalendarDateSchedulable(
  context: EventSchedulerCalendarResolveContext,
  date: string,
  resourceId?: EventSchedulerEntityId,
): boolean | null;

---

isCalendarRangeWorking

export function isCalendarRangeWorking(
  context: EventSchedulerCalendarResolveContext,
  date: string,
  startMinutes: number,
  endMinutes: number,
  resourceId?: EventSchedulerEntityId,
): boolean | null;

---

resolveCalendar

export function resolveCalendar(
  context: EventSchedulerCalendarResolveContext,
  resourceId?: EventSchedulerEntityId,
): EventSchedulerResolvedCalendarEntity | null;

---

EventSchedulerCalendarResolveContext

interface EventSchedulerCalendarResolveContext {
  readonly config: Pick<EventSchedulerResolvedConfig, 'calendars' | 'labels'>;
  readonly resources: readonly EventSchedulerResourceEntity[]
}

---

EventSchedulerCalendarSlotState

interface EventSchedulerCalendarSlotState {
  readonly available: boolean;
  readonly kind: 'closed';
  readonly title?: string;
  readonly reason?: string;
  readonly className?: string;
  readonly calendarId?: EventSchedulerEntityId
}

---

EventSchedulerClipboardController

Owns Scheduler clipboard state and browser/adapter integration.

Mutation and selection remain in the plugin; this class only translates selected events to/from the stable Scheduler clipboard payload.

class EventSchedulerClipboardController {
  copy(
    events: readonly EventSchedulerEventEntity[],
    config: EventSchedulerConfig | null,
  ): EventSchedulerClipboardPayload | null;

  read(config: EventSchedulerConfig | null): EventSchedulerClipboardPayload | null;

  hasPayload(config: EventSchedulerConfig | null): boolean;
}

---

mergeSchedulerElementProps

export function mergeSchedulerElementProps(
  builtIn: EventSchedulerElementProps,
  custom: EventSchedulerElementProps | null | undefined,
): EventSchedulerElementProps;

---

renderCustomSection

export function renderCustomSection(
  h: EventSchedulerTemplateH,
  result: EventSchedulerTemplateResult,
  wrapperClass?: string,
): EventSchedulerTemplateResult;

---

mergeClassValues

export function mergeClassValues(...values: readonly unknown[]): string;

---

MIN_EVENT_SCHEDULER_SLOT_MINUTES

MIN_EVENT_SCHEDULER_SLOT_MINUTES: 15;

---

isEventSchedulerHistoryConfig

export function isEventSchedulerHistoryConfig(history: HistoryConfig | undefined): boolean;

---

resolveEventSchedulerHistoryConfig

export function resolveEventSchedulerHistoryConfig(
  history: HistoryConfig | undefined,
): HistoryConfig;

---

eventSchedulerSnapshotsEqual

export function eventSchedulerSnapshotsEqual(
  previousEvents: readonly EventSchedulerEventEntity[],
  nextEvents: readonly EventSchedulerEventEntity[],
): boolean;

---

EVENT_SCHEDULER_HISTORY_RECORD_EVENT

EVENT_SCHEDULER_HISTORY_RECORD_EVENT: string;

---

EventSchedulerHistoryTool

Bridges scheduler-owned event snapshots into the shared Pro HistoryPlugin.

class EventSchedulerHistoryTool {
  emitSnapshot(
    previousEvents: readonly EventSchedulerEventEntity[],
    nextEvents: readonly EventSchedulerEventEntity[],
  ): boolean;

  replaySnapshot(detail: EventManagerEvent): boolean;
}

---

EventSchedulerRemoteHistoryQueue

Releases remote mutation results in initiation order while requests remain concurrent.

class EventSchedulerRemoteHistoryQueue {
  handle(detail: EventSchedulerRemoteMutationDetail): EventSchedulerRemoteMutationDetail[];

  handleOutcome(
    detail: EventSchedulerRemoteMutationDetail,
    currentEvents?: readonly EventSchedulerEventEntity[],
    options: { readonly rollbackRejected?: boolean } = {},
  ): {
    readonly committed: EventSchedulerRemoteMutationDetail[];
    readonly events?: EventSchedulerEventEntity[];
  };

  clear(): void;
}

---

normalizeKeyboardShortcuts

export function normalizeKeyboardShortcuts(
  value: EventSchedulerConfig['keyboardShortcuts'],
): EventSchedulerResolvedConfig['keyboardShortcuts'];

---

normalizeKeyboardShortcutMap

export function normalizeKeyboardShortcutMap(
  shortcuts: Partial<Record<string, string | readonly string[] | false>> = {},
): EventSchedulerResolvedConfig['keyboardShortcuts']['shortcuts'];

---

DEFAULT_KEYBOARD_SHORTCUTS

DEFAULT_KEYBOARD_SHORTCUTS: {
  escape: string[];
  help: string[];
  today: string[];
  search: string[];
  previous: string[];
  next: string[];
  cyclePrevious: string[];
  cycleNext: string[];
  open: string[];
  create: string[];
  edit: string[];
  lock: string[];
  delete: string[];
  copy: string[];
  paste: string[];
  duplicate: string[];
  viewWeek: string[];
};

---

installEventSchedulerDependencies

Installs shared Pro services required by Event Scheduler.

Most dependencies are general grid services and follow the existing auto-install lifetime. Row z-indexing changes ordinary row rendering, so an instance created specifically for Scheduler is tracked and removed with it.

export function installEventSchedulerDependencies(
  grid: HTMLRevoGridElement,
  providers: PluginProviders,
): EventSchedulerInstalledDependencies;

---

EventSchedulerInstalledDependencies

interface EventSchedulerInstalledDependencies {
  /** Activates helper plugins whose effects are Scheduler-specific. */
    activate(): void;
  /** Removes Scheduler-owned helpers while preserving host-owned instances. */
    deactivate(): void;
  /** Removes only helper plugins owned exclusively by this Scheduler instance. */
    destroy(): void
}

---

normalizeResources

export function normalizeResources(
  resources: readonly EventSchedulerResourceEntity[],
  config: EventSchedulerConfig,
): readonly EventSchedulerResourceEntity[];

---

resolveTimelineResources

export function resolveTimelineResources(
  resources: readonly EventSchedulerResourceEntity[],
  events: readonly EventSchedulerEventEntity[],
  assignmentsByEvent: ReadonlyMap<string, readonly EventSchedulerAssignmentEntity[]>,
  config: EventSchedulerResolvedConfig,
  unassignedSummary: EventSchedulerUnassignedSummary,
): readonly EventSchedulerResourceEntity[];

---

normalizeEvents

export function normalizeEvents(
  events: readonly EventSchedulerEventEntity[],
  resources: readonly EventSchedulerResourceEntity[],
  assignmentsByEvent: ReadonlyMap<string, readonly EventSchedulerAssignmentEntity[]>,
): readonly EventSchedulerEventEntity[];

---

getEventTitle

export function getEventTitle(event: EventSchedulerEventEntity, fallback?: string): string;

---

normalizeAssignments

export function normalizeAssignments(
  assignments: readonly EventSchedulerAssignmentEntity[],
  events: readonly EventSchedulerEventEntity[],
  resources: readonly EventSchedulerResourceEntity[],
): readonly EventSchedulerAssignmentEntity[];

---

normalizeAvailability

export function normalizeAvailability(
  availability: readonly EventSchedulerAvailabilityEntity[],
  resources: readonly EventSchedulerResourceEntity[],
): readonly EventSchedulerNormalizedAvailability[];

---

groupAssignmentsByEvent

export function groupAssignmentsByEvent(
  assignments: readonly EventSchedulerAssignmentEntity[],
): ReadonlyMap<string, readonly EventSchedulerAssignmentEntity[]>;

---

getEventResourceIds

export function getEventResourceIds(
  event: EventSchedulerEventEntity,
  assignmentsByEvent: ReadonlyMap<string, readonly EventSchedulerAssignmentEntity[]>,
): readonly EventSchedulerEntityId[];

---

createUnassignedSummary

export function createUnassignedSummary(
  config: EventSchedulerResolvedConfig,
  events: readonly EventSchedulerEventEntity[],
  assignmentsByEvent: ReadonlyMap<string, readonly EventSchedulerAssignmentEntity[]>,
): EventSchedulerUnassignedSummary;

---

createEventSegments

export function createEventSegments(
  config: EventSchedulerResolvedConfig,
  days: readonly EventSchedulerDay[],
  slots: readonly EventSchedulerTimeSlot[],
  events: readonly EventSchedulerEventEntity[],
  resources: readonly EventSchedulerResourceEntity[],
  assignments: readonly EventSchedulerAssignmentEntity[],
): readonly EventSchedulerEventSegment[];

---

isUnassignedResource

export function isUnassignedResource(resource: EventSchedulerResourceEntity): boolean;

---

assignLanes

export function assignLanes(
  segments: readonly EventSchedulerEventSegment[],
  conflictResult: EventSchedulerConflictEngineResult,
  config: EventSchedulerResolvedConfig,
): readonly EventSchedulerEventSegment[];

---

createResourceRows

export function createResourceRows(
  config: EventSchedulerResolvedConfig,
  resources: readonly EventSchedulerResourceEntity[],
  segments: readonly EventSchedulerEventSegment[],
  coverageResults: readonly EventSchedulerCoverageResult[],
  utilizationResults: readonly EventSchedulerUtilizationResult[],
  unassignedSummary: EventSchedulerUnassignedSummary,
): readonly EventSchedulerGridRow[];

---

createTimeRows

export function createTimeRows(
  config: EventSchedulerResolvedConfig,
  days: readonly EventSchedulerDay[],
  slots: readonly EventSchedulerTimeSlot[],
): readonly EventSchedulerGridRow[];

---

createWeekDays

export function createWeekDays(
  config: EventSchedulerResolvedConfig,
  events: readonly EventSchedulerEventEntity[] = [],
  availability: readonly EventSchedulerNormalizedAvailability[] = [],
): readonly EventSchedulerDay[];

---

createTimeSlots

export function createTimeSlots(config: EventSchedulerResolvedConfig): readonly EventSchedulerTimeSlot[];

---

createWeekColumns

export function createWeekColumns(config: EventSchedulerResolvedConfig, days: readonly EventSchedulerDay[]): ColumnData;

---

createTimelineColumns

export function createTimelineColumns(
  config: EventSchedulerResolvedConfig,
  days: readonly EventSchedulerDay[],
  slots: readonly EventSchedulerTimeSlot[],
): ColumnData;

---

isEmptyId

export function isEmptyId(id: EventSchedulerEntityId | null | undefined): boolean;

---

uniqueIds

export function uniqueIds(ids: readonly EventSchedulerEntityId[]): readonly EventSchedulerEntityId[];

---

matchesStringFilter

export function matchesStringFilter(
  value: string | readonly string[] | undefined,
  filter: string | readonly string[] | undefined,
): boolean;

---

getPathValue

export function getPathValue(source: unknown, path: string): unknown;

---

createResourceTree

export function createResourceTree(
  resources: readonly EventSchedulerResourceEntity[],
  parentIdField: keyof EventSchedulerResourceEntity | string | undefined,
): readonly EventSchedulerResourceTreeNode[];

---

flattenResourceTree

export function flattenResourceTree(
  node: EventSchedulerResourceTreeNode,
): readonly EventSchedulerResourceEntity[];

---

EventSchedulerResourceTreeNode

interface EventSchedulerResourceTreeNode {
  readonly resource: EventSchedulerResourceEntity;
  readonly children: EventSchedulerResourceTreeNode[]
}

---

EventSchedulerCellTemplateH

export type EventSchedulerCellTemplateH = Parameters<NonNullable<ColumnType<DataType>['cellTemplate']>>[0];

---

EventSchedulerEventBarActions

interface EventSchedulerEventBarActions {
  readonly isEventSelected: (eventId: EventSchedulerEventSegment['eventId']) => boolean;
  readonly onEventPointerDown: (
      event: PointerEvent,
      segment: EventSchedulerEventSegment,
      action: 'move' | 'resize-start' | 'resize-end',
    ) => void;
  readonly onEventClick: (
      event: MouseEvent,
      segment: EventSchedulerEventSegment,
    ) => void;
  readonly onEventDoubleClick: (
      event: MouseEvent,
      segment: EventSchedulerEventSegment,
    ) => void
}

---

EventSchedulerColumnTypeOptions

interface EventSchedulerColumnTypeOptions {
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly onResourceGroupToggle: (groupId: string) => void;
  readonly onSlotPointerDown: (
      event: PointerEvent,
      row: EventSchedulerGridRow,
      column: EventSchedulerDayColumn | EventSchedulerTimelineColumn,
      slotSegments: readonly EventSchedulerEventSegment[],
    ) => void
}

---

createEventSchedulerColumnTypes

export function createEventSchedulerColumnTypes(options: EventSchedulerColumnTypeOptions): Record<string, ColumnType<DataType>>;

---

createEventSchedulerTimeRowHeader

export function createEventSchedulerTimeRowHeader(projection: EventSchedulerProjection): RowHeaders;

---

createEventSchedulerTimeCellProperties

export function createEventSchedulerTimeCellProperties(
  row: EventSchedulerGridRow,
  projection: EventSchedulerProjection | null | undefined,
): ReturnType<NonNullable<ColumnType<DataType>['cellProperties']>>;

---

createEventSchedulerTimeCellTemplate

export function createEventSchedulerTimeCellTemplate(
  h: Parameters<NonNullable<ColumnType<DataType>['cellTemplate']>>[0],
  row: EventSchedulerGridRow,
  projection: EventSchedulerProjection | null | undefined,
);

---

createTimeCellContext

export function createTimeCellContext(
  row: EventSchedulerGridRow,
  view: EventSchedulerTimeCellContext['view'],
): EventSchedulerTimeCellContext;

---

flattenSchedulerColumns

export function flattenSchedulerColumns(columns: ColumnData): readonly ColumnRegular[];

---

isSchedulerColumnGrouping

export function isSchedulerColumnGrouping(column: ColumnGrouping | ColumnRegular): column is ColumnGrouping;

---

EventSchedulerContextMenuControllerOptions

interface EventSchedulerContextMenuControllerOptions {
  readonly grid: HTMLRevoGridElement;
  readonly domLayer: EventSchedulerDomLayer;
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly getContextMenuConfig: () => EventSchedulerContextMenuConfig;
  readonly getResourceIdFromSlot: (resourceId: string | number | undefined) => EventSchedulerEntityId | undefined;
  readonly hasClipboardPayload: () => boolean;
  readonly openEventEditor: (segment: EventSchedulerEventSegment) => void;
  readonly copyEvent: (segment: EventSchedulerEventSegment) => void;
  readonly duplicateEvent: (segment: EventSchedulerEventSegment) => void;
  readonly toggleLock: (segment: EventSchedulerEventSegment) => void;
  readonly toggleConfirmation: (segment: EventSchedulerEventSegment) => void;
  readonly deleteEvent: (segment: EventSchedulerEventSegment) => void;
  readonly createShift: (slot: EventSchedulerSlotContext, resourceId?: EventSchedulerEntityId) => void;
  readonly paste: (slot: EventSchedulerSlotContext, options: EventSchedulerPasteOptions) => void;
  readonly canZoomIn?: () => boolean;
  readonly canZoomOut?: () => boolean;
  readonly zoomIn?: () => void;
  readonly zoomOut?: () => void;
  readonly onSlotContextMenu: (slot: EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId }, event: MouseEvent | null) => void
}

---

EventSchedulerContextMenuController

class EventSchedulerContextMenuController {
  apply(): void;

  remove(): void;
}

---

createDayCellTemplate

export function createDayCellTemplate(options: EventSchedulerColumnTypeOptions): NonNullable<ColumnType<DataType>['cellTemplate']>;

---

canCreateOverExistingSegments

export function canCreateOverExistingSegments(config: EventSchedulerResolvedConfig): boolean;

---

EventSchedulerSlotPoint

interface EventSchedulerSlotPoint {
  readonly dayIndex: number;
  readonly slotIndex: number;
  readonly resourceId?: string | number;
  readonly axis: 'week' | 'timeline';
  readonly offsetRatio?: number
}

---

EventSchedulerGhostRangeOptions

interface EventSchedulerGhostRangeOptions {
  readonly slotCount: number;
  readonly mode?: 'event' | 'create';
  readonly label?: string | Node;
  readonly labelProps?: EventSchedulerElementProps;
  readonly color?: string;
  readonly conflict?: boolean;
  readonly laneIndex?: number;
  readonly laneCount?: number;
  readonly resourceId?: string | number;
  readonly axis?: 'week' | 'timeline';
  readonly startOffsetRatio?: number;
  readonly endOffsetRatio?: number;
  readonly compactLabel?: {
      readonly durationMinutes: number;
      readonly thresholdMinutes: number;
      readonly startTime: string;
    }
}

---

EventSchedulerRemoteStateViewModel

interface EventSchedulerRemoteStateViewModel {
  readonly loading: boolean;
  readonly refreshing: boolean;
  readonly saving: boolean;
  readonly empty: boolean;
  readonly error?: string;
  readonly loadingLabel: string;
  readonly refreshingLabel: string;
  readonly savingLabel: string;
  readonly emptyLabel: string;
  readonly errorLabel: string;
  readonly template?: EventSchedulerEmptyStateTemplate;
  readonly properties?: (context: EventSchedulerEmptyStateContext) => EventSchedulerElementProps | undefined
}

---

EventSchedulerDomLayer

Contains Scheduler DOM-only responsibilities that cannot live in RevoGrid providers: pointer hit-testing beneath overlays, transient ghost styling, hidden source bars, and the external remote-state host. Callers own semantic state; this layer owns creation and deterministic cleanup of visual artifacts.

class EventSchedulerDomLayer {
  getSlotFromPoint(x: number, y: number): EventSchedulerSlotPoint | null;

  getNearestSlotFromPoint(x: number, y: number): EventSchedulerSlotPoint | null;

  getSlotFromTarget(target: EventTarget | null): EventSchedulerSlotPoint | null;

  isEventTarget(target: EventTarget | null): boolean;

  renderRemoteState(model: EventSchedulerRemoteStateViewModel): void;

  clearRemoteState(): void;

  hideEventSegment(eventId: string | number, resourceId?: string | number): void;

  clearHiddenEventSegments(): void;

  applyGhostRange(dayIndex: number, startSlot: number, endSlot: number, options: EventSchedulerGhostRangeOptions): void;

  clearGhostRange(): void;
}

---

EventSchedulerEditorResourceField

Renders the built-in editor’s bounded multi-resource selector.

Assignment state stays as entity ids; resource indexes and DOM option values are presentation details and never become Scheduler data.

export function EventSchedulerEditorResourceField({
  resources,
  selectedResourceIds,
  disabled,
  labels,
  onChange,
}: EventSchedulerEditorResourceFieldProps);

---

getEditorResourceIds

Resolves the singular/plural event assignment fields to one unique list.

export function getEditorResourceIds(
  event: EventSchedulerEventEntity | null,
): readonly EventSchedulerEntityId[];

---

createEditorResourceChanges

Serializes editor selection using the smallest compatible event shape.

A singular selection continues using resourceId; plural selection uses resourceIds, and an empty selection explicitly clears both legacy fields.

export function createEditorResourceChanges(
  resourceIds: readonly EventSchedulerEntityId[],
): Pick<EventSchedulerEventEditChanges, 'resourceId' | 'resourceIds'>;

---

EventSchedulerEditorResourceFieldProps

interface EventSchedulerEditorResourceFieldProps {
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly selectedResourceIds: readonly EventSchedulerEntityId[];
  readonly disabled: boolean;
  readonly labels: EventSchedulerLabels;
  readonly onChange: (
      resourceIds: readonly EventSchedulerEntityId[],
    ) => void
}

---

renderEventSchedulerEditor

export function renderEventSchedulerEditor(
  host: HTMLElement,
  state: EventSchedulerEditorState,
  callbacks: EventSchedulerEditorCallbacks,
): void;

---

unmountEventSchedulerEditor

export function unmountEventSchedulerEditor(host: HTMLElement): void;

---

EventSchedulerEditorState

interface EventSchedulerEditorState {
  readonly open: boolean;
  readonly mode: EventSchedulerEventEditorMode;
  readonly event: EventSchedulerEventEntity | null;
  readonly resources: readonly EventSchedulerResourceEntity[];
  readonly readonly: boolean;
  readonly validationMessage?: string;
  readonly statusOptions?: readonly (string | EventSchedulerEventEditorStatusOption)[];
  readonly labels: EventSchedulerLabels
}

---

EventSchedulerEditorCallbacks

interface EventSchedulerEditorCallbacks {
  readonly onSubmit: (changes: EventSchedulerEventEditChanges) => void;
  readonly onDelete: () => void;
  readonly onClose: () => void
}

---

EventSchedulerEventBar

interface EventSchedulerEventBar {
  readonly key: string;
  readonly eventId: EventSchedulerEntityId;
  readonly resourceId?: EventSchedulerEntityId;
  readonly segments: readonly EventSchedulerEventSegment[];
  readonly firstSegment: EventSchedulerEventSegment;
  readonly lastSegment: EventSchedulerEventSegment;
  readonly laneIndex: number;
  readonly laneCount: number;
  readonly conflict: boolean;
  readonly conflictSeverity?: EventSchedulerConflictSeverity;
  readonly conflictTypes: readonly EventSchedulerConflictType[];
  readonly conflictIds: readonly string[]
}

---

EventSchedulerBarIndexUpdate

interface EventSchedulerBarIndexUpdate {
  readonly projection: EventSchedulerProjection;
  /** Physical column source owned by RevoGrid's regular-column store. */
    readonly columnSource: readonly ColumnRegular[];
  /** Visible/reordered physical indexes used by RevoGrid dimensions. */
    readonly columnItems: readonly number[]
}

---

EventSchedulerBarIndex

Projection-backed scheduler bar lookup.

RevoGrid dimensions address the visible items order, not the physical column source. Keeping that mapping here gives both renderers one consistent geometry index and makes reorder/trim changes invalidate the lookup.

class EventSchedulerBarIndex {
  update(options: EventSchedulerBarIndexUpdate): void;

  getColumns(): readonly ColumnRegular[];

  getDayBars(columnProp: string): readonly EventSchedulerEventBar[];

  getResourceBars(row: EventSchedulerGridRow): readonly EventSchedulerEventBar[];

  getDayColumnIndex(columnProp: string): number | undefined;

  getTimelineColumnIndex(
    dayIndex: number,
    slotIndex: number,
  ): number | undefined;
}

---

createEventSchedulerBarGeometry

Projects one logical Scheduler bar into its anchor cell or row coordinates.

Horizontal coordinates are adjusted by RevoGrid’s render offset because the row VNode moves with the virtual column pool. Vertical coordinates stay relative to the first slot row, which remains mounted while Y virtualization is disabled for vertical Scheduler views.

export function createEventSchedulerBarGeometry(options: {
  readonly projection: EventSchedulerProjection;
  readonly bar: EventSchedulerEventBar;
  readonly anchorRowIndex: number;
  readonly context: EventSchedulerBarLayoutContext;
}): EventSchedulerBarGeometry | null;

---

intersectsEventSchedulerVisibleColumns

export function intersectsEventSchedulerVisibleColumns(
  geometry: Pick<
    EventSchedulerBarGeometry,
    'logicalColumnStart' | 'logicalColumnEnd'
  >,
  visibleRange: EventSchedulerVisibleColumnRange | null,
): boolean;

---

EventSchedulerBarOrientation

export type EventSchedulerBarOrientation = 'vertical' | 'horizontal';

---

EventSchedulerBarGeometry

interface EventSchedulerBarGeometry {
  readonly orientation: EventSchedulerBarOrientation;
  readonly left: number;
  readonly top: number;
  readonly width: number;
  readonly height: number;
  /** Event-local Y offset where the vertical current-time line crosses the bar. */
    readonly currentTimeLineOffset?: number;
  readonly logicalColumnStart: number;
  readonly logicalColumnEnd: number;
  readonly minimumVisualSize: boolean
}

---

EventSchedulerBarLayoutContext

interface EventSchedulerBarLayoutContext {
  readonly columns: readonly ColumnRegular[];
  readonly columnDimension: DimensionSettingsState;
  readonly rowDimension: DimensionSettingsState;
  readonly columnRenderOffset: number;
  readonly getDayColumnIndex?: (columnProp: string) => number | undefined;
  readonly getTimelineColumnIndex?: (
      dayIndex: number,
      slotIndex: number,
    ) => number | undefined
}

---

EventSchedulerVisibleColumnRange

interface EventSchedulerVisibleColumnRange {
  readonly start: number;
  readonly end: number
}

---

createEventSchedulerBarRenderContexts

Builds the public customization context for one continuous visual bar.

The primary segment is always a real projection segment; aggregate bar boundaries live in start, end, and duration. This prevents impossible hybrid segment ranges for multi-day bars.

export function createEventSchedulerBarRenderContexts(options: {
  readonly bar: EventSchedulerEventBar;
  readonly mode: EventSchedulerEventRenderMode;
  readonly selected: boolean;
}): EventSchedulerBarRenderContexts;

---

EventSchedulerBarRenderContexts

interface EventSchedulerBarRenderContexts {
  readonly context: EventSchedulerRenderContext;
  readonly sectionContext: EventSchedulerEventSectionContext
}

---

renderEventSchedulerBar

Renders one focusable DOM bar for an event assignment.

bar.segments retains day-level projection detail while customization hooks execute once with aggregate start/end fields and a real primary segment.

export function renderEventSchedulerBar(
  h: EventSchedulerTemplateH,
  bar: EventSchedulerEventBar,
  geometry: EventSchedulerBarGeometry,
  projection: EventSchedulerProjection,
  actions: EventSchedulerEventBarActions,
);

---

getWeekEventVisibleHeight

export function getWeekEventVisibleHeight(options: {
  readonly row: EventSchedulerGridRow;
  readonly segment: EventSchedulerEventSegment;
  readonly projection: EventSchedulerProjection | null | undefined;
  readonly carryInBoundary: boolean;
}): number | undefined;

---

getWeekEventVisualLayout

export function getWeekEventVisualLayout(options: {
  readonly row: EventSchedulerGridRow;
  readonly segment: EventSchedulerEventSegment;
  readonly projection: EventSchedulerProjection | null | undefined;
  readonly carryInBoundary: boolean;
}): EventSchedulerWeekEventVisualLayout | undefined;

---

getTimelineEventVisualLayout

export function getTimelineEventVisualLayout(options: {
  readonly segment: EventSchedulerEventSegment;
  readonly projection: EventSchedulerProjection | null | undefined;
}): EventSchedulerTimelineEventVisualLayout | undefined;

---

EventSchedulerWeekEventVisualLayout

interface EventSchedulerWeekEventVisualLayout {
  readonly height: number;
  readonly minimumSize: boolean
}

---

EventSchedulerTimelineEventVisualLayout

interface EventSchedulerTimelineEventVisualLayout {
  readonly firstSegment: boolean;
  readonly lastSegment: boolean;
  readonly end: number;
  readonly width: number;
  readonly minimumSize: boolean
}

---

isCoarseEventSchedulerPointer

export function isCoarseEventSchedulerPointer(event: Pick<PointerEvent, 'pointerType'>): boolean;

---

canStartEventSchedulerSlotPointerAction

export function canStartEventSchedulerSlotPointerAction(event: EventSchedulerPointerStart): boolean;

---

canStartEventSchedulerEventPointerAction

export function canStartEventSchedulerEventPointerAction(
  event: EventSchedulerPointerStart,
  selected: boolean,
  action: EventSchedulerEventPointerAction,
): boolean;

---

bindEventSchedulerPointerControl

export function bindEventSchedulerPointerControl(
  options: EventSchedulerPointerControlOptions,
): EventSchedulerPointerControl | null;

---

EventSchedulerEventPointerAction

export type EventSchedulerEventPointerAction = 'move' | 'resize-start' | 'resize-end';

---

EventSchedulerPointerControlOptions

interface EventSchedulerPointerControlOptions {
  readonly event: PointerEvent;
  readonly onMove: (event: PointerEvent) => void;
  readonly onEnd: (event: PointerEvent) => void;
  readonly onCancel: (event: Event) => void;
  readonly listenerTarget?: EventSchedulerPointerListenerTarget;
  readonly captureTarget?: EventSchedulerPointerCaptureTarget | null
}

---

EventSchedulerPointerControl

interface EventSchedulerPointerControl {
  readonly pointerId: number;
  destroy(): void
}

---

EventSchedulerGridSync

Projects Scheduler rows, columns, and display policy into RevoGrid while preserving the host grid snapshot for deactivation. Vertical views disable Y virtualization because bars are anchored in the first slot row; resource timelines retain the host policy because each bar is owned by its row.

class EventSchedulerGridSync {
  initialize(): void;

  applyProjection(
    projection: EventSchedulerProjection,
    options: { readonly applyColumns?: boolean } = {},
  ): void;

  restore(): void;

  isApplyingSource(): boolean;

  isApplyingColumns(): boolean;

  refreshTimelineViewport(): void;

  captureColumnResize(columns: Record<number, ColumnRegular>): void;

  getResourceColumnSize(): number | undefined;
}

---

EventSchedulerKeyboardControllerOptions

interface EventSchedulerKeyboardControllerOptions {
  readonly document: Document;
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly isEditorOpen: () => boolean;
  readonly closeEditor: () => void;
  readonly stopPointerAction: () => void;
  readonly navigate: (action: 'previous' | 'next' | 'today') => void;
  readonly requestView: (view: EventSchedulerView) => void;
  readonly focusSearch: () => void;
  readonly cycleSelectedEvent: (direction: -1 | 1) => void;
  readonly openSelectedEventEditor: () => void;
  readonly createAtLastSlot: () => void;
  readonly toggleSelectedEventLock: () => void;
  readonly bulkDeleteSelectedEvents: () => void;
  readonly copySelectedEvents: () => void;
  readonly pasteCopiedEvents: () => void;
  readonly duplicateSelectedEvents: () => void;
  readonly getSelectedEventIds: () => readonly EventSchedulerEntityId[];
  readonly hasClipboardPayload: () => boolean
}

---

EventSchedulerKeyboardController

class EventSchedulerKeyboardController {
  destroy(): void;

  handleKeyDown(event: KeyboardEvent): void;

  closeShortcutsPanel(): void;
}

---

EventSchedulerPointerControllerOptions

interface EventSchedulerPointerControllerOptions {
  readonly domLayer: EventSchedulerDomLayer;
  readonly getConfig: () => EventSchedulerConfig | null;
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly getEvents: () => readonly EventSchedulerEventEntity[];
  readonly getResources: () => readonly EventSchedulerResourceEntity[];
  readonly getAssignments: () => readonly EventSchedulerAssignmentEntity[];
  readonly getAvailability: () => readonly EventSchedulerAvailabilityEntity[];
  readonly isCreateAllowed: (context: EventSchedulerSlotContext & { readonly resourceId?: EventSchedulerEntityId }) => boolean;
  readonly isEventSelected: (eventId: EventSchedulerEntityId) => boolean;
  readonly selectEvent: (eventIds: readonly EventSchedulerEntityId[]) => void;
  readonly getResourceIdFromSlot: (resourceId?: string | number) => EventSchedulerEntityId | undefined;
  readonly createRangePreview: (range: EventSchedulerCreateRangeContext) => string | Node | undefined;
  readonly createRangePreviewProperties: (range: EventSchedulerCreateRangeContext) => EventSchedulerElementProps | undefined;
  readonly commitCreateRange: (range: EventSchedulerCreateRangeContext) => void;
  readonly commitMove: (eventId: EventSchedulerEntityId, dateTime: string, resourceId?: EventSchedulerEntityId) => void;
  readonly commitResize: (eventId: EventSchedulerEntityId, edge: EventSchedulerResizeEdge, dateTime: string) => void;
  readonly setInteractionPreview: (preview: EventSchedulerInteractionPreview | null) => void;
  readonly suppressNextSlotClick: () => void
}

---

EventSchedulerInteractionPreview

interface EventSchedulerInteractionPreview {
  readonly action: 'move' | 'resize';
  readonly eventId: EventSchedulerEntityId;
  readonly event: EventSchedulerEventEntity
}

---

EventSchedulerPointerController

Owns the Scheduler pointer state machine from pointer-down through preview and commit. It keeps transient move/resize/create state out of grid data, delegates DOM-only feedback to EventSchedulerDomLayer, and guarantees that stop() releases pointer bindings and clears every interaction artifact.

class EventSchedulerPointerController {
  handleSlotPointerDown(
    event: PointerEvent,
    row: EventSchedulerGridRow,
    column: EventSchedulerDayColumn | EventSchedulerTimelineColumn,
    slotSegments: readonly EventSchedulerEventSegment[],
  ): void;

  handleEventPointerDown(
    event: PointerEvent,
    segment: EventSchedulerEventSegment,
    type: EventSchedulerEventPointerAction,
  ): void;

  stop(): void;
}

---

getVerticalPointerMinuteDelta

export function getVerticalPointerMinuteDelta(options: {
  readonly projection: EventSchedulerProjection;
  readonly slotIndex: number;
  readonly pointerDeltaY: number;
  readonly rowSize: number;
}): number;

---

getPointerMinutes

export function getPointerMinutes(
  projection: EventSchedulerProjection,
  pointerSlot: EventSchedulerSlotPoint,
): number;

---

getTimelinePointerDelta

Keeps compressed rendered-day movement separate from movement within a day. Hidden dates and hours do not occupy pixels on the timeline axis.

export function getTimelinePointerDelta(
  projection: EventSchedulerProjection,
  pointerStartDayIndex: number,
  pointerStartMinutes: number,
  pointerSlot: EventSchedulerSlotPoint,
): EventSchedulerTimelinePointerDelta | null;

---

getEffectivePointerSnapMinutes

export function getEffectivePointerSnapMinutes(
  projection: EventSchedulerProjection,
  slotIndex: number,
): number;

---

clampTimelineStartMinutes

export function clampTimelineStartMinutes(options: {
  readonly projection: EventSchedulerProjection;
  readonly startMinutes: number;
  readonly durationSlots: number;
}): number;

---

getVisibleTimelineDuration

export function getVisibleTimelineDuration(
  projection: EventSchedulerProjection,
): number;

---

EventSchedulerTimelinePointerDelta

interface EventSchedulerTimelinePointerDelta {
  /** Difference between rendered Scheduler days, excluding hidden dates. */
    readonly renderedDayDelta: number;
  /** Pointer movement inside the visible time range of one rendered day. */
    readonly withinDayMinutes: number
}

---

normalizeSchedulerMoveTime

Converts minutes on the compressed Scheduler axis back to a schedulable date. Hidden weekdays, calendar closures, and non-working days are skipped without changing the within-day time.

export function normalizeSchedulerMoveTime(
  projection: EventSchedulerProjection,
  baseDay: Pick<EventSchedulerDay, 'date' | 'dayIndex'>,
  rawStartMinutes: number,
  resourceId?: EventSchedulerEntityId,
): EventSchedulerNormalizedMoveTime | null;

---

EventSchedulerNormalizedMoveTime

interface EventSchedulerNormalizedMoveTime {
  readonly date: string;
  readonly dayIndex: number;
  readonly slotIndex: number;
  readonly startMinutes: number
}

---

resolvePointerMoveTarget

Resolves a drag pointer to an event start without losing the pickup offset.

Timeline days are a compressed axis: hidden dates and hidden hours do not occupy pixels. The rendered-day delta must therefore stay separate from the within-day delta. Inferring a day change from an underflowing minute value makes a same-day clamp wrap to an adjacent date.

export function resolvePointerMoveTarget(options: {
  readonly projection: EventSchedulerProjection;
  readonly segment: EventSchedulerEventSegment;
  readonly pointerSlot: EventSchedulerSlotPoint;
  readonly pointerDeltaY: number;
  readonly rowSize: number;
  readonly durationSlots: number;
  readonly pointerStartDayIndex?: number;
  readonly pointerStartMinutes?: number;
  readonly resourceId?: EventSchedulerEntityId;
}): EventSchedulerPointerMoveTarget | null;

---

EventSchedulerPointerMoveTarget

interface EventSchedulerPointerMoveTarget {
  readonly dayIndex: number;
  readonly date: string;
  readonly startSlot: number;
  readonly endSlot: number;
  readonly startDateTime: string;
  readonly eventStartDateTime: string;
  readonly visible: boolean;
  readonly resourceId?: EventSchedulerEntityId;
  readonly ghostResourceId?: EventSchedulerEntityId
}

---

getSegmentGhostColor

export function getSegmentGhostColor(options: {
  readonly projection: EventSchedulerProjection | null;
  readonly segment: EventSchedulerEventSegment;
  readonly isDragging: boolean;
  readonly isResizing: boolean;
}): string | undefined;

---

createPreviewEventFromRange

export function createPreviewEventFromRange(
  range: EventSchedulerCreateRangeContext,
  config: EventSchedulerConfig | null,
): EventSchedulerEventEntity | null;

---

createPreviewReassignmentPatch

export function createPreviewReassignmentPatch(
  event: EventSchedulerEventEntity,
  nextResourceId: EventSchedulerEntityId | undefined,
): Partial<EventSchedulerEventEntity>;

---

PREVIEW_CREATE_EVENT_ID

PREVIEW_CREATE_EVENT_ID: string;

---

getActiveCreateRange

export function getActiveCreateRange(
  projection: EventSchedulerProjection,
  active: EventSchedulerCreatePointerActionState,
): EventSchedulerCreateRangeContext | null;

---

getSnappedSlotPoint

export function getSnappedSlotPoint(
  projection: EventSchedulerProjection,
  slot: {
    readonly dayIndex: number;
    readonly slotIndex: number;
    readonly offsetRatio?: number;
  },
): EventSchedulerSnappedSlotPoint | null;

---

getSnappedResizeDateTime

export function getSnappedResizeDateTime(
  projection: EventSchedulerProjection,
  slot: {
    readonly dayIndex: number;
    readonly slotIndex: number;
    readonly offsetRatio?: number;
  },
): string | null;

---

clampResizeDateTime

export function clampResizeDateTime(
  projection: EventSchedulerProjection,
  event: EventSchedulerEventEntity,
  edge: EventSchedulerResizeEdge,
  dateTime: string,
  slotIndex: number,
): string;

---

getResizePreviewRange

export function getResizePreviewRange(
  projection: EventSchedulerProjection,
  active: EventSchedulerEventPointerActionState,
  dayIndex: number,
  startDateTime: string,
  endDateTime: string,
): EventSchedulerResizePreviewRange | null;

---

getRangeSlotOffsets

export function getRangeSlotOffsets(
  projection: EventSchedulerProjection,
  range: EventSchedulerCreateRangeContext,
): {
  readonly startOffsetRatio: number;
  readonly endOffsetRatio: number;
};

---

getPointerOffsetRatio

export function getPointerOffsetRatio(
  event: PointerEvent,
  target: EventTarget | null,
  axis: 'week' | 'timeline',
): number;

---

EventSchedulerCreatePointerActionState

interface EventSchedulerCreatePointerActionState {
  readonly type: 'create';
  readonly dayIndex: number;
  readonly currentDayIndex: number;
  readonly axis: 'week' | 'timeline';
  readonly resourceId?: EventSchedulerEntityId;
  readonly anchorSlot: number;
  readonly currentSlot: number;
  readonly anchorMinutes: number;
  readonly currentMinutes: number
}

---

EventSchedulerEventPointerActionState

interface EventSchedulerEventPointerActionState {
  readonly type: 'move' | 'resize-start' | 'resize-end';
  readonly segment: EventSchedulerEventSegment
}

---

EventSchedulerSnappedSlotPoint

interface EventSchedulerSnappedSlotPoint {
  readonly minutes: number;
  readonly startDateTime: string;
  readonly endDateTime: string
}

---

EventSchedulerResizePreviewRange

interface EventSchedulerResizePreviewRange {
  readonly startSlot: number;
  readonly endSlot: number;
  readonly startOffsetRatio: number;
  readonly endOffsetRatio: number
}

---

createResourceCellTemplate

export function createResourceCellTemplate(options: EventSchedulerColumnTypeOptions): NonNullable<ColumnType<DataType>['cellTemplate']>;

---

EventSchedulerRowEventBarRendererOptions

interface EventSchedulerRowEventBarRendererOptions {
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly actions: EventSchedulerEventBarActions
}

---

EventSchedulerRowEventBarRenderer

Appends continuous timeline bars to resource row VNodes.

Row ownership keeps Y virtualization available. Column visibility is tested against logical geometry so a bar remains mounted when its starting slot has left the virtual column pool but another part of the bar is still visible.

class EventSchedulerRowEventBarRenderer {
  apply(detail: BeforeRowRenderEvent<EventSchedulerGridRow>): void;
}

---

createTimelineCellTemplate

export function createTimelineCellTemplate(options: EventSchedulerColumnTypeOptions): NonNullable<ColumnType<DataType>['cellTemplate']>;

---

createTimelineCellTemplateState

export function createTimelineCellTemplateState(options: {
  readonly column: EventSchedulerTimelineColumn;
  readonly row: EventSchedulerGridRow;
  readonly projection: EventSchedulerProjection | null;
  readonly currentTime: EventSchedulerCurrentTimeCellState | null;
}): EventSchedulerTimelineCellTemplateState;

---

getCurrentTimeMarker

export function getCurrentTimeMarker(
  column: EventSchedulerTimelineColumn,
  projection: EventSchedulerProjection,
): EventSchedulerCurrentTimeCellState | null;

---

EventSchedulerCurrentTimeCellState

interface EventSchedulerCurrentTimeCellState {
  readonly left: number;
  readonly label: string;
  readonly dateTime: string
}

---

EventSchedulerTimelineCellTemplateState

interface EventSchedulerTimelineCellTemplateState {
  readonly slotSegments: readonly EventSchedulerEventSegment[];
  readonly props: Record<string, unknown>
}

---

EventSchedulerVerticalEventBarRendererOptions

interface EventSchedulerVerticalEventBarRendererOptions {
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly actions: EventSchedulerEventBarActions
}

---

EventSchedulerVerticalEventBarRenderer

Anchors vertical event bars in the first rendered slot cell of each day. Vertical Scheduler views disable Y virtualization, so this cell remains mounted while each bar spans the required time rows.

class EventSchedulerVerticalEventBarRenderer {
  apply(
    detail: BeforeCellRenderEvent<
      CellTemplateProp<EventSchedulerGridRow, EventSchedulerDayColumn>
    >,
  ): void;
}