# API-Referenz

> Die öffentliche API von SuperScheduler 0.1.0: Komponenten, Optionen mit geprüften Standards, Callbacks, Control-Methoden, Subpath-Module, Lite und reservierte APIs.

Source: https://superscheduler.org/de/docs/api-reference/
Reviewed: 2026-10-07

Diese Seite führt die öffentliche API auf, die SuperScheduler 0.1.0 implementiert: die React-Komponenten, jede Option mit Typ und Standardwert, nach Bereichen gruppiert, die Callbacks mit ihren Argumenten und der Unterstützung für Abbruch oder asynchrone Bestätigung, die Methoden des Controls, die Subpath-Module von Pro und die Lite-API. Mitglieder, die typisiert, aber nicht implementiert sind, stehen gesondert unter Reservierte APIs: Sie warnen in Entwicklungs-Builds und bewirken nichts.

Diese Referenz behandelt die API, die in diesen Anleitungen verwendet wird, so wie sie in Version 0.1.0 implementiert ist. Alles außer dem Abschnitt [Lite-API](#lite) gehört zu SuperScheduler Pro (`super-scheduler`). Standardwerte sind die Werte, die das Control verwendet, wenn Sie eine Option weglassen; „keiner“ bedeutet, dass die Option keinen Wert hat, bis Sie einen setzen. Die Anleitungen erklären, wie sich diese Bausteine kombinieren lassen; die [Beispiele](https://superscheduler.org/de/examples/) zeigen sie in funktionierenden Anwendungen.

Einige Konventionen gelten überall:

- `DateInput` ist `SuperScheduler.Date | string`. Strings sind ISO-8601-Werte in bürgerlicher Zeit mit Sekunden (`'2026-10-01T14:00:00'`) oder reine Datumsangaben (`'2026-10-01'`). Das Ende eines Ereignisses ist exklusiv.
- IDs von Ressourcen, Ereignissen und Verknüpfungen sind `string | number` und werden strikt verglichen: `1` und `'1'` sind verschieden.
- Optionen sind Props von `SuperSchedulerComponent`, Schlüssel von `control.update(options)` und Live-Eigenschaften des Controls.
- Handler laufen mit `this` auf das Control gesetzt. Ihre Rückgabewerte werden ignoriert, und auf einen `async`-Handler wird nicht gewartet: Verwenden Sie das Protokoll aus `async` und `loaded()`, wo es existiert.

## Einstiegspunkte
| Import | Edition | Exporte | Anleitung |
|---|---|---|---|
| `super-scheduler` | Pro | `SuperSchedulerComponent`, `useSchedulerControl`, der Namespace `SuperScheduler`, `SchedulerDate`, `SchedulerEvent`, `version` und die öffentlichen Typen | [React-Integration](https://superscheduler.org/de/docs/react-integration/) |
| `super-scheduler/styles.css` | Pro | Das Stylesheet (ein einziges `@layer super-scheduler`) | [Theming](https://superscheduler.org/de/docs/theming/) |
| `super-scheduler/react-render` | Pro | `SuperSchedulerComponent` mit React-Render-Props | [React-Render-Slots](https://superscheduler.org/de/docs/react-render-slots/) |
| `super-scheduler/history` | Pro | `createHistory` | [Rückgängig und Wiederholen](https://superscheduler.org/de/docs/undo-redo/) |
| `super-scheduler/minimap` | Pro | `createMinimap`, `SchedulerMinimap`, `eventDensity` | [Minimap](https://superscheduler.org/de/docs/minimap-metrics/) |
| `super-scheduler/panes` | Pro | `SchedulerPanes`, `linkPanes` | [Bereiche und gespeicherte Ansichten](https://superscheduler.org/de/docs/panes-saved-views/) |
| `super-scheduler/zoom-ui` | Pro | `createZoomHud`, `createZoomSlider`, `createLodBadge` | [Zeitskalen und Zoom](https://superscheduler.org/de/docs/time-scales-zoom/) |
| `super-scheduler/views` | Pro | `getViewState`, `applyViewState` | [Bereiche und gespeicherte Ansichten](https://superscheduler.org/de/docs/panes-saved-views/) |
| `super-scheduler/ranges` | Pro | `createRangeLoader` | [Bereichsweises Laden](https://superscheduler.org/de/docs/range-loading/) |
| `super-scheduler/hooks` | Pro | `useScheduler`, `useSchedulerState`, `subscribeScheduler`, `getSchedulerSnapshot` | [Kontrollierter Zustand](https://superscheduler.org/de/docs/controlled-state/) |
| `super-scheduler/tailwind` | Pro | Preset für Tailwind CSS v3 (`export =`) | [Theming](https://superscheduler.org/de/docs/theming/) |
| `super-scheduler/datasets` | Pro | `generateDataset`, `generateScenario`, `toSuperSchedulerData`, `SCENARIOS`, `Prng` | [Performance](https://superscheduler.org/de/docs/performance-virtualization/#measuring) |
| `super-scheduler/core` | Pro | DOM-freie Hilfsmittel für Datumswerte, Dauern, Zeitleisten, Indizes und Layout | |
| `super-scheduler-lite` | Lite | `SuperSchedulerComponent`, der Namespace `SuperScheduler`, `SchedulerDate`, `version` | [Schnellstart mit Lite](https://superscheduler.org/de/docs/quick-start-lite/) |
| `super-scheduler-lite/styles.css` | Lite | Das Lite-Stylesheet | [Schnellstart mit Lite](https://superscheduler.org/de/docs/quick-start-lite/) |

Jeder Einstiegspunkt wird als ESM, als CommonJS und mit Typdeklarationen ausgeliefert. React 18.2 oder neuer, oder 19, ist eine Peer-Abhängigkeit (bei Pro auch React DOM); Laufzeitabhängigkeiten gibt es keine. Alle Module lassen sich auf einem Server ohne DOM importieren.

## Komponenten
### SuperSchedulerComponent
`SuperSchedulerComponent` beherbergt ein Control. Ihre Props (`SchedulerProps`) sind alle Optionen und Handler unten plus `controlRef`. Sie rendert ein ungestyltes `<div>`, hat keine Props `className`, `style` oder `id` und leitet an `control.update()` nur die Props weiter, deren Identität sich seit dem letzten Rendern geändert hat; eine Prop, die verschwindet, fällt auf ihren Standardwert zurück.

| Mitglied | Typ | Hinweise |
|---|---|---|
| `ref.current.control` | `SuperScheduler.Scheduler` | Wird beim Mount zugewiesen; nach dem Unmount ist es das freigegebene Control |
| `controlRef` | `MutableRefObject<Scheduler \| null>` oder `(control) => void` | Ref-Objekte werden beim Mount gesetzt und beim Unmount geleert; Funktionen werden nur beim Mount mit dem Control aufgerufen |
| `useSchedulerControl()` | `{ controlRef, control }` | `control` ist React-State: `null` bis zum Mount, dann das Control, `null` nach dem Unmount |

Die Komponente aus `super-scheduler/react-render` akzeptiert dieselben Props plus `renderEvent`, `renderCell`, `renderRowHeader`, `renderTimeHeader`, `renderArea`, `renderCorner`, `eventHover`, die Handler `onBefore*DomAdd` und `onBefore*DomRemove` sowie `renderOptions` (siehe [react-render](#react-render)).

```tsx
// src/control-access.tsx
import { useEffect, useRef } from 'react'
import { SuperScheduler, SuperSchedulerComponent, useSchedulerControl } from 'super-scheduler'
import { useScheduler } from 'super-scheduler/hooks'

const CONFIG = {
  startDate: '2026-10-01',
  days: 31,
  scale: 'Day',
} satisfies SuperScheduler.SchedulerConfig

// 1. A class ref: `ref.current.control` exists after mount.
export function WithRef() {
  const ref = useRef<SuperSchedulerComponent>(null)
  useEffect(() => ref.current?.control.scrollTo('2026-10-15', true, 'middle'), [])
  return <SuperSchedulerComponent ref={ref} {...CONFIG} />
}

// 2. The control as React state: null until mount, then the live control.
export function WithHook() {
  const { controlRef, control } = useSchedulerControl()
  useEffect(() => control?.scrollTo(SuperScheduler.Date.today()), [control])
  return <SuperSchedulerComponent controlRef={controlRef} {...CONFIG} />
}

// 3. Control plus tracked state topics, published after changes settle.
export function WithState() {
  const { controlRef, state } = useScheduler({ track: ['zoom', 'viewport'] })
  return (
    <>
      <p>
        {state.viewport === undefined
          ? ''
          : `${state.viewport.start.toString('d MMM')} to ${state.viewport.end.toString('d MMM')}`}
      </p>
      <SuperSchedulerComponent controlRef={controlRef} {...CONFIG} />
    </>
  )
}

// 4. Imperative, without React: init() before use, dispose() on teardown.
export function mount(host: HTMLElement): () => void {
  const control = new SuperScheduler.Scheduler(host, CONFIG)
  control.init()
  return () => control.dispose()
}
```
### Typen
| Typ | Bedeutung |
|---|---|
| `SchedulerProps` | Props von `SuperSchedulerComponent` |
| `SchedulerConfig` | Optionen, die `new SuperScheduler.Scheduler()` und `control.update()` akzeptieren |
| `SchedulerOptions`, `SchedulerEventHandlers` | Die Options- und die Handler-Hälfte der Konfiguration |
| `SchedulerApi` | Die Schnittstelle des Controls (dieselbe Form wie `SuperScheduler.Scheduler`) |
| `Scheduler...Args` | Eine Schnittstelle pro Handler, zum Beispiel `SchedulerEventMoveArgs`, `SchedulerEventsChangeArgs` |
| `SuperScheduler.EventData<T>`, `SuperScheduler.ResourceData<T>` | Datenstrukturen, generisch über Ihre zusätzlichen Felder |
| `SchedulerCustomProps` | Mit `declare module 'super-scheduler'` um eigene Props erweiterbar |

## Datenstrukturen
### Ereignisse
`SuperScheduler.EventData<T>` hat keine Indexsignatur: Deklarieren Sie zusätzliche Felder über den Typparameter, zum Beispiel `EventData<{ guest: string }>`.

| Felder | Typ | Bedeutung |
|---|---|---|
| `id`, `start`, `end`, `text` | `EventId`, `DateInput`, `DateInput`, `string` | Erforderlich. `end` ist exklusiv, außer bei `eventEndSpec: 'Date'` |
| `resource` | `ResourceId` | Zeile des Ereignisses |
| `backColor`, `fontColor`, `borderColor`, `barColor`, `barBackColor` | `string` | Farben |
| `cssClass`, `padding`, `borderRadius`, `height` | `string`, `string \| number`, `string \| number`, `number` | Darstellung |
| `html`, `htmlLeft`, `htmlRight` | `string` | Vertrauenswürdiges HTML, wird nie escaped; escapen Sie Nutzertext mit `SuperScheduler.Util.escapeHtml` |
| `toolTip`, `bubbleHtml`, `areas`, `contextMenu` | `string`, `string`, `AreaData[]`, `Menu` | Tooltip, Bubble-Inhalt, klickbare Bereiche, Menü |
| `moveDisabled`, `resizeDisabled`, `moveHDisabled`, `moveVDisabled` | `boolean` | Sperren: jede Verschiebung, Dauer ändern, horizontale Verschiebungen, Zeilenwechsel |
| `clickDisabled`, `doubleClickDisabled`, `rightClickDisabled`, `deleteDisabled`, `moveSkipNonBusinessDisabled` | `boolean` | Abschaltungen pro Ereignis |
| `hidden`, `barHidden` | `boolean` | Blendet das Ereignis oder seinen Dauerbalken aus |
| `complete` | `number` | Prozentwert für `durationBarMode: 'PercentComplete'` |
| `line`, `minLine`, `sort` | `'dedicated' \| number`, `number`, `string[]` | Steuerung der Stapelung |
| `tags` | `unknown` | Freie Daten |

### Ressourcen
`SuperScheduler.ResourceData<T>` akzeptiert zusätzliche Felder.

| Felder | Typ | Bedeutung |
|---|---|---|
| `id`, `name` | `ResourceId`, `string` | Zeilen-ID und Beschriftung |
| `children`, `expanded` | `ResourceData[]`, `boolean` | Baumzeilen (erfordern `treeEnabled`); Elternelemente sind zugeklappt, außer bei `expanded: true` |
| `frozen` | `'top' \| 'bottom'` | Zeile, die über oder unter den scrollenden Zeilen fixiert ist |
| `split` | `ResourceData[]` | Mehrere Zeilen unter einer Kopfzelle |
| `columns` | `ResourceColumnData[]` | Zellen für `rowHeaderColumns`, nach Index |
| `cellsDisabled` | `boolean` | Jede Zelle der Zeile ist deaktiviert: schraffiert, kein Ablegen, keine Auswahl |
| `preventUsage` | `boolean` | Keine Ereignisse und keine Auswahl in der Zeile |
| `cellsAutoUpdated` | `boolean` | Führt `onBeforeCellRender` für diese Zeile erneut aus, wenn sich ihre Ereignisse ändern |
| `minHeight`, `eventHeight`, `marginTop`, `marginBottom`, `maxLines`, `emptyHeight` | `number` | Zeilengeometrie |
| `backColor`, `fontColor`, `cssClass`, `html`, `toolTip`, `bubbleHtml`, `ariaLabel`, `areas`, `contextMenu`, `tags` | verschiedene | Darstellung des Kopfes und Daten |

### Verknüpfungen, Köpfe, Zoomstufen und Trennlinien
| Typ | Felder |
|---|---|
| `LinkData` | `from`, `to` (Ereignis-IDs), `id`, `type` (`'FinishToStart'` als Standard, `'FinishToFinish'`, `'StartToStart'`, `'StartToFinish'`), `color`, `width`, `style` (`'solid' \| 'dotted' \| 'dashed'`), `cssClass`, `layer`, `text`, `textAlignment`, `bubbleHtml`, `contextMenu` |
| `TimeHeaderData` | `groupBy` (`'Minute' \| 'Hour' \| 'Day' \| 'Week' \| 'Month' \| 'Quarter' \| 'Year' \| 'Cell' \| 'None' \| 'Default'`), `format`, `height` |
| `ZoomLevel` | `id`, `properties` (Optionswerte, jeweils optional als Funktion von `{ date, level }`) |
| `SeparatorData` | `location`, `color`, `layer` (`'AboveEvents' \| 'BelowEvents'`), `opacity`, `width`, `cssClass`, `toolTip` |
| `TimelineData` | `start`, `end`, `width` (Zellen für `scale: 'Manual'`) |

## Optionen
### Zeitachse
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `startDate` | `DateInput` | heute | Auf Mitternacht abgeschnitten |
| `days` | `number` | `1` | Länge der Zeitleiste |
| `scale` | `'CellDuration' \| 'Minute' \| 'Hour' \| 'Day' \| 'Week' \| 'Month' \| 'Year' \| 'Manual'` | `'CellDuration'` | `'Manual'` verwendet `timeline` |
| `cellDuration` | `number` (Minuten) | `60` | Mit `scale: 'CellDuration'` |
| `cellWidth` | `number` | `40` | Pixel pro Zelle der aktuellen Skala |
| `cellWidthSpec` | `'Fixed' \| 'Auto'` | `'Fixed'` | `'Auto'` passt die Zeitleiste in die Breite ein |
| `cellWidthMin` | `number` | `1` | |
| `timeHeaders` | `TimeHeaderData[]` | `[{ groupBy: 'Default' }, { groupBy: 'Cell' }]` | `'Default'` folgt `cellGroupBy` |
| `cellGroupBy` | `GroupBy` | `'Day'` | |
| `headerHeight` | `number` | `30` | Pro Kopfzeile |
| `timeFormat` | `'Auto' \| 'Clock12Hours' \| 'Clock24Hours'` | `'Auto'` | Nur Standardbeschriftungen der Stunden |
| `locale` | `string \| SuperScheduler.Locale` | `'en-us'` | Jede `Intl`-Locale-ID |
| `weekStarts` | `'Auto' \| number` | `'Auto'` | `0` ist Sonntag |
| `eventEndSpec` | `'DateTime' \| 'Date'` | `'DateTime'` | `'Date'` macht Enden ohne Uhrzeit inklusiv |
| `showNonBusiness` | `boolean` | `true` | `false` blendet Wochenenden (Tagesskala) oder Stunden außerhalb der Geschäftszeiten aus |
| `businessBeginsHour`, `businessEndsHour` | `number` | `9`, `18` | |
| `businessWeekends` | `boolean` | `false` | |
| `cellsMarkBusiness` | `boolean` | `true` | |
| `showCurrentTimeHeader` | `boolean` | `false` | |
| `separators` | `SeparatorData[]` | `[]` | Vertikale Datumsmarkierungen |
| `timeline` | `TimelineData[]` | keiner | Mit `scale: 'Manual'` |
| `infiniteScrollingEnabled` | `boolean` | `false` | `infiniteScrollingMargin` `50`, `infiniteScrollingStepDays` `30` |
| `floatingTimeHeaders` | `boolean` | `true` | Mitlaufende Beschriftungen im Kopf |
| `viewType` | `'Resources'` | `'Resources'` | `'Days'` und `'Gantt'` sind reserviert |
| `scrollX`, `scrollY` | `number` | keiner | Anfängliche Scrollposition in Pixeln |

### Zeilen
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `resources` | `ResourceData[]` | `[]` | |
| `treeEnabled` | `boolean` | `false` | Erforderlich für `children` |
| `treeIndent` | `number` | `20` | |
| `treeAutoExpand` | `boolean` | `true` | |
| `treePreventParentUsage` | `boolean` | `false` | Elternelemente nehmen keine Ereignisse und keine Auswahl an |
| `rowHeaderWidth` | `number` | `80` | |
| `rowHeaderWidthAutoFit` | `boolean` | `true` | Wächst mit den Namen; `rowHeaderWidthMin` `20`, `rowHeaderWidthMarginRight` `0` |
| `rowHeaderColumns` | `RowHeaderColumnData[]` | keiner | Eine Spalte, die `name` zeigt |
| `rowHeaderColumnsResizable` | `boolean` | `true` | `rowHeaderColumnDefaultWidth` `80`, `rowHeaderColumnsMergeParents` `true` |
| `rowHeaderColumnsReorderable` | `boolean` | `false` | Spaltentitel ziehen |
| `rowMinHeight`, `rowEmptyHeight` | `number` | `0`, keiner | |
| `rowMarginTop`, `rowMarginBottom` | `number` | `0` | |
| `eventHeight` | `number` | `35` | Eine Stapelzeile |
| `eventMarginBottom` | `number` | `0` | |
| `rowFilterParentsAlwaysVisible` | `boolean` | `true` | |
| `rowSortingMode` | `'LeavesOnly' \| 'ParentsOnly' \| 'All'` | `'LeavesOnly'` | Von `rows.sort()` verwendet |
| `selectedRows` | `string[] \| number[]` | `[]` | |
| `cornerText`, `cornerHtml` | `string` | `''`, keiner | Zelle oben links |

### Ereignisse und Bearbeitung
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `events` | `EventData[]` | `[]` | Kontrollierte Daten; das Array wird übernommen und direkt per splice verändert |
| `defaultEvents` | `EventData[]` | keiner | Unkontrollierte Anfangsdaten, einmal gelesen |
| `eventMoveHandling`, `eventResizeHandling` | `'Update' \| 'Notify' \| 'Disabled'` | `'Update'` | `'Disabled'` verhindert die Geste |
| `eventClickHandling` | `'Enabled' \| 'Select' \| 'ContextMenu' \| 'Bubble' \| 'Disabled'` | `'Enabled'` | `'Select'` schaltet die Auswahl um |
| `eventDoubleClickHandling` | dieselben Werte | `'Disabled'` | Ein Doppelklick-Handler verzögert einfache Klicks um `doubleClickTimeout` (`300`) |
| `eventRightClickHandling` | dieselben Werte | `'ContextMenu'` | |
| `eventSelectHandling` | `'Update' \| 'Disabled'` | `'Update'` | |
| `eventDeleteHandling` | `'Update' \| 'Disabled'` | `'Disabled'` | `'Update'` blendet beim Hovern eine Löschschaltfläche ein |
| `eventHoverHandling` | `'Bubble' \| 'Disabled'` | `'Bubble'` | Zeigt `bubbleHtml` |
| `eventTapAndHoldHandling` | `'Move' \| 'ContextMenu' \| 'Disabled'` | `'Move'` | Touch; `tapAndHoldTimeout` `300` |
| `allowEventOverlap` | `boolean` | `true` | `false` lehnt Verschiebungen, Dauer-Änderungen und Auswahlen auf belegte Zeit ab |
| `conflictHighlight` | `boolean` | `false` | Markiert kollidierende Ereignisse während des Ziehens |
| `useEventBoxes` | `'Always' \| 'Never' \| 'ShortEventsOnly'` | `'Always'` | `'Always'` zeichnet Ereignisse über ganze Zellen |
| `eventMoveByCell` | `boolean` | `false` | Mit `useEventBoxes: 'Never'` |
| `moveBy` | `'Full' \| 'Top' \| 'Left'` | `'Full'` | Bereich des Ziehgriffs |
| `eventMoveMargin`, `eventResizeMargin` | `number` | `5` | |
| `eventMoveSkipNonBusiness`, `eventMoveToPosition` | `boolean` | `false` | |
| `snapToGrid` (und `...EventMoving`, `...EventResizing`, `...TimeRangeSelecting`, `...RectangleSelecting`) | `boolean` | `true` | |
| `dragCard` | `boolean \| DragCardOptions` | `true` | Karte neben dem Zeiger während des Ziehens |
| `headerMarker`, `resizeHandles` | `boolean` | `true` | |
| `autoScroll` | `'Drag' \| 'Always' \| 'Disabled'` | `'Drag'` | `autoScrollSpeed` `50`, `autoScrollDelay` `100` |
| `dragOutAllowed` | `boolean` | `false` | Ereignisse auf Ablageziele ziehen |
| `floatingEvents` | `boolean` | `true` | Mitlaufende Beschriftungen der Ereignisse |
| `eventMinWidth` | `number` | `1` | |
| `eventBorderRadius`, `eventPadding` | `string \| number` | keiner | |
| `eventTextWrappingEnabled` | `boolean` | `false` | |
| `eventHtmlLeftMargin`, `eventHtmlRightMargin` | `number` | `10` | |
| `durationBarVisible` | `boolean` | `true` | `durationBarMode` `'Duration'` oder `'PercentComplete'`; `durationBarHeight` keiner |
| `eventStackingLineHeight` | `number` | `100` | |
| `showToolTip` | `boolean` | `true` | Native Tooltips aus `toolTip` |
| `eventMovingStartEndEnabled`, `eventResizingStartEndEnabled`, `timeRangeSelectingStartEndEnabled` | `boolean` | `false` | Beschriftungen neben dem Schatten, Format `'MMMM d, yyyy'` |
| `crosshairType` | `'Header' \| 'Full' \| 'Disabled'` | `'Header'` | |
| `xssProtection` | `'Enabled' \| 'Disabled'` | `'Enabled'` | Escaped `text`; `html` wird nie escaped |

### Auswahl
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `timeRangeSelectedHandling` | `'Enabled' \| 'Hold' \| 'HoldForever' \| 'Disabled'` | `'Enabled'` | Klicks und Ziehen auf leeren Zellen; `'HoldForever'` behält die Auswahl, wenn der Nutzer an anderer Stelle klickt |
| `timeRangeClickHandling` | `'Enabled' \| 'Disabled'` | `'Enabled'` | Klicks auf einen ausgewählten Zeitraum |
| `timeRangeDoubleClickHandling` | `'Enabled' \| 'Disabled'` | `'Disabled'` | |
| `timeRangeRightClickHandling` | `'ContextMenu' \| 'Enabled' \| 'Disabled'` | `'ContextMenu'` | |
| `allowMultiRange`, `multiRangeMode` | `boolean`, `'CtrlOrMeta' \| 'Always'` | `false`, `'CtrlOrMeta'` | Mehrere Zeiträume |
| `allowMultiSelect` | `boolean` | `true` | Mehrere ausgewählte Ereignisse |
| `eventMultiSelectRange` | `boolean` | `false` | Umschalt+Klick wählt einen Block aus |
| `rectangleSelectHandling` | `'Disabled' \| 'Enabled' \| 'EventSelect'` | `'Disabled'` | |
| `rectangleSelectMode`, `rectangleSelectModifiers` | `'Free' \| 'Row'`, `boolean` | `'Free'`, `false` | |
| `allowMultiMove`, `allowMultiResize` | `boolean` | `false` | `multiMoveVerticalMode` `'Disabled'` |
| `rowClickHandling` | `'Enabled' \| 'Select' \| 'Disabled'` | `'Enabled'` | |
| `rowDoubleClickHandling` | `'Enabled' \| 'Select' \| 'Disabled'` | `'Disabled'` | |
| `rowRightClickHandling` | `'ContextMenu' \| 'Enabled' \| 'Disabled'` | `'ContextMenu'` | |
| `rowSelectHandling` | `'Update' \| 'Notify'` | `'Update'` | |
| `timeHeaderClickHandling` | `'Enabled' \| 'Disabled'` | `'Enabled'` | |
| `resourceExpandHandling`, `resourceCollapseHandling` | `'Enabled'` | `'Enabled'` | |

### Zoom und Detailstufe
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `zoomLevels` | `ZoomLevel[]` | `[]` | |
| `zoom` | `number \| string` | keiner | Anfangsstufe: Index oder `id` |
| `zoomPosition` | `'left' \| 'middle' \| 'right'` | `'left'` | Bleibt bei Stufenwechseln an Ort und Stelle |
| `zoomGesture` | `boolean \| ZoomGestureOptions` | `true` | Ctrl oder Cmd + Mausrad, Pinch; Optionen `min`, `max` (`400`), `wheel` (`'ctrl'`), `pinch` (`true`), `sensitivity` (`1`), `scales` (`'zoomLevels'`), `link` |
| `lod` | `boolean \| LodOptions` | `true` | Adaptive Detailstufe |

### Größe und Layout
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `height` | `number \| '100%'` | `600` | Gesamthöhe, Köpfe eingeschlossen |
| `heightSpec` | `'Max' \| 'Fixed' \| 'Auto' \| 'Parent100Pct' \| 'Max100Pct'` | `'Max'` | `'Max'`: Höhe des Inhalts bis `height` |
| `width` | `number` | keiner | Füllt den Host |
| `visible` | `boolean` | `true` | |

### Erscheinungsbild
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `colorScheme` | `'inherit' \| 'light' \| 'dark' \| 'auto'` | `'inherit'` | Nur `'auto'` folgt der Einstellung des Betriebssystems |
| `density` | `'comfortable' \| 'compact' \| 'dense'` | keiner | |
| `classNames`, `styles` | pro Slot (`root`, `event`, `cell`, `rowHeader`, ...) | `{}` | Klassen oder Inline-Styles |
| `cssClass` | `string` | keiner | Zusätzliche Klasse an der Wurzel |
| `unstyled` | `boolean` | `false` | Nur Struktur |
| `theme` | `string` | keiner | Fügt Klassen `{theme}_*` hinzu |
| `nowLine` | `boolean \| { interval, label, cssClass }` | `false` | Intervall `60000` ms |
| `emptyState`, `errorState` | `ReactNode \| Node` | keiner | Ein String wird als Text angezeigt |
| `loading` | `boolean` | keiner | `loadingLabelText` `'Loading...'`, `loadingLabelVisible` `true` |
| `messageHideAfter`, `messageHideOnMouseOut`, `messageBarPosition` | `number`, `boolean`, `'Top' \| 'Bottom'` | `5000`, `true`, `'Top'` | Für `control.message()` |

### Verknüpfungen
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `links` | `LinkData[]` | `[]` | Aus Daten gezeichnet |
| `linkShape` | `'Curved' \| 'RightAngled'` | `'Curved'` | |
| `linkLayer` | `'Above' \| 'Below'` | `'Above'` | |
| `linkWidth` | `'Auto' \| number` | `'Auto'` | |
| `linkBottomMargin` | `number` | `17` | |

### Tastatur
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `keyboardEnabled` | `boolean` | `false` | |
| `keyboardTarget` | `'document' \| 'component'` | `'document'` | |
| `keyboardMode` | `'SuperScheduler' \| 'Full'` | `'SuperScheduler'` | `'Full'` erfordert `keyboardEnabled` |
| `keyboardOptions` | `{ pageRows, contextMenuKey, bubbleOnFocus, selectAll, zoomKeys }` | keiner | `zoomKeys` ist standardmäßig `false` |

### Menüs und Bubbles
| Option | Typ | Standard |
|---|---|---|
| `contextMenu`, `contextMenuResource`, `contextMenuSelection`, `contextMenuLink` | `SuperScheduler.Menu` | keiner |
| `bubble` | `SuperScheduler.Bubble` | eine Bubble, die `bubbleHtml` zeigt |
| `cellBubble`, `resourceBubble`, `linkBubble` | `SuperScheduler.Bubble` | keiner |
| `allowDefaultContextMenu` | `boolean` | `false` |

### Daten, Laden und Erweiterungen
| Option | Typ | Standard | Hinweise |
|---|---|---|---|
| `extensions` | `SchedulerExtension[]` | keiner | Range-Loader, Verläufe |
| `history` | Verlaufsobjekt | keiner | Kurzform für eine einzelne Verlaufserweiterung |
| `dynamicLoading` | `boolean` | `false` | Mit `onScroll` |
| `scrollDelayDynamic` | `number` | `500` | Ruhezeit vor `onScroll` |

### React-Inhalte
Nur mit `SuperSchedulerComponent` aus `super-scheduler/react-render`:

| Prop | Argumente | Rückgabe |
|---|---|---|
| `renderEvent` | `{ control, e, data, row, width, lod }` | `ReactNode` |
| `renderCell` | `{ control, cell }` | `ReactNode` |
| `renderRowHeader` | `{ control, row, column }` | `ReactNode` |
| `renderTimeHeader` | `{ control, header }` | `ReactNode` |
| `renderArea` | `{ control, area, source }` (Bereiche mit `render: true`) | `ReactNode` |
| `renderCorner` | `{ control }` | `ReactNode` |
| `eventHover` | `{ render, delay (350), leaveGrace (180), placement ('auto'), pin (false), glide (true) }` | |
| `renderOptions` | `{ retain, sliceMs (8) }` | |

## Callbacks
### Konventionen
- **Davor und danach.** `onEventMove` läuft vor einer Änderung und kann sie abbrechen; `onEventMoved` läuft danach. Die meisten Paare folgen diesem Muster.
- **Abbrechen.** Handler, deren Argumente `preventDefault()` haben, können abbrechen: die Klick-Familie, `onEventSelect`, `onEventDelete`, `onEventMove`, `onEventResize`, `onTimeRangeSelect`, `onTimeRangeClick` und seine Varianten für Doppel- und Rechtsklick, `onRectangleSelect`, `onRowClick` und Varianten, `onRowSelect`, `onResourceExpand`, `onResourceCollapse`, `onTimeHeaderClick`, `onTimeHeaderRightClick`, `onGridMouseDown`, `onKeyDown`, `onKeyboardFocusChange` und `onLinkClick`. Wer einen Klick abbricht, überspringt auch den zugehörigen „-ed“-Handler und die Folgeaktion.
- **Asynchrone Bestätigung.** `onEventMove` und `onEventResize` unterstützen `args.async = true` und ein späteres `args.loaded()`; `preventDefault()` vor `loaded()` bricht ab, und `newStart`, `newEnd` und `newResource`, die vor `loaded()` gesetzt werden, werden angewendet.
- **Steuern.** `onEventMoving`, `onEventResizing`, `onTimeRangeSelecting` und `onRectangleSelecting` laufen bei jeder Änderung des Schattens; weisen Sie `args.allowed`, `args.start`, `args.end`, `args.cssClass` oder `args.html` zu.

### Ereignisse
| Handler | Argumente | Abbruch |
|---|---|---|
| `onEventClick`, `onEventClicked` | `{ e, div, control, originalEvent, ctrl, shift, meta }` | erster |
| `onEventDoubleClick`, `onEventDoubleClicked` | `{ e, originalEvent }` | erster |
| `onEventRightClick`, `onEventRightClicked` | `{ e, div, originalEvent }` | erster |
| `onEventSelect`, `onEventSelected` | `{ e, selected, ctrl, meta }` | erster |
| `onEventDelete`, `onEventDeleted` | `{ e, control }` | erster |
| `onEventMouseEnter`, `onEventMouseLeave` | `{ e, div }` | nein |
| `onEventFilter` | `{ e, filterParam, visible }`; setzen Sie `visible = false` | nein |
| `onEventsChange` | `{ events, changed, removed, reason }`, `reason` ist einer von `'move'`, `'resize'`, `'create'`, `'remove'`, `'update'`, `'api'`, `'history'`, `'load'` | nein |

`e` ist ein `SuperScheduler.Event`: `e.data` ist das Datenobjekt, und `e.id()`, `e.start()`, `e.end()`, `e.text()`, `e.resource()` und `e.duration()` lesen es.

### Ziehen und Dauer ändern
| Handler | Argumente | Abbruch und asynchron |
|---|---|---|
| `onEventMoving` | `{ e, start, end, duration, resource, row, allowed, allowOverlap, conflicts, message, cssClass, html, external, multimove, left, right, ctrl, shift, alt, meta }` | steuern mit `allowed` |
| `onEventMove` | `{ e, newStart, newEnd, newResource, external, multimove, control, position, async, loaded() }` | `preventDefault()`, asynchron |
| `onEventMoved` | dieselben Werte, nur lesend; der Speicher enthält bereits die neuen Zeiten | nein |
| `onEventResizing` | `{ e, start, end, what, row, allowed, allowOverlap, conflicts, message, ... }` | steuern mit `allowed` |
| `onEventResize` | `{ e, newStart, newEnd, what, multiresize, control, async, loaded() }` | `preventDefault()`, asynchron |
| `onEventResized` | dieselben Werte, nur lesend | nein |

### Zeiträume und Rechtecke
| Handler | Argumente | Abbruch |
|---|---|---|
| `onTimeRangeSelecting` | `{ start, end, anchor, duration, resource, row, allowed, overlapping, ignoreDisabledCells, html, cssClass, button }` | steuern mit `allowed` |
| `onTimeRangeSelect`, `onTimeRangeSelected` | `{ start, end, resource, control, origin, multirange }`, `origin` ist einer von `'click'`, `'drag'`, `'keyboard'`, `'api'` | erster |
| `onTimeRangeClick`, `onTimeRangeDoubleClick`, `onTimeRangeRightClick` (und „-ed“) | `{ start, end, resource }`, auf einem bereits ausgewählten Zeitraum | erster |
| `onRectangleSelecting` | `{ events, start, end, resources, visible }` | steuern mit `visible` |
| `onRectangleSelect` | `{ events, start, end, resources, append }` | ja |
| `onRectangleSelected` | `{ events }` | nein |
| `onGridMouseDown` | `{ action, originalEvent, button, ctrl, shift, meta }`; setzen Sie `action = 'None'` | ja |

### Zeilen und Köpfe
| Handler | Argumente | Abbruch |
|---|---|---|
| `onRowClick`, `onRowDoubleClick`, `onRowRightClick` (und „-ed“) | `{ row, x, originalEvent, ctrl, shift, meta }` | erster |
| `onRowSelect`, `onRowSelected` | `{ row, selected, ctrl, shift, meta }` | erster |
| `onRowFilter` | `{ row, filterParam, visible, control }` | nein |
| `onRowMouseOver`, `onRowMouseOut` | `{ row, div }` | nein |
| `onResourceExpand`, `onResourceCollapse` | `{ resource }` | ja |
| `onRowHeaderResized`, `onRowHeaderColumnResized` | `{}`, `{ column }` | nein |
| `onRowHeaderColumnsChange` | `{ control, columns, order, widths, reason }` | nein |
| `onRowSorted` | `{ oldSortParam }` | nein |
| `onTimeHeaderClick`, `onTimeHeaderClicked` | `{ header: { start, end, level }, control, originalEvent, ctrl, shift, meta }` | erster |
| `onTimeHeaderRightClick`, `onTimeHeaderRightClicked` | `{ header }` | erster |
| `onCellMouseEnter`, `onCellMouseLeave` | `{ cell }` | nein |

### Render-Hooks
| Handler | Argumente | Änderbar |
|---|---|---|
| `onBeforeEventRender` | `{ control, data }` | `data.backColor`, `fontColor`, `cssClass`, `html`, `areas`, `toolTip`, `height`, `hidden`... (eine Kopie; `start` und `end` sind `SuperScheduler.Date`) |
| `onBeforeCellRender` | `{ control, cell, getPixels(date) }` | `cell.properties.backColor`, `cssClass`, `html`, `text`, `disabled`, `areas`, `bubbleHtml` |
| `onBeforeRowHeaderRender` | `{ row }` | `row.html`, `text`, `cssClass`, `backColor`, `areas`, `columns[i].html` |
| `onBeforeResHeaderRender` | `{ resource }` | Eine Kopie der Ressource, Layoutfelder eingeschlossen |
| `onBeforeRowHeaderColumnRender` | `{ column }` | `html` des Spaltentitels, `cssClass`, `areas` |
| `onBeforeTimeHeaderRender` | `{ control, header }` | `header.html`, `text`, `cssClass`, `backColor`, `toolTip`, `areas` |
| `onBeforeCornerRender` | `{ control, html, areas }` | Inhalt der Ecke |
| `onBeforeLinkRender` | `{ data, from, to }` | Farbe, Breite und Stil der Verknüpfung, `cssClass` |
| `onIncludeTimeCell` | `{ cell: { start, end, visible, width } }` | Zellen der Zeitleiste ausblenden oder in der Größe ändern |
| `onAfterEventRender`, `onAfterCellRender` | `{ e, div }`, `{ cell, div }` | Der gezeichnete Knoten |
| `onAfterRender`, `onAfterUpdate`, `onDimensionsChanged` | | Benachrichtigungen zum Lebenszyklus |

### Weitere Handler
| Handler | Argumente |
|---|---|
| `onZoom` | `{ control, cellWidth, scale, cellDuration, phase, origin, anchor, viewportStart, level, lod }`, in jedem Frame einer Geste |
| `onHistoryChange` | `{ canUndo, canRedo, undoLabel, redoLabel, cause }` |
| `onScroll` | `{ viewport, async, events, remove, clearEvents, loaded() }`, mit `dynamicLoading` |
| `onKeyDown` | `{ originalEvent }`, abbrechbar |
| `onKeyboardFocusChange`, `onKeyboardFocusChanged` | `{ previous, focus }` |
| `onLinkClick`, `onLinkClicked` | `{ link, originalEvent }`, `{ link }` |

## Control-API
Das Control ist `ref.current.control`, der Wert von `controlRef`, `args.control` in den meisten Handlern oder `new SuperScheduler.Scheduler(element, options)`, gefolgt von `init()`.

### Lebenszyklus und Anzeige
| Mitglied | Beschreibung |
|---|---|
| `init()` | Bei imperativen Controls einmal erforderlich; `update()` vor `init()` wirft einen Fehler |
| `update(options?)` | Wendet Optionen an und zeichnet synchron neu; ohne Argumente eine vollständige Aktualisierung |
| `dispose()`, `disposed()` | Abbau und dessen Zustand |
| `show()`, `hide()`, `setHeight(px)` | Sichtbarkeit; `setHeight` wechselt zu `heightSpec: 'Fixed'` |
| `message(text, delayOrOptions?)` | Meldungsleiste im Control |
| `loadingStart(options?)`, `loadingStop()` | Ladebeschriftung |
| `clearSelection()` | Hebt die Zeitraumauswahl auf |
| `dragInProgress()` | `true` während einer Geste |
| `levelOfDetail` | Aktueller Zustand der Detailstufe |
| `history` | Der angebundene Verlauf oder `null` |
| `moveRowHeaderColumn(from, to)` | Ordnet Spalten des Zeilenkopfs neu |
| `nav` | Die Elemente `top`, `scroll`, `corner`, `timeHeader`, `message` und `loading` (`null` vor `init()`) |
| `v` | Versions-String |

### Scrollen und sichtbarer Bereich
| Mitglied | Beschreibung |
|---|---|
| `scrollTo(date \| px, animated?, position?)` | `animated`: `boolean`, ms, `'fast'`, `'normal'`, `'slow'` oder `'linear'`; `position`: `'left'`, `'middle'`, `'right'` |
| `scrollToResource(id \| row)` | |
| `setScroll(x, y)`, `setScrollX(x)`, `setScrollY(y)`, `getScrollX()`, `getScrollY()` | Scrollen in Pixeln |
| `getViewPort()` | `{ start, end, resources, rows(), events() }` des sichtbaren Bereichs |
| `visibleStart()`, `visibleEnd()` | Anfang und Ende der Zeitleiste, nicht des sichtbaren Bereichs |
| `getDate(px, precise?, isEnd?)`, `getCoords()` | Zuordnung von Pixeln und Zeiger |
| `infinite.scrollTo(date)`, `infinite.shiftStart(days)` | Unendliches Scrollen |

### Ereignisse
| Mitglied | Beschreibung |
|---|---|
| `events.list` | Das Daten-Array, per Referenz |
| `events.add(event)` | Wirft bei einer doppelten ID |
| `events.update(event)` | Ersetzt ein geladenes Ereignis; bewirkt nichts bei einer unbekannten ID |
| `events.remove(event \| id)` | |
| `events.find(id \| predicate)`, `events.findAll(predicate \| example)` | Suchen, die `SuperScheduler.Event` zurückgeben |
| `events.all()`, `events.forRange(start?, end?)` | Alle Ereignisse oder jene, die sich mit einem Zeitraum überschneiden (standardmäßig der sichtbare) |
| `events.filter(param)` | Führt `onEventFilter` aus |
| `events.scrollIntoView(event)` | |

### Zeilen
| Mitglied | Beschreibung |
|---|---|
| `rows.add(data)`, `rows.addChild(parent, data)`, `rows.update(row \| data)`, `rows.remove(row \| id)` | Änderungen an Zeilen |
| `rows.find(id \| predicate)`, `rows.all()`, `rows.visible()`, `rows.each(fn)` | Suchen, die `SuperScheduler.Row` zurückgeben |
| `rows.expand(level?)`, `rows.expandAll()`, `rows.collapseAll()` | Zustand des Baums |
| `rows.filter(param)` | Führt `onRowFilter` aus |
| `rows.sort(spec?)`, `rows.sortParam` | Sortierung (`{ field, order }`) |
| `rows.selection.add/remove/clear/get/isSelected` | Zeilenauswahl |

### Auswahl
| Mitglied | Beschreibung |
|---|---|
| `multiselect.add/remove/clear/get/events/isSelected/redraw` | Auswahl von Ereignissen |
| `multiselect.selectAll({ scope, filter })` | `scope` `'view'` (Standard) oder `'all'` |
| `multiselect.startRectangle()` | Aktiviert die Rechteckauswahl |
| `multirange.add(selection)`, `multirange.get()`, `multirange.clear()` | Zeiträume (`new SuperScheduler.Selection(start, end, resource)`) |
| `selectTimeRange(start, end, resource, dontFireEvent?)` | Wählt einen Zeitraum aus |

### Zoom, Verknüpfungen, Zellen und Tastatur
| Mitglied | Beschreibung |
|---|---|
| `zoom.active` | Index der aktiven Stufe (`-1`, solange keine aktiv ist) |
| `zoom.setActive(level, position?, anchorDate?)` | Wendet eine Stufe sofort an |
| `zoom.animateTo({ level } \| { cellWidth }, { duration (300), position, anchorDate })` | Animiert; gibt ein Promise zurück |
| `zoom.step(delta, options?)` | Eine Stufe oder, ohne Stufen, ein Faktor von 1,6 |
| `links.list`, `links.add`, `links.update`, `links.remove`, `links.find`, `links.findByFromTo`, `links.findAllByFromTo` | Verknüpfungen |
| `cells.all()`, `cells.find(start, resource)`, `cells.findXy(x, y)`, `cells.findByPixels(x, y)` | Gemountete Zellen |
| `keyboard.focusCell`, `focusEvent`, `getFocus`, `move`, `clearFocus`, `resetFocus` | Tastaturfokus |

### Statische Mitglieder
| Mitglied | Beschreibung |
|---|---|
| `SuperScheduler.Scheduler.makeDraggable({ element, data, duration, ... })` | DOM-Elemente als neue Ereignisse ins Raster ziehen |
| `SuperScheduler.Scheduler.registerDropTarget({ element, onDrop, ... })` | Ereignisse außerhalb des Rasters ablegen (mit `dragOutAllowed`) |
| `SuperScheduler.Scheduler.startDragging(options)`, `stopDragging()` | Programmatisches Ziehen von außen |

## Der Namespace SuperScheduler
| Mitglied | Beschreibung |
|---|---|
| `Date` | Datum und Uhrzeit in bürgerlicher Zeit: `today()`, `now()`, `parse(text, pattern, locale?)`, `fromYearMonthDay()`, `add*()`, `firstDayOf*()`, `getDatePart()`, `getDay()` (Tag des Monats), `getDayOfWeek()`, `dayOfWeekISO()`, `weekNumberISO()`, `toString(pattern?, locale?)`, `toDate()`, `toDateLocal()`, `value`, `ticks`, `equals()` |
| `Duration` | Zeitspanne in Millisekunden: `ofDays()`, `ofHours()`, `ofMinutes()`, `totalHours()`, `toString(pattern?)` |
| `Event` | Wrapper für Ereignisse (`data`, `id()`, `start()`, `end()`, `text()`, `resource()`, `duration()`) |
| `Locale` | `register(locale)`, `find(id)`, `new Locale(id, fields)` |
| `Menu`, `Bubble` | Kontextmenüs und Hover-Bubbles (`show()`, `hide()`) |
| `Selection` | `new Selection(start, end, resource?)` |
| `Util` | `escapeHtml(text)`, `overlaps(start1, end1, start2, end2)` (halboffen) |
| `ColorUtil` | `darker()`, `lighter()`, `contrasting()` |
| `Exception` | Wird bei falscher Verwendung der API geworfen |
| `guid()` | Zufällige UUID v4 |
| `Row`, `RenderRow`, `Link` | Vom Control erzeugt; lesen Sie sie in Handlern |

## Subpath-Module
### history
`createHistory(options?)` gibt einen Verlauf zurück, den Sie als `history={history}` oder in `extensions` übergeben. Optionen: `limit` (`50`), `record` (`['move', 'resize']`), `keys` (`'root'`, `'document'` oder `false`; Standard `'root'`), `equals`, `fields`, `apply` (`'control'` oder eine Funktion für kontrollierte Ereignisse) und `labels`. Methoden: `undo()`, `redo()`, `clear()`, `push({ label, undo, redo })`, `record({ ops, control })`, `batch(label, run)`, `revert(eventId)`, `subscribe(listener)`; Eigenschaften `canUndo`, `canRedo`, `undoLabel`, `redoLabel`. Ladevorgänge und abgelehnte Änderungen werden nicht aufgezeichnet.

### minimap
`createMinimap(control, container, options?)` und die React-Komponente `<SchedulerMinimap control={control} />`. Optionen: `series` (Standard `eventDensity(control)`), `height` (`28`), `peak` (`'relative'` oder `'absolute'` mit `max`), `tone`, `marks` (`today`, `months`, `past`, alle `true`), `range` und `labels`. Das Widget hat `update()`, `refresh()` und `dispose()`.

### panes
`<SchedulerPanes>` nimmt die Props des Planers plus `panes` (`{ id, resources or rowFilter, size, minSize (48), hidden, props }`), eine erforderliche numerische `height`, `timeHeader` (`'first'`), `scrollbar` (`'last'`), `splitter` (`true`), `crossPaneMove` (`true`), `component`, `onPaneResize` und `panesRef`. `linkPanes(controls, { zoom, rowHeaderWidth })` koppelt vorhandene Controls und gibt `{ dispose() }` zurück.

### zoom-ui
`createZoomHud(control, { format, apiMs (700) })`, `createZoomSlider(control, container, { min, max, detents, scale ('log'), label })` und `createLodBadge(control, container, labels?)`. Jede Funktion gibt `{ element, dispose() }` zurück.

### views
`getViewState(control, include?)` gibt einen JSON-tauglichen Zustand zurück (`zoom`, `scroll`, `density`, `collapsed`, `columns`); `applyViewState(control, state, { animate, when, timeout })` (`when` ist `'now'` oder `'rows'`) gibt ein Promise auf einen `boolean` zurück.

### ranges
`createRangeLoader({ load, chunkDays (7), prefetch (1), cacheChunks (26), skeleton (true), onError })` gibt einen Loader mit `reload(range?)`, `clear()` und `loading` zurück. `load({ start, end, signal })` gibt die Ereignisse zurück, die sich mit `[start, end)` überschneiden.

### hooks
`useScheduler({ track })` gibt `{ controlRef, control, state }` für die Themen `'events'`, `'selection'`, `'zoom'`, `'viewport'` und `'history'` zurück. `useSchedulerState(control, topic)`, `subscribeScheduler(control, topic, listener)` (gibt eine Funktion zum Abmelden zurück) und `getSchedulerSnapshot(control, topic)` liefern denselben Zustand außerhalb des Hooks. Der Zustand des sichtbaren Bereichs wird veröffentlicht, nachdem sich das Scrollen gesetzt hat.

### react-render
`SuperSchedulerComponent` mit den [Props für React-Inhalte](#options-react-render). Der HTML- oder Text-Fallback wird zuerst gezeichnet; React-Inhalte ersetzen ihn nach dem Ende der Interaktion. `renderOptions.retain` ist standardmäßig der kleinere Wert von 2.000 oder dem Doppelten der gemounteten Elemente; `sliceMs` ist standardmäßig `8`.

### tailwind
Ein Preset für Tailwind CSS v3: `presets: [require('super-scheduler/tailwind')]`. Es ergänzt `super-scheduler`-Farben, -Radien, -Schatten und -Übergänge, die auf die CSS-Tokens abgebildet sind.

### datasets
`generateDataset(options)` und `generateScenario(id, overrides?)` erzeugen deterministische Daten im Hotelstil (`rows` und `days` erforderlich, `seed`, `start` in Ticks, `density`, `events`, `times`). `toSuperSchedulerData(dataset)` gibt `{ resources, events }` zurück. Szenarien: `S1` (120 Zeilen, 730 Tage), `S2` (1.000 Zeilen, 730 Tage), `S3` (5.000 Zeilen, 1.500 Tage) und ihre dichten Varianten. Die Daten beginnen standardmäßig am 2026-01-01.

### core
DOM-freie Hilfsfunktionen, die die Engine nutzt: `SchedulerDate`, `Duration`, `registerLocale`, `resolveLocale`, `formatTicks`, `parseTicks`, `ticksFromParts(year, month, day, ...)`, `partsOf`, `formatIso`, `parseIso`, `todayTicks`, `nowTicks`, die Konstanten `MS_PER_*` sowie Hilfsmittel für Zeitleisten, Indizes und Layout. Verwenden Sie sie für Diagramme und Werkzeuge neben dem Planer.

## Lite-API
`super-scheduler-lite` ist eine schreibgeschützte Tageszeitleiste. Optionen, die es nicht implementiert, werfen `SuperScheduler Lite: unsupported option "..."`, in jedem Build.

| Option | Typ | Standard |
|---|---|---|
| `startDate` | `DateInput` | heute |
| `days` | `number` (ganzzahlig) | `31` |
| `scale` | `'Day'` | `'Day'` |
| `cellWidth` | `number` | `64` |
| `height` | `number` | `400` |
| `rowHeaderWidth` | `number` | `160` |
| `rowMinHeight` | `number` | `40` |
| `eventHeight` | `number` | `26` |
| `resources` | `{ id, name }[]` (flach) | `[]` |
| `events` | `{ id, resource, start, end, text, backColor?, fontColor?, cssClass?, toolTip?, tags? }[]` | `[]` |
| `locale` | `string` | `'en-us'` |
| `ariaLabel` | `string` | `'Resource schedule'` |
| `emptyState` | `string` | `'No resources'` |
| `onEventClick` | `({ control, e: { data }, originalEvent }) => void` | keiner |
| `onTimeRangeClick` | `({ control, start, end, resource, originalEvent }) => void`, jede leere Zelle | keiner |
| `controlRef` | Ref-Objekt oder `(control \| null) => void` | keiner |

Das Control (`ref.current.control`) hat `init()`, `update(options)`, `dispose()`, `disposed()`, `scrollTo(date)`, `scrollToResource(id)`, `visibleStart()` und `visibleEnd()`. Der Namespace hat `SuperScheduler.Date` und `SuperScheduler.Scheduler`. Die Ressourcenfelder `children`, `frozen`, `split` und `columns` werden abgelehnt. Theme-Tokens auf `.super-scheduler-lite`: `--super-scheduler-background`, `-text`, `-border`, `-header`, `-event` und `-focus`. Siehe [Von Lite zu Pro migrieren](https://superscheduler.org/de/docs/migrate-lite-to-pro/).

## Reservierte APIs
Diese Mitglieder sind typisiert, damit bestehender Code kompiliert, aber sie sind in 0.1.0 nicht implementiert. Sie bewirken nichts, geben leere Werte zurück und geben in Entwicklungs-Builds einmal `super-scheduler: <feature> is not supported yet` aus.

| Bereich | Reserviert |
|---|---|
| Inline-Bearbeitung | `eventEditHandling`, `eventEditMinWidth`, `rowEditHandling`, `'Edit'`-Werte der Klick-Handlings, `events.edit()`, `rows.edit()`, `Row.edit()`, `onEventEdit`, `onEventEdited`, `onEventEditKeyDown`, `onRowEdit`, `onRowEdited`, `onAfterEventEditRender` |
| Zeilen anlegen und verschieben | `rowCreateHandling`, `rowCreateHeight`, `rowCreateHtml`, `rowCreateText`, `rowMoveHandling`, `rowMoveSameLevelOnly`, `rowDragHandleWidth`, `onRowCreate`, `onRowCreated`, `onRowMove`, `onRowMoved`, `onRowMoving`, `makeDraggableAsRow`, `registerRowDropTarget` |
| Interaktives Anlegen von Verknüpfungen | `linkCreateHandling`, `linkDotSize`, `linkPointSize`, `onLinkCreate`, `onLinkCreated` (Verknüpfungen werden aus den Daten in `links` gezeichnet) |
| Server-Roundtrips und Laden per HTTP | Handling-Werte und Menüaktionen `'CallBack'` und `'PostBack'`, `backendUrl`, `eventsLoadMethod`, `rowsLoadMethod`, `linksLoadMethod`, `events.load()`, `rows.load()`, `links.load()`, `blockOnCallBack`, `notifyCommit`, `clientState`, `onCallBackStart`, `onCallBackEnd`, `onLoadNode` |
| Automatisches Aktualisieren | `autoRefreshEnabled`, `autoRefreshInterval`, `autoRefreshMaxCount`, `autoRefreshCommand`, `autoRefreshPause()`, `autoRefreshStart()`, `onAutoRefresh` |
| Export | `exportAs()`, `exceljs`, `onBeforeEventExport`, `onBeforeCellExport`, `onBeforeRowHeaderExport`, `onBeforeTimeHeaderExport`, `onBeforeCornerExport` |
| Ereignisversionen und Gruppierung | `eventVersionsEnabled`, `eventVersionHeight`, `eventVersionMargin`, `eventVersionPosition`, `eventVersionsReserveSpace`, `groupConcurrentEvents`, `groupConcurrentEventsLimit`, `groupBubble`, `onBeforeGroupRender`, `row.groups` |
| Wiederholungen | `events.findRecurrent()` (gibt `null` zurück) |
| Ansichten und Layout | `viewType: 'Days'` und `'Gantt'` (werden als `'Resources'` gerendert), `layout`, `rowHeaderScrolling`, `rowHeaderColumnsMode`, `rowHeaderHideIconEnabled`, `rows.headerHide()`, `rows.headerShow()`, `rows.headerToggle()`, `timeHeaderTextWrappingEnabled`, `sortDirections`, `syncResourceTree` |
| Sonstiges | `api`, `eventBubbleShowForMargins`, `hideBorderFor100PctHeight`, `hideUntilInit`, `initEventEnabled`, `jointEventsMove`, `jointEventsResize`, `navigatorBackSync`, `overrideWheelScrolling`, `scrollStep`, `watchWidthChanges`, `range` und `range.all()` (verwenden Sie `multirange`), `events.focus()`, `uiBlock()`, `uiUnblock()`, `onBeforeGridLineRender`, `onResourceHeaderClick`, `onResourceHeaderClicked`, `SuperScheduler.Navigator`, `Row.column(i).html(value)`, `Bubble` `onDomAdd` und `onDomRemove` |

Teilweise implementiert:

- `treeAnimation` wird akzeptiert, aber die Aufklapp-Animation wird nie abgespielt.
- `eventClusters` und `onClusterClick` werden akzeptiert und haben noch keine sichtbare Wirkung.
- Die Handler `onBefore*DomAdd` und `onBefore*DomRemove`, die `render*`-Props und `eventHover` funktionieren nur mit der Komponente aus `super-scheduler/react-render`; die Wurzelkomponente warnt und ignoriert sie.

Akzeptierte Tuning-Hinweise, die ignoriert werden, weil die Virtualisierung immer aktiv ist und sich selbst abstimmt: `beforeCellRenderCaching`, `cellSweeping`, `cellSweepingCacheSize`, `drawBlankCells`, `dynamicEventRendering` mit seinen Rand- und Cache-Optionen, `eventUpdateInplaceOptimization`, `progressiveRowRendering`, `progressiveRowRenderingPreload` und die Optionen `scrollDelay*` außer `scrollDelayDynamic`.