# Event Scheduler
URL: https://pro.rv-grid.com/api/event-scheduler/
Source: src/content/docs/api/event-scheduler.md
## Module Extensions

### `EventSchedulerConfig`

```ts
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`)

```ts
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`)

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

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

---

### `normalizeSchedulerConfig`

```ts
export function normalizeSchedulerConfig(config: EventSchedulerConfig): EventSchedulerResolvedConfig;
```

---

### `EventSchedulerPlugin`

Enterprise scheduler plugin for week and resource-timeline planning.

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

**Example:**
```typescript
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.

```ts
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: EventSchedulerEventEditChanges): EventSchedulerEventEntity;

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

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

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

  /** Returns the currently selected slot, when an empty scheduler slot is selected. */
  getSelectedSlot(): (EventSchedulerSlotContext &;

  /** 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`

```ts
EVENT_SCHEDULER_BEFORE_EVENT_CHANGE_EVENT: string;
```

---

### `EVENT_SCHEDULER_BEFORE_EVENT_SELECT_EVENT`

```ts
EVENT_SCHEDULER_BEFORE_EVENT_SELECT_EVENT: string;
```

---

### `EVENT_SCHEDULER_BEFORE_SLOT_SELECT_EVENT`

```ts
EVENT_SCHEDULER_BEFORE_SLOT_SELECT_EVENT: string;
```

---

### `EVENT_SCHEDULER_EVENT_CREATED_EVENT`

```ts
EVENT_SCHEDULER_EVENT_CREATED_EVENT: string;
```

---

### `EVENT_SCHEDULER_EVENT_CHANGED_EVENT`

```ts
EVENT_SCHEDULER_EVENT_CHANGED_EVENT: string;
```

---

### `EVENT_SCHEDULER_EVENT_DELETED_EVENT`

```ts
EVENT_SCHEDULER_EVENT_DELETED_EVENT: string;
```

---

### `EVENT_SCHEDULER_EVENT_SELECTED_EVENT`

```ts
EVENT_SCHEDULER_EVENT_SELECTED_EVENT: string;
```

---

### `EVENT_SCHEDULER_SLOT_CLICK_EVENT`

```ts
EVENT_SCHEDULER_SLOT_CLICK_EVENT: string;
```

---

### `EVENT_SCHEDULER_CONFLICTS_UPDATED_EVENT`

```ts
EVENT_SCHEDULER_CONFLICTS_UPDATED_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_LOAD_START_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_LOAD_START_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_LOAD_SUCCESS_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_LOAD_SUCCESS_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_LOAD_ERROR_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_LOAD_ERROR_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_MUTATION_PENDING_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_MUTATION_PENDING_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_MUTATION_COMMITTED_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_MUTATION_COMMITTED_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_MUTATION_REJECTED_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_MUTATION_REJECTED_EVENT: string;
```

---

### `EVENT_SCHEDULER_REMOTE_STATE_CHANGE_EVENT`

```ts
EVENT_SCHEDULER_REMOTE_STATE_CHANGE_EVENT: string;
```

---

### `EVENT_SCHEDULER_NAVIGATE_REQUEST_EVENT`

```ts
EVENT_SCHEDULER_NAVIGATE_REQUEST_EVENT: string;
```

---

### `EVENT_SCHEDULER_VIEW_REQUEST_EVENT`

```ts
EVENT_SCHEDULER_VIEW_REQUEST_EVENT: string;
```

---

### `EVENT_SCHEDULER_RESOURCE_REASSIGN_REQUEST_EVENT`

```ts
EVENT_SCHEDULER_RESOURCE_REASSIGN_REQUEST_EVENT: string;
```

---

### `EVENT_SCHEDULER_OPEN_SHIFT_ASSIGN_REQUEST_EVENT`

```ts
EVENT_SCHEDULER_OPEN_SHIFT_ASSIGN_REQUEST_EVENT: string;
```

---

### `EVENT_SCHEDULER_SEARCH_FOCUS_REQUEST_EVENT`

```ts
EVENT_SCHEDULER_SEARCH_FOCUS_REQUEST_EVENT: string;
```

---

### `EventSchedulerView`

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

---

### `EventSchedulerEventLayout`

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

---

### `EventSchedulerConflictPolicy`

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

---

### `EventSchedulerConflictScope`

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

---

### `EventSchedulerConflictType`

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

---

### `EventSchedulerConflictSeverity`

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

---

### `EventSchedulerConflictRulePolicy`

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

---

### `EventSchedulerMutationAction`

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

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

---

### `EventSchedulerStatus`

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

---

### `EventSchedulerAvailabilityKind`

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

---

### `EventSchedulerEntityId`

```ts
export type EventSchedulerEntityId = string | number;
```

---

### `EventSchedulerTimeRange`

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

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

---

### `EventSchedulerDateRange`

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

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

---

### `EventSchedulerCurrentTimeMarkerConfig`

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

---

### `EventSchedulerResolvedCurrentTimeMarkerConfig`

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

---

### `EventSchedulerNonWorkingTimeConfig`

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

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

---

### `EventSchedulerResolvedWorkingHoursRange`

```ts
export type EventSchedulerResolvedWorkingHoursRange = CalendarResolvedWorkingTimeRange;
```

---

### `EventSchedulerResolvedNonWorkingTimeConfig`

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

---

### `EventSchedulerResolvedCalendarEntity`

```ts
export type EventSchedulerResolvedCalendarEntity = ResolvedCalendarEntity;
```

---

### `EventSchedulerResolvedCalendarsConfig`

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

---

### `EventSchedulerEventEntity`

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

---

### `EventSchedulerEventEditChanges` (Extended from `index.ts`)

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

---

### `EventSchedulerRecurrenceFrequency`

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

---

### `EventSchedulerRecurrenceRule`

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

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

```ts
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`)

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

---

### `EventSchedulerRecurrenceSeriesEditOptions`

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

---

### `EventSchedulerRecurrenceSeriesDeleteOptions`

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

---

### `EventSchedulerSelectionConfig`

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

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

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

---

### `EventSchedulerClipboardPayload`

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

---

### `EventSchedulerPasteOptions`

```ts
interface EventSchedulerPasteOptions {
  readonly startDateTime?: string;
  readonly resourceId?: EventSchedulerEntityId;
  readonly idSuffix?: string
}
```

---

### `EventSchedulerDuplicateRangeOptions`

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

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

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

---

### `EventSchedulerCoverageRequirementEntity`

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

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

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

---

### `EventSchedulerCoverageCountContext`

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

---

### `EventSchedulerCoverageConfig`

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

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

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

---

### `EventSchedulerUtilizationStatus`

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

---

### `EventSchedulerUtilizationTargetContext`

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

---

### `EventSchedulerUtilizationCountContext`

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

---

### `EventSchedulerUtilizationConfig`

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

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

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

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

---

### `EventSchedulerUnassignedSummary`

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

```ts
interface EventSchedulerUnassignedRoleContext {
  readonly event: EventSchedulerEventEntity
}
```

---

### `EventSchedulerUnassignedRoleFormatterContext` (Extended from `index.ts`)

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

---

### `EventSchedulerUnassignedAssignmentContext`

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

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

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

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

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

---

### `EventSchedulerFilterSummary`

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

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

---

### `EventSchedulerResourceGroupSummary`

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

---

### `EventSchedulerResourceGroupContext`

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

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

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

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

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

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

---

### `EventSchedulerPermissionDecision`

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

---

### `EventSchedulerCreatePermissionContext`

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

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

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

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

---

### `EventSchedulerTemplateH`

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

---

### `EventSchedulerElementProps`

```ts
export type EventSchedulerElementProps = Record<string, unknown>;
```

---

### `EventSchedulerRenderContext`

```ts
interface EventSchedulerRenderContext {
  readonly event: EventSchedulerEventEntity;
  readonly resource?: EventSchedulerResourceEntity;
  readonly segment: EventSchedulerEventSegment
}
```

---

### `EventSchedulerEventRenderMode`

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

---

### `EventSchedulerEventSectionContext` (Extended from `index.ts`)

```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`)

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

---

### `EventSchedulerEventResizeHandleContext` (Extended from `index.ts`)

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

---

### `EventSchedulerConflictDisplayContext` (Extended from `index.ts`)

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

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

---

### `EventSchedulerTimelineHeaderContext`

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

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

---

### `EventSchedulerHeaderGroupKind`

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

---

### `EventSchedulerHeaderContext`

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

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

---

### `EventSchedulerTimeCellContext` (Extended from `index.ts`)

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

---

### `EventSchedulerCurrentTimeMarkerContext`

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

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

---

### `EventSchedulerSlotRenderContext` (Extended from `index.ts`)

```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`)

```ts
interface EventSchedulerDayCellContext {

}
```

---

### `EventSchedulerClosedSlotContext` (Extended from `index.ts`)

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

---

### `EventSchedulerResourceCellContext` (Extended from `index.ts`)

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

---

### `EventSchedulerResourceGroupCellContext` (Extended from `index.ts`)

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

---

### `EventSchedulerTimelineCellContext` (Extended from `index.ts`)

```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`)

```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`)

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

---

### `EventSchedulerEmptyStateKind`

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

---

### `EventSchedulerEmptyStateContext`

```ts
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:**
```typescript
* ```ts
 * customization: {
 *   emptyState: {
 *     template: ({ kind, label }) => `${kind}: ${label}`,
 *   },
 * }
 * ```
```

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

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

---

### `EventSchedulerColumnSizeConfig`

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

---

### `EventSchedulerViewColumnSizeConfig`

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

---

### `EventSchedulerHeaderCustomizationConfig`

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

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

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

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

---

### `EventSchedulerConflictCustomizationConfig`

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

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

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

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

---

### `EventSchedulerEventEditorStatusOption`

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

---

### `EventSchedulerLabels`

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

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

---

### `EventSchedulerEventEditorHook`

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

---

### `EventSchedulerEventTemplate`

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

---

### `EventSchedulerRemoteMode`

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

---

### `EventSchedulerRemoteLoadTarget`

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

---

### `EventSchedulerRemoteMutationStatus`

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

---

### `EventSchedulerRemoteRangeRequest`

```ts
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`)

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

---

### `EventSchedulerRemoteEventsResult`

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

---

### `EventSchedulerRemoteResourcesResult`

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

---

### `EventSchedulerRemoteAvailabilityResult`

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

---

### `EventSchedulerRemoteCoverageResult`

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

---

### `EventSchedulerRemoteValidationResult`

```ts
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`)

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

---

### `EventSchedulerRemoteMutationRequest`

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

---

### `EventSchedulerRemoteConfig`

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

**Example:**
```typescript
* ```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 })
 *   }
 * }
 * ```
```

```ts
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()`.

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

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

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

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

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

```ts
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`)

```ts
interface EventSchedulerAvailabilityRuleContext {
  readonly resourceId?: EventSchedulerEntityId
}
```

---

### `EventSchedulerAvailabilityRuleResult`

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

---

### `EventSchedulerAvailabilityRule`

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

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

---

### `EventSchedulerContextMenuItemId`

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

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

---

### `EventSchedulerContextMenuItemsContext`

```ts
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`)

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

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

---

### `EventSchedulerContextMenuItemDisabled`

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

---

### `EventSchedulerContextMenuItemAction`

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

---

### `EventSchedulerContextMenuItem`

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

```ts
export type EventSchedulerContextMenuItemLike = ContextMenuItem | EventSchedulerContextMenuItem;
```

---

### `EventSchedulerContextMenuItemContext` (Extended from `index.ts`)

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

---

### `EventSchedulerContextMenuItemsFactory`

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

---

### `EventSchedulerContextMenuTemplate`

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

---

### `EventSchedulerContextMenuItemFilter`

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

---

### `EventSchedulerContextMenuConfig`

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

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

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

---

### `EventSchedulerContinuationLabelsConfig`

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

```ts
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`)

```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`)

```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`)

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

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

---

### `EventSchedulerDay`

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

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

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

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

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

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

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

---

### `EventSchedulerEventDeletedDetail`

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

---

### `EventSchedulerEventCopiedDetail`

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

---

### `EventSchedulerEventSelectedDetail`

```ts
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`)

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

---

### `EventSchedulerBeforeSlotSelectDetail` (Extended from `index.ts`)

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

---

### `EventSchedulerSlotClickDetail` (Extended from `index.ts`)

```ts
interface EventSchedulerSlotClickDetail {
  readonly resourceId?: EventSchedulerEntityId
}
```

---

### `EventSchedulerConflictsUpdatedDetail`

```ts
interface EventSchedulerConflictsUpdatedDetail {
  readonly conflicts: readonly EventSchedulerConflict[]
}
```

---

### `EventSchedulerRemoteLoadDetail`

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

---

### `EventSchedulerRemoteMutationDetail`

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

```ts
interface EventSchedulerRemoteStateChangeDetail {
  readonly state: EventSchedulerRemoteState
}
```

---

### `EventSchedulerNavigateRequestDetail`

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

---

### `EventSchedulerViewRequestDetail`

```ts
interface EventSchedulerViewRequestDetail {
  readonly view: EventSchedulerView
}
```

---

### `EventSchedulerResourceReassignRequestDetail`

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

---

### `EventSchedulerOpenShiftAssignRequestDetail` (Extended from `index.ts`)

```ts
interface EventSchedulerOpenShiftAssignRequestDetail {
  readonly resourceId?: EventSchedulerEntityId
}
```

---

### `EventSchedulerSearchFocusRequestDetail`

```ts
interface EventSchedulerSearchFocusRequestDetail {
  readonly reason: 'keyboard'
}
```

---

### `EventSchedulerColumnTypeMap`

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

---

### `createEventSchedulerProjection`

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

---

### `createSlotContext`

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

---

### `createRangeContext`

```ts
export function createRangeContext(
  projection: EventSchedulerProjection,
  dayIndex: number,
  startSlot: number,
  endSlot: number,
  resourceId?: EventSchedulerEntityId,
  options:;
```

---

### `formatSchedulerDisplayTime`

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

---

### `EVENT_SCHEDULER_UNASSIGNED_RESOURCE_ID`

```ts
EVENT_SCHEDULER_UNASSIGNED_RESOURCE_ID: string;
```

---

### `resolveUnassignedRequiredRole`

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

---

### `moveEvent`

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

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

---

### `resizeEvent`

Resizes one event boundary while preserving the opposite boundary.

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

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

---

### `createEvent`

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

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

---

### `deleteEvent`

Removes one event after permission and before-change validation.

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

---

### `createEventFromSlot`

Creates an event draft from a single scheduler slot.

```ts
export function createEventFromSlot(
  context: EventSchedulerMutationContext,
  options:;
```

---

### `createEventFromRange`

Creates an event from a selected scheduler range.

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

---

### `EventSchedulerMutationContext`

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

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

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

---

### `updateSelectedEventIds`

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

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

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

---

### `bulkMoveEvents`

Moves selected events together while preserving their relative offsets.

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

---

### `bulkDeleteEvents`

Deletes selected events atomically.

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

---

### `bulkUpdateEventStatus`

Updates status for selected events atomically.

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

---

### `pasteCopiedEvents`

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

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

---

### `duplicateEvents`

Duplicates selected events by an offset in days.

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

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

---

### `EventSchedulerBulkContext`

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

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

---

### `idKey`

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

---

### `createEventFromTemplate`

Creates one event from a configured scheduler template.

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

---

### `createRecurringEvents`

Expands a template into daily or weekly recurring events.

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

---

### `editRecurrenceSeries`

Applies changes to every matching event in a recurrence series.

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

---

### `deleteRecurrenceSeries`

Deletes every matching event in a recurrence series.

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

---

### `expandRecurrenceStartDateTimes`

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

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

---

### `EventSchedulerTemplateContext` (Extended from `index.ts`)

Context used by template and recurrence helper functions.

```ts
interface EventSchedulerTemplateContext {
  readonly templates: readonly EventSchedulerEventTemplateEntity[]
}
```

---

### `resolveEventSchedulerLabels`

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

---

### `DEFAULT_EVENT_SCHEDULER_LABELS`

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

```ts
export function resolveEventSchedulerSavedViewConfig(config: EventSchedulerConfig): EventSchedulerConfig;
```

---

### `applyEventSchedulerFilters`

```ts
export function applyEventSchedulerFilters(options:;
```

---

### `EventSchedulerFilterResult`

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

---

### `createEventSchedulerConflicts`

```ts
export function createEventSchedulerConflicts(input: EventSchedulerConflictEngineInput): EventSchedulerConflictEngineResult;
```

---

### `hasBlockingConflictsForEvent`

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

---

### `EventSchedulerConflictEngineInput`

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

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

---

### `normalizeCoverageRequirements`

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

---

### `createEventSchedulerCoverageResults`

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

---

### `summarizeCoverageResults`

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

---

### `getTimelineCoverageState`

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

---

### `formatCoverageSummary`

```ts
export function formatCoverageSummary(summary: EventSchedulerCoverageSummary): string;
```

---

### `EventSchedulerCoverageInput`

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

---

### `EventSchedulerTimelineCoverageState`

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

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

---

### `summarizeUtilizationResults`

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

---

### `formatUtilizationResult`

```ts
export function formatUtilizationResult(result: EventSchedulerUtilizationResult): string;
```

---

### `formatUtilizationSummary`

```ts
export function formatUtilizationSummary(summary: EventSchedulerUtilizationSummary): string;
```

---

### `EventSchedulerUtilizationInput`

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

---

### `createRemoteState`

```ts
export function createRemoteState(patch: Partial<EventSchedulerRemoteState> =;
```

---

### `EventSchedulerRemoteDataSnapshot`

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

---

### `EventSchedulerRemoteLoadContext`

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

---

### `EventSchedulerRemoteMutationContext` (Extended from `index.ts`)

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

---

### `EventSchedulerRemoteControllerCallbacks`

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

```ts
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:**
```typescript
* ```ts
 * assertCanCreateEvent({ config, resources }, { event: draft, action: 'create' });
 * ```
```

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

---

### `canCreateEvent`

Checks whether an event creation is allowed without throwing.

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

---

### `assertCanMutateEvent`

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

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

---

### `canMutateEvent`

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

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

---

### `isEventReadonly`

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

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

---

### `isResourceLocked`

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

```ts
export function isResourceLocked(resource: EventSchedulerResourceEntity): boolean;
```

---

### `EventSchedulerPermissionDataContext`

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

---

### `EventSchedulerPermissionCheckResult`

Result returned by scheduler permission checks.

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

---

### `EventSchedulerCreatePermissionOptions`

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

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

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

---

### `exportEventSchedulerEvents`

```ts
export function exportEventSchedulerEvents(
  projection: EventSchedulerProjection,
  options: EventSchedulerExportOptions =;
```

---

### `exportEventSchedulerResourceWorkload`

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

---

### `exportEventSchedulerConflicts`

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

---

### `exportEventSchedulerCoverage`

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

---

### `exportEventSchedulerVisibleSchedule`

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

---

### `createEventSchedulerPrintView`

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

---

### `EventSchedulerExportFormat`

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

---

### `EventSchedulerExportScope`

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

---

### `EventSchedulerReportValue`

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

---

### `EventSchedulerReportRow`

```ts
export type EventSchedulerReportRow = Record<string, EventSchedulerReportValue>;
```

---

### `EventSchedulerExportOptions`

Options shared by scheduler CSV/JSON export helpers.

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

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

```ts
interface EventSchedulerCoverageExportOptions {
  readonly gapsOnly?: boolean
}
```

---

### `EventSchedulerExportResult`

Result returned by scheduler export helpers.

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

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

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

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

---

### `availabilityOverlapsDate`

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

---

### `availabilityAppliesToResource`

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

---

### `getTimelineAvailabilityState`

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

---

### `getConfiguredAvailabilitySlotState`

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

---

### `getNonWorkingTimeSlotState`

```ts
export function getNonWorkingTimeSlotState(
  projection: EventSchedulerProjection,
  date: string,
  startMinutes: number,
  endMinutes: number,
  options:;
```

---

### `isCurrentTimelineDay`

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

---

### `EventSchedulerAvailabilitySlotKind`

```ts
export type EventSchedulerAvailabilitySlotKind = EventSchedulerAvailabilityKind | 'closed';
```

---

### `EventSchedulerAvailabilitySlotState`

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

---

### `getCalendarSlotState`

```ts
export function getCalendarSlotState(
  context: EventSchedulerCalendarResolveContext,
  date: string,
  startMinutes: number,
  endMinutes: number,
  resourceId?: EventSchedulerEntityId,
  options:;
```

---

### `isCalendarDateSchedulable`

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

---

### `isCalendarRangeWorking`

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

---

### `resolveCalendar`

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

---

### `EventSchedulerCalendarResolveContext`

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

---

### `EventSchedulerCalendarSlotState`

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

---

### `mergeSchedulerElementProps`

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

---

### `renderCustomSection`

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

---

### `mergeClassValues`

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

---

### `normalizeKeyboardShortcuts`

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

---

### `normalizeKeyboardShortcutMap`

```ts
export function normalizeKeyboardShortcutMap(
  shortcuts: Partial<Record<string, string | readonly string[] | false>> =;
```

---

### `DEFAULT_KEYBOARD_SHORTCUTS`

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

---

### `normalizeResources`

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

---

### `resolveTimelineResources`

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

---

### `normalizeEvents`

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

---

### `getEventTitle`

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

---

### `normalizeAssignments`

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

---

### `normalizeAvailability`

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

---

### `groupAssignmentsByEvent`

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

---

### `getEventResourceIds`

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

---

### `createUnassignedSummary`

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

---

### `createEventSegments`

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

---

### `isUnassignedResource`

```ts
export function isUnassignedResource(resource: EventSchedulerResourceEntity): boolean;
```

---

### `assignLanes`

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

---

### `createResourceRows`

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

---

### `createTimeRows`

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

---

### `createWeekDays`

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

---

### `createTimeSlots`

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

---

### `createWeekColumns`

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

---

### `createTimelineColumns`

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

---

### `isEmptyId`

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

---

### `uniqueIds`

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

---

### `matchesStringFilter`

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

---

### `getPathValue`

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

---

### `createResourceTree`

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

---

### `flattenResourceTree`

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

---

### `EventSchedulerResourceTreeNode`

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

---

### `EventSchedulerCellTemplateH`

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

---

### `EventSchedulerColumnTypeOptions`

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

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

---

### `createEventSchedulerTimeRowHeader`

```ts
export function createEventSchedulerTimeRowHeader(projection: EventSchedulerProjection): RowHeaders;
```

---

### `createEventSchedulerTimeCellProperties`

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

---

### `createEventSchedulerTimeCellTemplate`

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

---

### `createTimeCellContext`

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

---

### `flattenSchedulerColumns`

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

---

### `isSchedulerColumnGrouping`

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

---

### `EventSchedulerContextMenuControllerOptions`

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

```ts
class EventSchedulerContextMenuController {
  apply(): void;

  remove(): void;
}
```

---

### `createDayCellTemplate`

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

---

### `canCreateOverExistingSegments`

```ts
export function canCreateOverExistingSegments(config: EventSchedulerResolvedConfig): boolean;
```

---

### `EventSchedulerSlotPoint`

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

---

### `EventSchedulerGhostRangeOptions`

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

---

### `EventSchedulerRemoteStateViewModel`

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

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

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

---

### `unmountEventSchedulerEditor`

```ts
export function unmountEventSchedulerEditor(host: HTMLElement): void;
```

---

### `EventSchedulerEditorState`

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

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

---

### `renderWeekEventSegmentSlice`

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

---

### `renderTimelineEventSegmentSlice`

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

---

### `getWeekEventVisibleHeight`

```ts
export function getWeekEventVisibleHeight(options:;
```

---

### `EventSchedulerGridSync`

```ts
class EventSchedulerGridSync {
  initialize(): void;

  applyProjection(projection: EventSchedulerProjection): void;

  restore(): void;

  isApplyingSource(): boolean;

  isApplyingColumns(): boolean;
}
```

---

### `EventSchedulerKeyboardControllerOptions`

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

```ts
class EventSchedulerKeyboardController {
  destroy(): void;

  handleKeyDown(event: KeyboardEvent): void;

  closeShortcutsPanel(): void;
}
```

---

### `EventSchedulerPointerControllerOptions`

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

---

### `EventSchedulerInteractionPreview`

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

---

### `EventSchedulerPointerController`

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

```ts
export function resolvePointerMoveTarget(options:;
```

---

### `EventSchedulerPointerMoveTarget`

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

---

### `getSegmentGhostColor`

```ts
export function getSegmentGhostColor(options:;
```

---

### `createPreviewEventFromRange`

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

---

### `createPreviewReassignmentPatch`

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

---

### `PREVIEW_CREATE_EVENT_ID`

```ts
PREVIEW_CREATE_EVENT_ID: string;
```

---

### `getActiveCreateRange`

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

---

### `getSnappedSlotPoint`

```ts
export function getSnappedSlotPoint(
  projection: EventSchedulerProjection,
  slot:;
```

---

### `getSnappedResizeDateTime`

```ts
export function getSnappedResizeDateTime(
  projection: EventSchedulerProjection,
  slot:;
```

---

### `getResizePreviewRange`

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

---

### `getRangeSlotOffsets`

```ts
export function getRangeSlotOffsets(
  projection: EventSchedulerProjection,
  range: EventSchedulerCreateRangeContext,
):;
```

---

### `getPointerOffsetRatio`

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

---

### `EventSchedulerCreatePointerActionState`

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

---

### `EventSchedulerEventPointerActionState`

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

---

### `EventSchedulerSnappedSlotPoint`

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

---

### `EventSchedulerResizePreviewRange`

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

---

### `createResourceCellTemplate`

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

---

### `createTimelineCellTemplate`

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

---

### `createTimelineCellTemplateState`

```ts
export function createTimelineCellTemplateState(options:;
```

---

### `getCurrentTimeMarker`

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

---

### `EventSchedulerCurrentTimeCellState`

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

---

### `EventSchedulerTimelineCellTemplateState`

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