@tensor_1/react 2.30.0 → 2.32.0

package/dist/components/RuleBuilder.js

@@ -7,10 +7,12 @@ import {
   mapRuleGroup,
   moveRuleNode,
   removeRuleNode,
+  setRuleCombinator,
   summarizeRule,
   validateRuleDefinition
 } from "../rule-builder-model.js";
 import { fillLabel } from "../fill-label.js";
+import { useUixLabels } from "../labels-context.js";
 const DEFAULT_RULE_BUILDER_LABELS = {
   region: "Rule builder",
   summary: "Rule summary",
@@ -40,7 +42,20 @@ const DEFAULT_RULE_BUILDER_LABELS = {
   summaryIssuesMany: "Rule has {count} validation issues.",
   addCondition: "Add condition",
   addGroup: "Add group",
-  addAction: "Add action"
+  addAction: "Add action",
+  issueDuplicateId: "Duplicate id \u201C{id}\u201D.",
+  issueMaxDepth: "Nesting exceeds {max} levels.",
+  issueEmptyGroup: "Add at least one condition.",
+  issueMissingField: "Choose a field.",
+  issueMissingOperator: "Choose an operator.",
+  issueNoActions: "Add at least one action.",
+  issueMissingActionType: "Choose an action.",
+  summarySentence: "When {conditions}, then {actions}.",
+  summarySentenceConditionsOnly: "When {conditions}.",
+  summaryNoConditions: "no conditions",
+  summaryNoActions: "no actions",
+  and: "AND",
+  or: "OR"
 };
 let ruleId = 0;
 const nextId = (prefix) => `${prefix}-${Date.now().toString(36)}-${(++ruleId).toString(36)}`;
@@ -49,28 +64,45 @@ function defaultCondition(fields, operators) {
   const operator = operators.find((item) => field?.operators?.includes(item.id)) ?? operators[0];
   return { id: nextId("condition"), field: field?.id ?? "", operator: operator?.id ?? "", value: "" };
 }
-function RuleGroupEditor({ group, depth, root, fields, operators, maxDepth, disabled, onRootChange, labels }) {
+function RuleGroupEditor({ group, depth, root, fields, operators, maxDepth, disabled, onRootChange, labels, combinator, hideCombinator, allowGroups }) {
   const updateNode = (id, update) => onRootChange(mapRuleGroup(root, id, update));
   const addCondition = () => onRootChange(appendRuleNode(root, group.id, defaultCondition(fields, operators), maxDepth));
   const addGroup = () => onRootChange(appendRuleNode(root, group.id, {
     id: nextId("group"),
-    combinator: "and",
+    combinator: combinator ?? "and",
     conditions: [defaultCondition(fields, operators)]
   }, maxDepth));
+  const rowControls = (node, index, label) => disabled ? null : /* @__PURE__ */ jsx(
+    RowControls,
+    {
+      labels,
+      label,
+      first: index === 0,
+      last: index === group.conditions.length - 1,
+      disabled: false,
+      onUp: () => onRootChange(moveRuleNode(root, node.id, -1)),
+      onDown: () => onRootChange(moveRuleNode(root, node.id, 1)),
+      onRemove: () => onRootChange(removeRuleNode(root, node.id))
+    }
+  );
   return /* @__PURE__ */ jsxs("fieldset", { className: "uix-rule-builder__group", "data-depth": depth, children: [
     /* @__PURE__ */ jsxs("legend", { className: "uix-rule-builder__group-heading", children: [
       /* @__PURE__ */ jsx("span", { children: depth === 1 ? labels.when : labels.group }),
-      /* @__PURE__ */ jsxs("label", { children: [
+      !hideCombinator && (combinator ? /* @__PURE__ */ jsxs("span", { className: "uix-rule-builder__match", children: [
+        labels.match,
+        " ",
+        combinator === "or" ? labels.any : labels.all
+      ] }) : /* @__PURE__ */ jsxs("label", { children: [
         labels.match,
         /* @__PURE__ */ jsxs("select", { className: "uix-select uix-select--sm", value: group.combinator, disabled, onChange: (event) => updateNode(group.id, (node) => ({ ...node, combinator: event.currentTarget.value })), children: [
           /* @__PURE__ */ jsx("option", { value: "and", children: labels.all }),
           /* @__PURE__ */ jsx("option", { value: "or", children: labels.any })
         ] })
-      ] })
+      ] }))
     ] }),
     /* @__PURE__ */ jsx("div", { className: "uix-rule-builder__rows", children: group.conditions.map((node, index) => isRuleGroup(node) ? /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__nested", children: [
-      /* @__PURE__ */ jsx(RuleGroupEditor, { ...{ group: node, depth: depth + 1, root, fields, operators, maxDepth, disabled, onRootChange, labels } }),
-      /* @__PURE__ */ jsx(RowControls, { labels, label: labels.itemGroup, first: index === 0, last: index === group.conditions.length - 1, disabled, onUp: () => onRootChange(moveRuleNode(root, node.id, -1)), onDown: () => onRootChange(moveRuleNode(root, node.id, 1)), onRemove: () => onRootChange(removeRuleNode(root, node.id)) })
+      /* @__PURE__ */ jsx(RuleGroupEditor, { ...{ group: node, depth: depth + 1, root, fields, operators, maxDepth, disabled, onRootChange, labels, combinator, hideCombinator, allowGroups } }),
+      rowControls(node, index, labels.itemGroup)
     ] }, node.id) : /* @__PURE__ */ jsx(
       ConditionRow,
       {
@@ -80,13 +112,13 @@ function RuleGroupEditor({ group, depth, root, fields, operators, maxDepth, disa
         operators,
         disabled,
         onChange: (condition) => updateNode(node.id, () => condition),
-        controls: /* @__PURE__ */ jsx(RowControls, { labels, label: labels.itemCondition, first: index === 0, last: index === group.conditions.length - 1, disabled, onUp: () => onRootChange(moveRuleNode(root, node.id, -1)), onDown: () => onRootChange(moveRuleNode(root, node.id, 1)), onRemove: () => onRootChange(removeRuleNode(root, node.id)) })
+        controls: rowControls(node, index, labels.itemCondition)
       },
       node.id
     )) }),
-    /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__add", children: [
-      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary uix-btn--sm", onClick: addCondition, disabled: disabled || fields.length === 0 || operators.length === 0, children: labels.addCondition }),
-      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: addGroup, disabled: disabled || depth >= maxDepth, children: labels.addGroup })
+    !disabled && /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__add", children: [
+      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary uix-btn--sm", onClick: addCondition, disabled: fields.length === 0 || operators.length === 0, children: labels.addCondition }),
+      allowGroups && /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: addGroup, disabled: depth >= maxDepth, children: labels.addGroup })
     ] })
   ] });
 }
@@ -124,9 +156,14 @@ function RuleBuilder({
   onChange,
   fields,
   operators,
-  actions,
+  actions = [],
   maxDepth = 3,
   readOnly = false,
+  conditionsOnly = false,
+  combinator,
+  hideCombinator = false,
+  allowGroups = true,
+  checks,
   validate,
   className,
   addConditionLabel,
@@ -134,33 +171,81 @@ function RuleBuilder({
   addActionLabel,
   labels: labelOverrides
 }) {
+  const provided = useUixLabels().ruleBuilder;
   const labels = {
     ...DEFAULT_RULE_BUILDER_LABELS,
+    ...provided,
     ...addConditionLabel != null ? { addCondition: addConditionLabel } : {},
     ...addGroupLabel != null ? { addGroup: addGroupLabel } : {},
     ...addActionLabel != null ? { addAction: addActionLabel } : {},
     ...labelOverrides
   };
   const issuesText = (template1, templateN) => fillLabel(issues.length === 1 ? template1 : templateN, { count: issues.length });
-  const issues = [...validateRuleDefinition(value, maxDepth), ...validate?.(value) ?? []];
+  const builtIn = validateRuleDefinition(value, maxDepth, {
+    messages: {
+      duplicateId: labels.issueDuplicateId,
+      maxDepth: labels.issueMaxDepth,
+      emptyGroup: labels.issueEmptyGroup,
+      missingField: labels.issueMissingField,
+      missingOperator: labels.issueMissingOperator,
+      noActions: labels.issueNoActions,
+      missingActionType: labels.issueMissingActionType
+    },
+    checks: conditionsOnly ? { noActions: false, missingActionType: false, ...checks } : checks
+  });
+  const issues = [...builtIn, ...validate?.(value) ?? []];
   const fieldLabels = Object.fromEntries(fields.map((field) => [field.id, field.label]));
   const operatorLabels = Object.fromEntries(operators.map((operator) => [operator.id, operator.label]));
   const actionLabels = Object.fromEntries(actions.map((action) => [action.id, action.label]));
-  if (readOnly) return /* @__PURE__ */ jsxs("section", { className: cx("uix-rule-builder uix-rule-builder--summary", className), "aria-label": labels.summary, children: [
-    /* @__PURE__ */ jsx("p", { children: summarizeRule(value, { fields: fieldLabels, operators: operatorLabels, actions: actionLabels }) }),
-    issues.length > 0 && /* @__PURE__ */ jsx("p", { className: "uix-rule-builder__invalid", children: issuesText(labels.summaryIssuesOne, labels.summaryIssuesMany) })
-  ] });
+  if (readOnly === "summary") {
+    const sentence = summarizeRule(value, {
+      fields: fieldLabels,
+      operators: operatorLabels,
+      actions: actionLabels,
+      conditionsOnly,
+      words: {
+        sentence: labels.summarySentence,
+        sentenceConditionsOnly: labels.summarySentenceConditionsOnly,
+        noConditions: labels.summaryNoConditions,
+        noActions: labels.summaryNoActions,
+        and: labels.and,
+        or: labels.or
+      }
+    });
+    return /* @__PURE__ */ jsxs("section", { className: cx("uix-rule-builder uix-rule-builder--summary", className), "aria-label": labels.summary, children: [
+      /* @__PURE__ */ jsx("p", { children: sentence }),
+      issues.length > 0 && /* @__PURE__ */ jsx("p", { className: "uix-rule-builder__invalid", children: issuesText(labels.summaryIssuesOne, labels.summaryIssuesMany) })
+    ] });
+  }
+  const disabled = readOnly === true;
+  const emitWhen = (when) => onChange({ ...value, when: combinator ? setRuleCombinator(when, combinator) : when });
   const updateActions = (next) => onChange({ ...value, then: next });
-  return /* @__PURE__ */ jsxs("section", { className: cx("uix-rule-builder", className), "aria-label": labels.region, children: [
-    /* @__PURE__ */ jsx(RuleGroupEditor, { group: value.when, depth: 1, root: value.when, fields, operators, maxDepth, disabled: readOnly, onRootChange: (when) => onChange({ ...value, when }), labels }),
-    /* @__PURE__ */ jsxs("fieldset", { className: "uix-rule-builder__actions", children: [
+  return /* @__PURE__ */ jsxs("section", { className: cx("uix-rule-builder", disabled && "uix-rule-builder--readonly", className), "aria-label": labels.region, children: [
+    /* @__PURE__ */ jsx(
+      RuleGroupEditor,
+      {
+        group: value.when,
+        depth: 1,
+        root: value.when,
+        fields,
+        operators,
+        maxDepth,
+        disabled,
+        onRootChange: emitWhen,
+        labels,
+        combinator,
+        hideCombinator,
+        allowGroups: allowGroups && maxDepth > 1
+      }
+    ),
+    !conditionsOnly && /* @__PURE__ */ jsxs("fieldset", { className: "uix-rule-builder__actions", children: [
       /* @__PURE__ */ jsx("legend", { children: labels.then }),
       value.then.map((action, index) => {
         const definition = actions.find((item) => item.id === action.type);
         return /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__action", children: [
-          /* @__PURE__ */ jsx("select", { className: "uix-select", value: action.type, onChange: (event) => updateActions(value.then.map((item) => item.id === action.id ? { ...item, type: event.currentTarget.value } : item)), "aria-label": labels.actionType, children: actions.map((item) => /* @__PURE__ */ jsx("option", { value: item.id, children: item.label }, item.id)) }),
-          definition?.renderParameters?.(action, (parameters) => updateActions(value.then.map((item) => item.id === action.id ? { ...item, parameters } : item)), false),
-          /* @__PURE__ */ jsx(
+          /* @__PURE__ */ jsx("select", { className: "uix-select", value: action.type, disabled, onChange: (event) => updateActions(value.then.map((item) => item.id === action.id ? { ...item, type: event.currentTarget.value } : item)), "aria-label": labels.actionType, children: actions.map((item) => /* @__PURE__ */ jsx("option", { value: item.id, children: item.label }, item.id)) }),
+          definition?.renderParameters?.(action, (parameters) => updateActions(value.then.map((item) => item.id === action.id ? { ...item, parameters } : item)), disabled),
+          !disabled && /* @__PURE__ */ jsx(
             RowControls,
             {
               labels,
@@ -183,7 +268,7 @@ function RuleBuilder({
           )
         ] }, action.id);
       }),
-      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary uix-btn--sm", disabled: actions.length === 0, onClick: () => updateActions([...value.then, { id: nextId("action"), type: actions[0]?.id ?? "", parameters: {} }]), children: labels.addAction })
+      !disabled && /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary uix-btn--sm", disabled: actions.length === 0, onClick: () => updateActions([...value.then, { id: nextId("action"), type: actions[0]?.id ?? "", parameters: {} }]), children: labels.addAction })
     ] }),
     /* @__PURE__ */ jsx("div", { className: "uix-rule-builder__validation", "aria-live": "polite", children: issues.length === 0 ? /* @__PURE__ */ jsx("span", { children: labels.valid }) : /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx("strong", { children: issuesText(labels.issuesOne, labels.issuesMany) }),

package/dist/components/SchedulingCalendar.d.ts

@@ -1,10 +1,29 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { CalendarWeekday } from '../calendar-model.js';
+import { MonthSpanLayout } from '../scheduling-calendar-model.js';
 
 type SchedulingCalendarView = 'month' | 'week' | 'agenda';
+/**
+ * @deprecated Use `band`, `status` and `markers` on the entry: they carry no product
+ * vocabulary and the consumer supplies every word. The values keep working in 2.x.
+ */
 type SchedulingEntryState = 'scheduled' | 'conflicted' | 'in-progress' | 'blackout-violation';
+/** @deprecated Use `pattern` and `kindLabel` on the overlay. The values keep working in 2.x. */
 type SchedulingOverlayKind = 'maintenance' | 'blackout';
+/**
+ * The one dimension that takes a hue. `none` and `low` are untinted, `medium` gets a
+ * heavier edge, and only `high` is filled. The consumer decides what a band means.
+ */
+type SchedulingBand = 'none' | 'low' | 'medium' | 'high';
+/**
+ * The state channel, drawn without hue: `tentative` is dashed, `committed` is the plain
+ * item, `live` carries a leading dot, `done` is dimmed and `dead` is struck through.
+ */
+type SchedulingStatus = 'tentative' | 'committed' | 'live' | 'done' | 'dead';
+type SchedulingMarkerEmphasis = 'refused' | 'warning' | 'neutral';
+/** How a window is hatched. Windows are neutral: the pattern and the visible label tell them apart. */
+type SchedulingOverlayPattern = 'diagonal' | 'cross' | 'dotted' | 'solid';
 /**
  * Which date text a `formatDate` call is for (TENSOR B1/C9, HAR-1347):
  * `day` names one day (each day cell's accessible name, the week-range title);
@@ -12,20 +31,66 @@ type SchedulingOverlayKind = 'maintenance' | 'blackout';
  * `month` is the month-view title (the date is the first of the month).
  */
 type SchedulingDatePart = 'day' | 'weekday' | 'month';
+/** A shape or icon with text. The text is always in the accessible name; a marker never relies on colour. */
+interface SchedulingMarker {
+    id: string;
+    /** An icon from `@tensor_1/react/icons`. Without one the marker draws a shape for its `emphasis`. */
+    icon?: ReactNode;
+    label: string;
+    emphasis?: SchedulingMarkerEmphasis;
+}
 interface SchedulingCalendarEntry {
     id: string;
     title: string;
     start: string;
     end: string;
+    /** @deprecated Use `band`, `status` and `markers`. */
     state?: SchedulingEntryState;
     meta?: string;
+    band?: SchedulingBand;
+    status?: SchedulingStatus;
+    markers?: SchedulingMarker[];
+    /** The complete accessible name, built by the consumer from its own words. Replaces `labels.entry`. */
+    accessibleName?: string;
 }
 interface SchedulingCalendarOverlay {
     id: string;
+    /** The window's name, shown as text. */
     label: string;
     start: string;
     end: string;
-    kind: SchedulingOverlayKind;
+    /** @deprecated Use `pattern` and `kindLabel`. */
+    kind?: SchedulingOverlayKind;
+    /** Defaults to `'solid'`. */
+    pattern?: SchedulingOverlayPattern;
+    /** What kind of window this is, in the consumer's words. Shown before the name. */
+    kindLabel?: string;
+    /** What the window applies to. Shown after the name. */
+    scopeLabel?: string;
+    /** The window applies to everything. A window that is not global never gets the global treatment. */
+    global?: boolean;
+    /** The complete accessible name. Replaces `labels.overlay`. */
+    accessibleName?: string;
+}
+/** What the consumer knows about one day (`YYYY-MM-DD`). The calendar shows these numbers and never derives them. */
+interface SchedulingCalendarDay {
+    /** Every item on the day, shown in the cell even when no chip fits. */
+    count: number;
+    /** The "+N" of the cell. 0 shows none. */
+    overflowCount: number;
+    /** The accessible text of the count, e.g. "7 items, 2 need review". */
+    label?: string;
+    markers?: SchedulingMarker[];
+}
+interface SchedulingLegendItem {
+    id: string;
+    label: string;
+    swatch: {
+        band?: SchedulingBand;
+        status?: SchedulingStatus;
+        pattern?: SchedulingOverlayPattern;
+        icon?: ReactNode;
+    };
 }
 /**
  * Every word the calendar renders (TENSOR RX-125, UIX-12). `{timeZone}`, `{view}`,
@@ -33,8 +98,15 @@ interface SchedulingCalendarOverlay {
  */
 interface SchedulingCalendarLabels {
     region: string;
+    /** @deprecated Use `previousMonth` and `previousWeek`. Still used when those are not set. */
     previous: string;
+    /** @deprecated Use `nextMonth` and `nextWeek`. Still used when those are not set. */
     next: string;
+    previousMonth?: string;
+    nextMonth?: string;
+    /** Also names the agenda's step, which moves by a week. */
+    previousWeek?: string;
+    nextWeek?: string;
     viewGroup: string;
     viewMonth: string;
     viewWeek: string;
@@ -44,7 +116,10 @@ interface SchedulingCalendarLabels {
     agenda: string;
     agendaEmpty: string;
     grid: string;
+    /** An entry's accessible name unless it sets `accessibleName`. Its marker labels are appended. */
     entry: string;
+    /** A window's accessible name unless it sets `accessibleName`. `{title}` is its kind, name and scope. */
+    overlay?: string;
     legend: string;
     /** The "+N more" toggle on a day with more entries than `maxEntriesPerDay`. `{count}` placeholder. */
     moreEntries: string;
@@ -52,19 +127,36 @@ interface SchedulingCalendarLabels {
     moreEntriesLabel: string;
     /** The toggle once the day is expanded in place. */
     fewerEntries: string;
+    /** The "+N" at the end of a week row whose spans did not all get a lane. `{count}` placeholder. */
+    moreSpans?: string;
+    /** Accessible name of that control. `{count}` and `{date}` (the first day with a hidden span). */
+    moreSpansLabel?: string;
+    /** The accessible text of a day's count when `days[date].label` is not given. `{count}` placeholder. */
+    dayCount?: string;
     states: Record<SchedulingEntryState, string>;
+    /** The words for `status`, used in the default accessible name and the agenda. */
+    statuses?: Partial<Record<SchedulingStatus, string>>;
 }
 declare const DEFAULT_SCHEDULING_CALENDAR_LABELS: SchedulingCalendarLabels;
 interface SchedulingCalendarProps {
+    /**
+     * The entries. Without `dayEntries` the calendar places each on its day in the order
+     * given; with `dayEntries` only the entries that cover more than one day are read from
+     * here (they are drawn as spans).
+     */
     entries: SchedulingCalendarEntry[];
     anchorDate: string;
     timeZone: string;
     view?: SchedulingCalendarView;
     onViewChange?: (view: SchedulingCalendarView) => void;
     onAnchorDateChange?: (date: string) => void;
+    /** Called by a click or Enter on a chip, a span or an agenda row. */
     onSelectEntry?: (entry: SchedulingCalendarEntry) => void;
     overlays?: SchedulingCalendarOverlay[];
+    /** Called by a click or Enter on a window span. */
+    onSelectOverlay?: (overlay: SchedulingCalendarOverlay) => void;
     filter?: (entry: SchedulingCalendarEntry) => boolean;
+    /** Replaces a chip's content. The default is the start time in `timeZone` (24 h) and the title. */
     renderEntry?: (entry: SchedulingCalendarEntry) => ReactNode;
     locale?: string;
     /** First column of the month and week grids: 0 = Sunday … 6 = Saturday. Defaults to 1 (Monday). */
@@ -75,20 +167,23 @@ interface SchedulingCalendarProps {
      */
     formatDate?: (date: string, part: SchedulingDatePart) => string;
     /**
-     * Formats an entry's start or end instant (ISO 8601) for the agenda and the entry names.
-     * The component does not shift it: render it in `timeZone` yourself. Defaults to `Intl`
-     * medium date + short time in `timeZone`.
+     * Formats a start or end instant (ISO 8601) for the agenda and the accessible names.
+     * The component does not shift it: render it in `timeZone` yourself. Defaults to the
+     * `day` date text followed by the 24-hour time in `timeZone`.
      */
     formatInstant?: (instant: string) => string;
     /**
-     * Show at most this many entries in a month or week day; the rest collapse behind a
-     * "+N more" toggle. Unset shows every entry.
+     * How many chips a day shows. Without `dayEntries` the rest collapse behind "+N more";
+     * with `dayEntries` it only sizes the cell (the consumer already cut the list, and a longer
+     * list makes the cells taller, never clipped). Unset shows every entry where the cells
+     * grow, and sizes a fixed cell for three chips.
      */
     maxEntriesPerDay?: number;
     /**
-     * Called by the "+N more" toggle with the day and every entry on it. When set, the
-     * consumer shows them (a popover, a drawer, the day view) and the day stays collapsed;
-     * otherwise the day expands in place.
+     * Called by a day's "+N more" and by a week row's "+N" with the day (and, without
+     * `dayEntries`, every entry on it). When set, the consumer shows them (a popover, a
+     * drawer, the day view) and the day stays collapsed. Required with `days` or `dayEntries`:
+     * a controlled day never expands in place.
      */
     onShowMore?: (date: string, entries: SchedulingCalendarEntry[]) => void;
     /**
@@ -98,6 +193,42 @@ interface SchedulingCalendarProps {
      * to the number). Return null for no badge.
      */
     renderDayBadge?: (date: string, entries: SchedulingCalendarEntry[]) => ReactNode;
+    /**
+     * Consumer-owned numbers per day (`YYYY-MM-DD`). When set, each listed day shows its
+     * `count` and markers even with no chip, and its "+N" is `overflowCount`, never a number
+     * derived from the entries given. Without `dayEntries` the chips are still this day's
+     * `entries`, cut to `maxEntriesPerDay`; the day never expands in place.
+     */
+    days?: Record<string, SchedulingCalendarDay>;
+    /**
+     * The single-day chips of each day, already ranked and cut by the consumer. When set, the
+     * calendar renders exactly these in the order given: it does not place, rank, cut or count.
+     */
+    dayEntries?: Record<string, SchedulingCalendarEntry[]>;
+    /**
+     * The result of `layoutMonthSpans` for this grid. When set, the calendar draws exactly
+     * these spans and never packs lanes itself. Compute it with `schedulingGridDays`.
+     */
+    spanLayout?: MonthSpanLayout;
+    /**
+     * Lanes kept for windows above the chips. Windows never take a chip slot. Default 2 where
+     * the cells have a fixed height; where they grow with their content every window gets a lane.
+     */
+    windowLaneCap?: number;
+    /** Lanes kept for entries that cover more than one day. Default as for `windowLaneCap`. */
+    spanLaneCap?: number;
+    /** When set, the legend is exactly these items (an empty list draws no legend). Unset keeps the built-in state legend. */
+    legend?: SchedulingLegendItem[];
+    /** A line under the legend, e.g. the display zone. */
+    legendCaption?: ReactNode;
+    /** `false` hides the previous/next buttons, the title and the view switch (the page has its own toolbar). */
+    showHeader?: boolean;
+    /** Shown above the grid, e.g. "Showing the first 2,000 items". */
+    notice?: ReactNode;
+    /** Shown inside the grid, below the day cells, when there is nothing to show. */
+    emptyNote?: ReactNode;
+    /** Called by a click or Enter on a day number. */
+    onSelectDate?: (date: string) => void;
     loading?: boolean;
     error?: string;
     onRetry?: () => void;
@@ -105,6 +236,6 @@ interface SchedulingCalendarProps {
     labels?: Partial<SchedulingCalendarLabels>;
 }
 /** Month/week/agenda calendar for UTC ranges rendered in an explicit IANA time zone. */
-declare function SchedulingCalendar({ entries, anchorDate, timeZone, view: controlledView, onViewChange, onAnchorDateChange, onSelectEntry, overlays, filter, renderEntry, locale, weekStartsOn, formatDate, formatInstant: formatInstantProp, maxEntriesPerDay, onShowMore, renderDayBadge, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
+declare function SchedulingCalendar({ entries, anchorDate, timeZone, view: controlledView, onViewChange, onAnchorDateChange, onSelectEntry, overlays, onSelectOverlay, filter, renderEntry, locale, weekStartsOn, formatDate, formatInstant: formatInstantProp, maxEntriesPerDay, onShowMore, renderDayBadge, days: dayInfo, dayEntries, spanLayout, windowLaneCap, spanLaneCap, legend, legendCaption, showHeader, notice, emptyNote, onSelectDate, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
 
-export { DEFAULT_SCHEDULING_CALENDAR_LABELS, SchedulingCalendar, type SchedulingCalendarEntry, type SchedulingCalendarLabels, type SchedulingCalendarOverlay, type SchedulingCalendarProps, type SchedulingCalendarView, type SchedulingDatePart, type SchedulingEntryState, type SchedulingOverlayKind };
+export { DEFAULT_SCHEDULING_CALENDAR_LABELS, type SchedulingBand, SchedulingCalendar, type SchedulingCalendarDay, type SchedulingCalendarEntry, type SchedulingCalendarLabels, type SchedulingCalendarOverlay, type SchedulingCalendarProps, type SchedulingCalendarView, type SchedulingDatePart, type SchedulingEntryState, type SchedulingLegendItem, type SchedulingMarker, type SchedulingMarkerEmphasis, type SchedulingOverlayKind, type SchedulingOverlayPattern, type SchedulingStatus };