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.
     *
     * Use `15` or `30` for detailed shifts and `60` or `1440` for higher-level planning.
     */
    readonly slotMinutes?: number;
  /** Drag, resize, and create snapping interval in minutes.
     *
     * Defaults to `slotMinutes`. Use this when visible slots are coarse but edits
     * should land on finer boundaries.
     *
     * @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;
  /** 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;
  /** 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;
};

---

EVENT_SCHEDULER_DAY_MS

EVENT_SCHEDULER_DAY_MS: number;

---

createDateTime

export function createDateTime(date: string, minutes: number): string;

---

formatTimeOfDay

export function formatTimeOfDay(totalMinutes: number): string;

---

getDurationMinutes

export function getDurationMinutes(event: Pick<EventSchedulerEventEntity, 'startDateTime' | 'endDateTime'>): number;

---

normalizeISODate

export function normalizeISODate(value: string): string;

---

normalizeSchedulerConfig

export function normalizeSchedulerConfig(config: EventSchedulerConfig): EventSchedulerResolvedConfig;

---

parseDateTime

export function parseDateTime(value: string): Date;

---

parseTimeOfDay

export function parseTimeOfDay(value: string, options:;

---

shiftDateTime

export function shiftDateTime(value: string, deltaMinutes: number): string;

---

snapDateTime

export function snapDateTime(value: string, snap: number): string;

---

snapMinutes

export function snapMinutes(minutes: number, snap: number): number;

---

toISODate

export function toISODate(date: Date): string;

---

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:

* ```ts
 * 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.

class EventSchedulerPlugin {
  /** 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: Partial<EventSchedulerEventEntity>): 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 &;

  /** Sets the selected slot from host-provided state. */
  setSelectedSlot(slot: (EventSchedulerSlotContext &;

  /** 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. */
  pasteCopiedEvents(options: EventSchedulerPasteOptions =;

  /** 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 =;

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

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

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

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

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

---

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;
  readonly primaryCalendarId?: CalendarId;
  readonly calendars?: readonly CalendarEntity[];
  readonly resourceCalendarId?: (resource: { readonly id: EventSchedulerEntityId; readonly calendarId?: CalendarId; readonly metadata?: Record<string, unknown> }) => CalendarId | undefined;
  readonly className?: string
}

---

EventSchedulerResolvedWorkingHoursRange

interface EventSchedulerResolvedWorkingHoursRange {
  readonly startMinutes: number;
  readonly endMinutes: number
}

---

EventSchedulerResolvedNonWorkingTimeConfig

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

---

EventSchedulerResolvedCalendarEntity

interface EventSchedulerResolvedCalendarEntity {
  readonly calendar: CalendarEntity;
  readonly workingDays: readonly number[];
  readonly workingHours: readonly EventSchedulerResolvedWorkingHoursRange[];
  readonly holidays: ReadonlySet<string>
}

---

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>
}

---

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 {
  readonly startDateTime?: string;
  readonly resourceId?: EventSchedulerEntityId;
  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;
  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:

* ```ts
 * 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;
  readonly segment: EventSchedulerEventSegment
}

---

EventSchedulerEventRenderMode

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

---

EventSchedulerEventSectionContext (Extended from index.ts)

interface EventSchedulerEventSectionContext {
  readonly mode: EventSchedulerEventRenderMode;
  readonly first: boolean;
  readonly last: boolean;
  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 {
  /** Severity chosen by the conflict engine for this visible event segment. */
    readonly severity: EventSchedulerConflictSeverity;
  /** Conflict rule types attached to this segment, such as `overlap` or `blocked-time`. */
    readonly conflictTypes: readonly EventSchedulerConflictType[];
  /** Stable conflict ids attached to this segment. */
    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:

* ```ts
 * 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 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 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: Partial<EventSchedulerEventEntity>) => 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: Partial<EventSchedulerEventEntity>;
  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:

* ```ts
 * 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';

---

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 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>
}

---

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
}

---

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 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 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'>> & {
      readonly row?: Partial<ContextMenuConfig>;
    };
  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;
  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,
): 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,
): EventSchedulerMutationResult;

---

editEvent

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

export function editEvent(
  context: EventSchedulerMutationContext,
  eventId: EventSchedulerEntityId,
  changes: Partial<EventSchedulerEventEntity>,
): 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:;

---

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']>
}

---

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.

export function pasteCopiedEvents(
  context: EventSchedulerBulkContext,
  payload: EventSchedulerClipboardPayload,
  options: EventSchedulerPasteOptions =;

---

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;
  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;
  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:;

---

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> =;

---

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?: Partial<EventSchedulerEventEntity>;
  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:;

  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:

* ```ts
 * 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 =;

---

exportEventSchedulerResourceWorkload

export function exportEventSchedulerResourceWorkload(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions =;

---

exportEventSchedulerConflicts

export function exportEventSchedulerConflicts(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions =;

---

exportEventSchedulerCoverage

export function exportEventSchedulerCoverage(
  projection: EventSchedulerProjection,
  options: EventSchedulerCoverageExportOptions =;

---

exportEventSchedulerVisibleSchedule

export function exportEventSchedulerVisibleSchedule(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions =;

---

createEventSchedulerPrintView

export function createEventSchedulerPrintView(
  projection: EventSchedulerProjection,
  options: EventSchedulerPrintOptions =;

---

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:

* ```ts
 * 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:

* ```ts
 * const print = plugin.createPrintView({ title: 'Security Team Schedule' });
 * 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[]
}

---

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:;

---

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:;

---

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
}

---

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;

---

formatCompactTimeOfDay

export function formatCompactTimeOfDay(totalMinutes: number): string;

---

addDays

export function addDays(date: string, days: number): string;

---

diffInCalendarDays

export function diffInCalendarDays(startDate: string, endDate: string): number;

---

createDateList

export function createDateList(startDate: string, endDate: string): readonly string[];

---

getDateMinutes

export function getDateMinutes(date: Date): number;

---

getClampedDateTimeDurationMinutes

export function getClampedDateTimeDurationMinutes(startDateTime: string, endDateTime: string): number;

---

rangesOverlap

export function rangesOverlap(start: number, end: number, rangeStart: number, rangeEnd: number): boolean;

---

getDateRangeBounds

export function getDateRangeBounds(range: EventSchedulerDateRange):;

---

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];

---

EventSchedulerColumnTypeOptions

interface EventSchedulerColumnTypeOptions {
  readonly getProjection: () => EventSchedulerProjection | null;
  readonly isEventSelected: (eventId: EventSchedulerEventSegment['eventId']) => boolean;
  readonly onResourceGroupToggle: (groupId: string) => void;
  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;
  readonly onSlotPointerDown: (
      event: PointerEvent,
      row: EventSchedulerGridRow,
      column: EventSchedulerDayColumn | EventSchedulerTimelineColumn,
      slotSegments: readonly EventSchedulerEventSegment[],
    ) => void
}

---

createEventSchedulerColumnTypes

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

---

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 getContextMenuPlugin: () => unknown;
  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 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'
}

---

EventSchedulerGhostRangeOptions

interface EventSchedulerGhostRangeOptions {
  readonly slotCount: number;
  readonly mode?: 'event' | 'create';
  readonly label?: string | Node;
  readonly labelProps?: EventSchedulerElementProps;
  readonly color?: string;
  readonly laneIndex?: number;
  readonly laneCount?: number;
  readonly resourceId?: string | number;
  readonly axis?: 'week' | 'timeline'
}

---

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

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;
}

---

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: Partial<EventSchedulerEventEntity>) => void;
  readonly onDelete: () => void;
  readonly onClose: () => void
}

---

renderWeekEventSegmentSlice

export function renderWeekEventSegmentSlice(
  h: EventSchedulerTemplateH,
  row: EventSchedulerGridRow,
  segment: EventSchedulerEventSegment,
  options: EventSchedulerColumnTypeOptions,
);

---

renderTimelineEventSegmentSlice

export function renderTimelineEventSegmentSlice(
  h: EventSchedulerTemplateH,
  column: EventSchedulerTimelineColumn,
  segment: EventSchedulerEventSegment,
  options: EventSchedulerColumnTypeOptions,
);

---

EventSchedulerGridSync

class EventSchedulerGridSync {
  initialize(): void;

  applyProjection(projection: EventSchedulerProjection): void;

  restore(): void;

  isApplyingSource(): boolean;

  isApplyingColumns(): boolean;
}

---

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 getResources: () => readonly EventSchedulerResourceEntity[];
  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 suppressNextSlotClick: () => void
}

---

EventSchedulerPointerController

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

  handleEventPointerDown(
    event: PointerEvent,
    segment: EventSchedulerEventSegment,
    type: 'move' | 'resize-start' | 'resize-end',
  ): void;

  stop(): void;
}

---

resolvePointerMoveTarget

export function resolvePointerMoveTarget(options:;

---

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
}

---

createResourceCellTemplate

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

---

createTimelineCellTemplate

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

---

createTimelineCellTemplateState

export function createTimelineCellTemplateState(options:;

---

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>
}