@tensor_1/react 2.34.0 → 2.36.0

package/dist/components/SchedulingTimeGrid.js

@@ -39,6 +39,8 @@ const GridItem = memo(function GridItem2({ entry, segment, column, alone, name,
   ] });
   const shared = {
     className: "uix-scheduling-calendar__entry uix-scheduling-calendar__tg-item",
+    "data-highlight": entry.emphasis === "highlight" || void 0,
+    "data-dim": entry.emphasis === "dim" || void 0,
     "data-band": entry.band ?? "none",
     "data-status": status,
     "data-state": entry.state,
@@ -54,6 +56,7 @@ const GridItem = memo(function GridItem2({ entry, segment, column, alone, name,
     "button",
     {
       type: "button",
+      tabIndex: -1,
       ...shared,
       "data-item-id": entry.id,
       "aria-label": name,
@@ -101,6 +104,9 @@ function SchedulingTimeGrid({
   const [widthCap, setWidthCap] = useState(Infinity);
   const [ghost, setGhost] = useState(null);
   const [announcement, setAnnouncement] = useState("");
+  const [activeDay, setActiveDay] = useState(days[0]);
+  const enteredFrom = useRef(null);
+  const tabStop = days.includes(activeDay) ? activeDay : days[0];
   const moving = canMove && onProposeMove !== void 0;
   const step = Number.isFinite(givenStep) && givenStep > 0 ? givenStep : DEFAULT_STEP;
   const laneOptions = useMemo(() => ({ crossMidnightMinutes: topLaneCrossMidnightMinutes }), [topLaneCrossMidnightMinutes]);
@@ -334,6 +340,78 @@ function SchedulingTimeGrid({
     dragRef.current = null;
   }, []);
   const gridColumns = (span) => `${span.startCol + 2} / ${span.endCol + 3}`;
+  const headButton = (date) => rootRef.current?.querySelector(`.uix-scheduling-calendar__tg-dayhead[data-date="${date}"] [data-calendar-date]`) ?? null;
+  const dayRing = (date) => {
+    const root = rootRef.current;
+    const column = days.indexOf(date);
+    if (!root || column === -1) return [];
+    const covers = (element) => {
+      const [from, to] = element.style.gridColumn.split("/").map((part) => Number(part.trim()));
+      return from !== void 0 && to !== void 0 && from <= column + 2 && column + 2 < to;
+    };
+    const all = (selector) => Array.from(root.querySelectorAll(selector));
+    return [
+      ...all(".uix-scheduling-calendar__tg-strip > button.uix-scheduling-calendar__window").filter(covers),
+      ...all(".uix-scheduling-calendar__tg-top > button.uix-scheduling-calendar__tg-span").filter(covers),
+      ...all(`[data-tg-column="${date}"] > button[data-item-id]`),
+      ...all(`.uix-scheduling-calendar__tg-dayhead[data-date="${date}"] > button.uix-scheduling-calendar__more`),
+      // "+N windows" opens one day; it is reached from that day.
+      ...all(`.uix-scheduling-calendar__tg-strip > button.uix-scheduling-calendar__rowmore[data-more-date="${date}"]`)
+    ];
+  };
+  const dayOfItem = (item) => {
+    if (enteredFrom.current && dayRing(enteredFrom.current).includes(item)) return enteredFrom.current;
+    const inColumn = item.getAttribute("data-more-date") ?? item.closest("[data-tg-column]")?.getAttribute("data-tg-column") ?? item.closest("[data-date]")?.getAttribute("data-date");
+    if (inColumn) return inColumn;
+    const from = Number(item.style.gridColumn.split("/")[0]);
+    return Number.isFinite(from) ? days[Math.max(0, Math.min(days.length - 1, from - 2))] ?? null : days[days.length - 1] ?? null;
+  };
+  const onHeadKeyDown = (event, date) => {
+    const index = days.indexOf(date);
+    const target = event.key === "ArrowLeft" ? index - 1 : event.key === "ArrowRight" ? index + 1 : event.key === "Home" ? 0 : event.key === "End" ? days.length - 1 : null;
+    if (target !== null) {
+      event.preventDefault();
+      const next = days[Math.max(0, Math.min(days.length - 1, target))];
+      setActiveDay(next);
+      headButton(next)?.focus();
+    } else if (event.key === "Enter") {
+      const [first] = dayRing(date);
+      if (!first) return;
+      event.preventDefault();
+      enteredFrom.current = date;
+      first.focus();
+    }
+  };
+  const onGridKeyDown = (event) => {
+    const item = event.target;
+    if (event.defaultPrevented || event.shiftKey || item.hasAttribute("data-calendar-date") || !["ArrowDown", "ArrowUp", "Home", "End", "Escape"].includes(event.key)) return;
+    const date = dayOfItem(item);
+    if (!date) return;
+    const ring = dayRing(date);
+    const index = ring.indexOf(item);
+    if (index === -1) return;
+    event.preventDefault();
+    const to = event.key === "Escape" ? null : ring[Math.max(0, Math.min(ring.length - 1, event.key === "Home" ? 0 : event.key === "End" ? ring.length - 1 : index + (event.key === "ArrowDown" ? 1 : -1)))];
+    if (to !== item && ghost?.source === "keys") {
+      setGhost(null);
+      setAnnouncement(labels.moveCancelled);
+    }
+    if (event.key === "Escape") {
+      event.stopPropagation();
+      enteredFrom.current = null;
+      setActiveDay(date);
+      headButton(date)?.focus();
+      return;
+    }
+    enteredFrom.current = date;
+    to?.focus();
+  };
+  const onGridFocus = (event) => {
+    const item = event.target;
+    if (item.hasAttribute("data-calendar-date")) return;
+    const date = dayOfItem(item);
+    if (date && dayRing(date).includes(item)) setActiveDay(date);
+  };
   const nowAt = now === void 0 ? null : new Date(now).getTime();
   const nowColumn = nowAt === null || Number.isNaN(nowAt) ? -1 : days.indexOf(zonedDateKey(new Date(nowAt), timeZone));
   const topHiddenOn = (date) => top.hidden.filter((id) => {
@@ -358,6 +436,8 @@ function SchedulingTimeGrid({
       role: "group",
       "aria-label": gridLabel,
       style: vars({ "--uix-scheduling-calendar-days": days.length, "--uix-scheduling-calendar-hours": maxHours }),
+      onKeyDown: onGridKeyDown,
+      onFocus: onGridFocus,
       onClickCapture: (event) => {
         if (suppressClick.current) {
           suppressClick.current = false;
@@ -374,12 +454,25 @@ function SchedulingTimeGrid({
             const more = info ? info.overflowCount : hiddenIds.length;
             const moreText = fillLabel(labels.moreSpans, { count: more });
             const moreName = fillLabel(labels.moreEntriesLabel, { count: more, date: dateText(date, "day") });
-            const headName = info ? info.label ?? `${dateText(date, "day")}, ${fillLabel(labels.dayCount, { count: info.count })}` : dateText(date, "day");
+            const headName = !info ? dateText(date, "day") : info.label ? fillLabel(labels.dayName, { date: dateText(date, "day"), label: info.label }) : `${dateText(date, "day")}, ${fillLabel(labels.dayCount, { count: info.count })}`;
             return /* @__PURE__ */ jsxs("div", { className: "uix-scheduling-calendar__tg-dayhead", role: "group", "aria-label": headName, "data-date": date, children: [
-              /* @__PURE__ */ jsx("button", { type: "button", className: "uix-scheduling-calendar__date", "data-calendar-date": date, "aria-label": dateText(date, "day"), onClick: onSelectDate ? () => onSelectDate(date) : void 0, children: dateText(date, "column") }),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "uix-scheduling-calendar__date",
+                  "data-calendar-date": date,
+                  tabIndex: tabStop === date ? 0 : -1,
+                  "aria-label": info?.label ? fillLabel(labels.dayName, { date: dateText(date, "day"), label: info.label }) : dateText(date, "day"),
+                  onFocus: () => setActiveDay(date),
+                  onKeyDown: (event) => onHeadKeyDown(event, date),
+                  onClick: onSelectDate ? () => onSelectDate(date) : void 0,
+                  children: dateText(date, "column")
+                }
+              ),
               info && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__count", "aria-hidden": "true", children: info.count }),
               info?.markers && info.markers.length > 0 && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__markers", children: info.markers.map((marker) => /* @__PURE__ */ jsx("span", { children: renderMarker(marker, true) }, marker.id)) }),
-              more > 0 && (onShowMore ? /* @__PURE__ */ jsx("button", { type: "button", className: "uix-scheduling-calendar__more", "aria-label": moreName, onClick: () => onShowMore(date, hiddenIds.map((id) => entryById.get(id)).filter(Boolean)), children: moreText }) : /* @__PURE__ */ jsxs("span", { className: "uix-scheduling-calendar__more", children: [
+              more > 0 && (onShowMore ? /* @__PURE__ */ jsx("button", { type: "button", tabIndex: -1, className: "uix-scheduling-calendar__more", "aria-label": moreName, onClick: () => onShowMore(date, hiddenIds.map((id) => entryById.get(id)).filter(Boolean)), children: moreText }) : /* @__PURE__ */ jsxs("span", { className: "uix-scheduling-calendar__more", children: [
                 /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: moreText }),
                 /* @__PURE__ */ jsx("span", { className: "uix-visually-hidden", children: moreName })
               ] }))
@@ -394,6 +487,7 @@ function SchedulingTimeGrid({
               "button",
               {
                 type: "button",
+                tabIndex: -1,
                 className: "uix-scheduling-calendar__window",
                 "data-overlay-id": overlay.id,
                 "data-pattern": overlay.pattern ?? "solid",
@@ -413,7 +507,7 @@ function SchedulingTimeGrid({
               placed.id
             );
           }),
-          moreWindows > 0 && (onShowMore ? /* @__PURE__ */ jsx("button", { type: "button", className: "uix-scheduling-calendar__rowmore", "aria-label": fillLabel(labels.moreWindowsLabel, { count: moreWindows, date: dateText(firstHiddenWindowDay, "day") }), onClick: () => onShowMore(firstHiddenWindowDay, []), children: fillLabel(labels.moreWindows, { count: moreWindows }) }) : /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__rowmore", children: fillLabel(labels.moreWindows, { count: moreWindows }) }))
+          moreWindows > 0 && (onShowMore ? /* @__PURE__ */ jsx("button", { type: "button", tabIndex: -1, className: "uix-scheduling-calendar__rowmore", "data-more-date": firstHiddenWindowDay, "aria-label": fillLabel(labels.moreWindowsLabel, { count: moreWindows, date: dateText(firstHiddenWindowDay, "day") }), onClick: () => onShowMore(firstHiddenWindowDay, []), children: fillLabel(labels.moreWindows, { count: moreWindows }) }) : /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__rowmore", children: fillLabel(labels.moreWindows, { count: moreWindows }) }))
         ] }),
         (topLanes > 0 || ghostSpan) && /* @__PURE__ */ jsxs("div", { className: "uix-scheduling-calendar__tg-strip uix-scheduling-calendar__tg-top", role: "group", "aria-label": labels.topLane, style: vars({ "--uix-scheduling-calendar-lanes": Math.max(topLanes, 1) }), children: [
           top.placed.map((placed) => {
@@ -425,8 +519,11 @@ function SchedulingTimeGrid({
               "button",
               {
                 type: "button",
+                tabIndex: -1,
                 className: "uix-scheduling-calendar__entry uix-scheduling-calendar__tg-span",
                 "data-item-id": entry.id,
+                "data-highlight": entry.emphasis === "highlight" || void 0,
+                "data-dim": entry.emphasis === "dim" || void 0,
                 "data-band": entry.band ?? "none",
                 "data-status": entryStatus(entry),
                 "data-state": entry.state,

package/dist/components/SchedulingTimeline.d.ts

@@ -1,9 +1,9 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
+import { MoveProposal } from '../scheduling-calendar-model.js';
 import { TimelineRange, TimelineScale } from '../scheduling-timeline-model.js';
-import { j as SchedulingEntryState } from '../SchedulingCalendar-DSLQ6AY5.js';
+import { j as SchedulingEntryState, p as SchedulingStatus, a as SchedulingBand, l as SchedulingMarker, o as SchedulingOverlayPattern } from '../SchedulingCalendar-B6TakO2h.js';
 import '../calendar-model.js';
-import '../scheduling-calendar-model.js';
 
 interface SchedulingTimelineLane {
     id: string;
@@ -11,6 +11,25 @@ interface SchedulingTimelineLane {
     /** A quieter second line under the lane name (an owner, a count). */
     meta?: ReactNode;
 }
+/** A collapsible block of lanes. The consumer builds the groups and owns every number on them. */
+interface SchedulingTimelineGroup {
+    id: string;
+    label: ReactNode;
+    /** A quieter text beside the group name. */
+    meta?: ReactNode;
+    /** The lanes of the group, in the order to draw them. A lane named by two groups is drawn in the first. */
+    laneIds: string[];
+    /**
+     * A collapsed group is one row. With `onToggleGroup` the consumer owns this value; without
+     * it, it is where the group starts and the timeline opens and closes the group itself.
+     */
+    collapsed?: boolean;
+    /** Shown on the one row of a collapsed group. The timeline derives neither the count nor a marker. */
+    summary?: {
+        count: number;
+        markers?: SchedulingMarker[];
+    };
+}
 interface SchedulingTimelineItem {
     id: string;
     laneId: string;
@@ -18,34 +37,61 @@ interface SchedulingTimelineItem {
     /** ISO 8601 instants. */
     start: string;
     end: string;
+    /** @deprecated Use `band`, `status` and `markers`. The values keep working in 2.x; a bar is no longer tinted by them. */
     state?: SchedulingEntryState;
     meta?: string;
-    /** `false` keeps this bar fixed even when `onMoveItem` is set. */
+    /** `false` keeps this bar fixed even when a move or resize callback is set. */
     movable?: boolean;
+    /** The one dimension that takes a hue: only `high` is filled. */
+    band?: SchedulingBand;
+    /** Drawn as a line style, never as a hue. */
+    status?: SchedulingStatus;
+    /** Shapes or icons with text. The text is in the accessible name. */
+    markers?: SchedulingMarker[];
+    /** The complete accessible name, built by the consumer from its own words. Replaces `labels.item`. */
+    accessibleName?: string;
 }
+/** @deprecated Use `pattern` and `kindLabel` on the overlay. The values keep working in 2.x. */
 type SchedulingTimelineOverlayKind = 'freeze' | 'maintenance' | 'blackout';
 interface SchedulingTimelineOverlay {
     id: string;
+    /** The name of the window, shown as text. */
     label: string;
     start: string;
     end: string;
-    kind: SchedulingTimelineOverlayKind;
-    /** Only this lane; every lane when unset. */
+    /** @deprecated Use `pattern` and `kindLabel`. */
+    kind?: SchedulingTimelineOverlayKind;
+    /** Only this lane. For several lanes use `laneIds`. */
     laneId?: string;
+    /** Only these lanes; every lane when neither this nor `laneId` is set. The window is still one element. */
+    laneIds?: string[];
+    /** How the window is hatched. Windows are neutral: the pattern and the visible words tell them apart. */
+    pattern?: SchedulingOverlayPattern;
+    /** What kind of window this is, in the words of the consumer. Shown before the name. */
+    kindLabel?: string;
+    /** What the window applies to. Shown after the name. */
+    scopeLabel?: string;
+    /** The complete accessible name. Replaces `labels.overlay`. */
+    accessibleName?: string;
 }
 interface SchedulingTimelineMarker {
     id: string;
     label: string;
     /** ISO 8601 instant. */
     at: string;
+    /** Only this lane. For several lanes use `laneIds`. */
     laneId?: string;
+    /** Only these lanes; every lane when neither this nor `laneId` is set. */
+    laneIds?: string[];
 }
 interface SchedulingTimelineLabels {
     region: string;
     lanes: string;
-    /** `{title}`, `{state}`, `{start}`, `{end}`, `{conflict}`. */
+    /** The accessible name of a bar unless it sets `accessibleName`. `{title}`, `{state}`, `{start}`, `{end}`, `{conflict}`. Its marker labels are appended. */
     item: string;
+    /** Read after a bar that shares time with another bar of its lane, while `flagOverlaps` is on. */
     conflict: string;
+    /** The hint of a timeline that has both `onMoveItem` and `onResizeItem` (the older sentence). */
     moveHint: string;
     /** Announced after a move. `{title}`, `{start}`, `{end}`. */
     moved: string;
@@ -57,8 +103,30 @@ interface SchedulingTimelineLabels {
     /** Heading of the screen-reader list of windows and markers. */
     windows: string;
     now: string;
+    /** @deprecated The words of `item.state`. Use `status` on the item, named by `statuses`. */
     states: Record<SchedulingEntryState, string>;
+    /** @deprecated The words of `overlay.kind`. Use `kindLabel` on the overlay. */
     overlays: Record<SchedulingTimelineOverlayKind, string>;
+    /** The words for `status`, used in the default accessible name. */
+    statuses?: Partial<Record<SchedulingStatus, string>>;
+    /** The accessible name of a window that can be selected. `{title}` is its kind, name and scope. */
+    overlay?: string;
+    /** The hint of a bar that `onMoveItem` moves, one step a key press. */
+    moveKeysHint?: string;
+    /** The hint of a bar whose end `onResizeItem` moves. */
+    resizeHint?: string;
+    /** The hint of a bar that `onProposeMove` moves. */
+    proposeHint?: string;
+    /** Announced for a pending move. `{start}` and `{end}` placeholders. */
+    moveProposed?: string;
+    /** Announced when a pending move is dropped. */
+    moveCancelled?: string;
+    /** Announced when the time asked for does not exist that day. `{time}` is the time used instead. */
+    gapForward?: string;
+    /** The count on the row of a collapsed group. `{count}` is the number the consumer gave; the wording, plural forms included, is this label. */
+    groupSummary?: string;
+    /** Announced when a move was handed to `onProposeMove`. `{start}` and `{end}` placeholders. */
+    moveSent?: string;
 }
 declare const DEFAULT_SCHEDULING_TIMELINE_LABELS: SchedulingTimelineLabels;
 interface SchedulingTimelineProps {
@@ -71,7 +139,16 @@ interface SchedulingTimelineProps {
     /** IANA zone for tick boundaries and every printed time. */
     timeZone: string;
     locale?: string;
+    /**
+     * Collapsible blocks of lanes, in the order given. Lanes that no group names are drawn after
+     * the groups. Unset keeps the flat list of lanes.
+     */
+    groups?: SchedulingTimelineGroup[];
+    /** Called by a group head. When set, the consumer flips `collapsed`; nothing opens until the props say so. */
+    onToggleGroup?: (id: string) => void;
     overlays?: SchedulingTimelineOverlay[];
+    /** Makes each window a button. Called by a click or Enter on it. */
+    onSelectOverlay?: (overlay: SchedulingTimelineOverlay) => void;
     markers?: SchedulingTimelineMarker[];
     /** Draws a "now" line at this instant (pass the current time; the component keeps no clock). */
     now?: string;
@@ -81,18 +158,53 @@ interface SchedulingTimelineProps {
     tickWidth?: string;
     /** Move/resize granularity in ms. Defaults: 15 min (hour), 1 h (day), 1 day (week, month). */
     step?: number;
-    /** Tick label. Default: `Intl` in `locale` and `timeZone`. */
+    /** Local hours (0–23) that get a minor tick inside each day of a `day` axis, e.g. `[6, 12, 18]`. */
+    subTicks?: number[];
+    /** Tick label. Default: `Intl` in `locale` and `timeZone`. A sub-tick asks with the scale `'hour'`. */
     formatTick?: (at: Date, scale: TimelineScale) => string;
     /** Start/end text in names and announcements. Default: `Intl` medium date + short time in `timeZone`. */
     formatInstant?: (instant: string) => string;
-    /** Bar content. Default: the title. */
+    /** Bar content. Default: the title. The text is cut at a word, never in one. */
     renderItem?: (item: SchedulingTimelineItem) => ReactNode;
     onSelectItem?: (item: SchedulingTimelineItem) => void;
-    /** Makes bars draggable and keyboard-movable. Receives the snapped new start and end. */
+    /**
+     * Makes bars draggable and keyboard-movable, one call for every key press and every drop.
+     * Receives the snapped new start and end. Not called for moves while `onProposeMove` is set.
+     */
     onMoveItem?: (id: string, next: {
         start: string;
         end: string;
     }) => void;
+    /**
+     * Lets the user ask for a move: a drag, or Shift and an arrow key to build a pending move and
+     * Enter to send it (Escape drops it). Called once per finished gesture. The timeline never
+     * moves the bar: it draws items where the props say, so an item whose props do not change is
+     * back where it was. Return a promise to keep the outline until it settles.
+     */
+    onProposeMove?: (id: string, proposal: MoveProposal) => void | Promise<unknown>;
+    /** Lets Alt+Shift and an arrow key move the end of a bar. Without it there is no resize of any kind. */
+    onResizeItem?: (id: string, next: {
+        start: string;
+        end: string;
+    }) => void;
+    /**
+     * `false` keeps the stacking of bars that share time and drops the hatch and the words for
+     * it: the consumer says what clashes, with a reason, through `markers`. Default `true`.
+     */
+    flagOverlaps?: boolean;
+    /**
+     * Above this many rows only the rows near the viewport are mounted. The rows counted are
+     * the ones passed: `lanes` plus `groups`, whatever is collapsed and however the bars pack, so
+     * the answer does not move with the width. Default 150; `Infinity` mounts everything. It says
+     * when windowing starts, not how much is mounted: that is what the viewport shows, plus overscan.
+     */
+    virtualizeAbove?: number;
+    /** A CSS length. The lanes then scroll inside the timeline under the axis. Unset: the page scrolls. */
+    maxHeight?: string;
+    /** Shown above the axis, e.g. "Showing 500 of 1,240 items". */
+    notice?: ReactNode;
+    /** A note under the axis on the column of a day (`YYYY-MM-DD` in `timeZone`), e.g. a count the consumer knows. */
+    columnNotes?: Record<string, ReactNode>;
     loading?: boolean;
     error?: string;
     onRetry?: () => void;
@@ -100,11 +212,14 @@ interface SchedulingTimelineProps {
     className?: string;
 }
 /**
- * Lanes of bars on a time axis (HAR-1364; TENSOR C8): change schedules, rollout Gantt rows,
- * renewal markers. Overlapping bars in a lane stack and are hatched; freeze, maintenance and
- * blackout windows are bands; with `onMoveItem`, bars move by drag or Shift+arrows and their
- * end changes with Alt+Shift+arrows, snapped to `step`.
+ * Lanes of bars on a time axis (HAR-1364, HAR-1521): schedules by service, rollout rows,
+ * renewal markers. Lanes can sit in collapsible groups; bars that share time stack in sub-rows
+ * packed by `packLanes`; a window is one neutral, patterned element over the lanes it names;
+ * only `band="high"` takes a hue. With `onProposeMove` a move is a proposal handed to the
+ * consumer (drag, or Shift and an arrow key, then Enter); `onMoveItem` still commits every
+ * step; the end of a bar moves only with `onResizeItem`. Long timelines mount only the rows
+ * near the viewport.
  */
-declare function SchedulingTimeline({ lanes, items, range, scale, timeZone, locale, overlays, markers, now, weekStartsOn, tickWidth, step: stepProp, formatTick, formatInstant: formatInstantProp, renderItem, onSelectItem, onMoveItem, loading, error, onRetry, labels: labelOverrides, className, }: SchedulingTimelineProps): react.JSX.Element;
+declare function SchedulingTimeline({ lanes, items, range, scale, timeZone, locale, groups, onToggleGroup, overlays, onSelectOverlay, markers, now, weekStartsOn, tickWidth, step: stepProp, subTicks, formatTick, formatInstant: formatInstantProp, renderItem, onSelectItem, onMoveItem, onProposeMove, onResizeItem, flagOverlaps, virtualizeAbove, maxHeight, notice, columnNotes, loading, error, onRetry, labels: labelOverrides, className, }: SchedulingTimelineProps): react.JSX.Element;
 
-export { DEFAULT_SCHEDULING_TIMELINE_LABELS, SchedulingTimeline, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps };
+export { DEFAULT_SCHEDULING_TIMELINE_LABELS, SchedulingTimeline, type SchedulingTimelineGroup, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps };