@tensor_1/react 2.31.0 → 2.33.0

package/dist/SchedulingCalendar-C4XVbqZr.d.ts

@@ -0,0 +1,339 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { CalendarWeekday } from './calendar-model.js';
+import { MoveProposal, MonthSpanLayout } from './scheduling-calendar-model.js';
+
+interface TimeGridEntryContext {
+    /** Whole text lines that fit in the item: 0 shows the markers only. */
+    availableLines: number;
+}
+interface SchedulingTimeGridProps {
+    view: 'week' | 'day';
+    days: string[];
+    timeZone: string;
+    entries: SchedulingCalendarEntry[];
+    overlays: SchedulingCalendarOverlay[];
+    dayInfo?: Record<string, SchedulingCalendarDay>;
+    labels: Required<SchedulingCalendarLabels>;
+    gridLabel: string;
+    dateText: (date: string, part: SchedulingDatePart) => string;
+    formatInstant: (instant: string) => string;
+    entryName: (entry: SchedulingCalendarEntry) => string;
+    entryStatus: (entry: SchedulingCalendarEntry) => string;
+    entryMarkers: (entry: SchedulingCalendarEntry) => SchedulingMarker[];
+    overlayName: (overlay: SchedulingCalendarOverlay) => string;
+    renderEntry?: (entry: SchedulingCalendarEntry, context?: TimeGridEntryContext) => ReactNode;
+    renderMarker: (marker: SchedulingMarker, showLabel?: boolean) => ReactNode;
+    onSelectEntry?: (entry: SchedulingCalendarEntry) => void;
+    onSelectOverlay?: (overlay: SchedulingCalendarOverlay) => void;
+    onSelectDate?: (date: string) => void;
+    onShowMore?: (date: string, entries: SchedulingCalendarEntry[]) => void;
+    now?: string;
+    canMove: boolean;
+    step: number;
+    onProposeMove?: (id: string, proposal: MoveProposal) => void | Promise<unknown>;
+    topLaneCrossMidnightMinutes: number;
+    topLaneCap: number;
+    windowLaneCap: number;
+    maxLanes: number;
+    emptyNote?: ReactNode;
+    nothingToShow: boolean;
+}
+/** Week (seven columns) or Day (one column) with an hour axis. */
+declare function SchedulingTimeGrid({ view, days, timeZone, entries: givenEntries, overlays: givenOverlays, dayInfo, labels, gridLabel, dateText, formatInstant, entryName, entryStatus, entryMarkers, overlayName, renderEntry, renderMarker, onSelectEntry, onSelectOverlay, onSelectDate, onShowMore, now, canMove, step: givenStep, onProposeMove, topLaneCrossMidnightMinutes, topLaneCap, windowLaneCap, maxLanes, emptyNote, nothingToShow, }: SchedulingTimeGridProps): react.JSX.Element;
+
+/** `day` is one column of the time grid. `week` is the time grid when `timeGrid` is set, else seven day cells. */
+type SchedulingCalendarView = 'month' | 'week' | 'day' | '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);
+ * `weekday` is the short column header (the date is any day of that weekday);
+ * `month` is the month-view title (the date is the first of the month);
+ * `column` heads one day column of the time grid (weekday and date, e.g. "Wed 07.10").
+ */
+type SchedulingDatePart = 'day' | 'weekday' | 'month' | 'column';
+/** 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;
+    /** No time of day. In the time grid the entry is drawn in the top lane. */
+    allDay?: boolean;
+    /** `false` keeps this entry where it is when the grid allows moves (`canMove`). */
+    movable?: boolean;
+}
+interface SchedulingCalendarOverlay {
+    id: string;
+    /** The window's name, shown as text. */
+    label: string;
+    start: string;
+    end: string;
+    /** @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}`,
+ * `{title}`, `{state}`, `{start}`, `{end}` are placeholders.
+ */
+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;
+    previousDay?: string;
+    nextDay?: string;
+    viewGroup: string;
+    viewMonth: string;
+    viewWeek: string;
+    viewDay?: string;
+    viewAgenda: string;
+    loading: string;
+    retry: string;
+    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;
+    /** Accessible name of that toggle. `{count}` and `{date}` placeholders. */
+    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>>;
+    /** The header of the hour axis: it names the display zone. `{timeZone}` placeholder. */
+    timeZone?: string;
+    /** Names the strip of windows above the time grid. */
+    windows?: string;
+    /** "+N windows" when the strip has more windows than lanes. `{count}` placeholder. */
+    moreWindows?: string;
+    /** Accessible name of that control. `{count}` and `{date}` (the first day with a hidden window). */
+    moreWindowsLabel?: string;
+    /** Names the lane above the hours that holds all-day and long entries. */
+    topLane?: string;
+    /** The cue on the second-day part of an entry that crosses midnight. `{time}` is its start. */
+    continuesFrom?: string;
+    /** Read after an item's name when it can be moved. */
+    moveHint?: 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;
+}
+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.
+     * In the time grid the second argument says how many text lines fit in the item (0: show the
+     * markers only); elsewhere it is not passed.
+     */
+    renderEntry?: (entry: SchedulingCalendarEntry, context?: TimeGridEntryContext) => ReactNode;
+    locale?: string;
+    /** First column of the month and week grids: 0 = Sunday … 6 = Saturday. Defaults to 1 (Monday). */
+    weekStartsOn?: CalendarWeekday;
+    /**
+     * Formats every calendar date the component writes (`date` is `YYYY-MM-DD`). Use it to
+     * apply a product date format such as DD.MM.YYYY; defaults to `Intl` in `locale`.
+     */
+    formatDate?: (date: string, part: SchedulingDatePart) => string;
+    /**
+     * 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;
+    /**
+     * 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 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;
+    /**
+     * A small badge beside a day's date, e.g. a collision count. Keep it short (a number or a
+     * glyph): it shares a narrow column with the date and is clipped, not wrapped. It sits
+     * outside the date button, so give it its own accessible text (a visually hidden word next
+     * 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;
+    /**
+     * Draws `view="week"` as a time grid: seven day columns on an hour axis. `view="day"` is
+     * always a time grid. Default `false`: the week stays seven day cells.
+     */
+    timeGrid?: boolean;
+    /** An instant (ISO 8601). The time grid draws one line at it, in the column of its day. The component keeps no clock. */
+    now?: string;
+    /**
+     * Lets the user ask for a move in the time grid (drag, or Shift and an arrow key, then
+     * Enter). Without it, or without `onProposeMove`, items have no move affordance at all.
+     */
+    canMove?: boolean;
+    /** Minutes a move snaps to. Default 15. */
+    step?: number;
+    /**
+     * Called once per finished gesture with the window the user asks for. The calendar never
+     * moves the item: it draws entries where the props say, so an entry 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>;
+    /** An entry running more than this many minutes past its first local midnight goes to the top lane. Default 360. */
+    topLaneCrossMidnightMinutes?: number;
+    /** Rows of the top lane of the time grid. Default 3. */
+    topLaneCap?: number;
+    /** Lanes side by side in one day column of the time grid, at most. Fewer are used when the column is narrow. Default 4. */
+    maxLanes?: number;
+    loading?: boolean;
+    error?: string;
+    onRetry?: () => void;
+    className?: string;
+    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, onSelectOverlay, filter, renderEntry, locale, weekStartsOn, formatDate, formatInstant: formatInstantProp, maxEntriesPerDay, onShowMore, renderDayBadge, days: dayInfo, dayEntries, spanLayout, windowLaneCap, spanLaneCap, legend, legendCaption, showHeader, notice, emptyNote, onSelectDate, timeGrid, now, canMove, step, onProposeMove, topLaneCrossMidnightMinutes, topLaneCap, maxLanes, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
+
+export { DEFAULT_SCHEDULING_CALENDAR_LABELS as D, type SchedulingBand as S, type TimeGridEntryContext as T, SchedulingCalendar as a, type SchedulingCalendarDay as b, type SchedulingCalendarEntry as c, type SchedulingCalendarLabels as d, type SchedulingCalendarOverlay as e, type SchedulingCalendarProps as f, type SchedulingCalendarView as g, type SchedulingDatePart as h, type SchedulingEntryState as i, type SchedulingLegendItem as j, type SchedulingMarker as k, type SchedulingMarkerEmphasis as l, type SchedulingOverlayKind as m, type SchedulingOverlayPattern as n, type SchedulingStatus as o, SchedulingTimeGrid as p, type SchedulingTimeGridProps as q };

package/dist/attachment-labels.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The words of an `Attachment` row. In a module of its own, with no "use client": the
+ * server-renderable `Attachment` and its client parts both read it, and a server component can
+ * still import the defaults as plain values.
+ */
+interface AttachmentLabels {
+    /** Remove button. `{name}`. */
+    remove: string;
+    /** Download link name when `download` is set. `{name}`. */
+    download: string;
+    loading: string;
+    forbidden: string;
+}
+declare const DEFAULT_ATTACHMENT_LABELS: AttachmentLabels;
+
+export { type AttachmentLabels, DEFAULT_ATTACHMENT_LABELS };

package/dist/attachment-labels.js

@@ -0,0 +1,9 @@
+const DEFAULT_ATTACHMENT_LABELS = {
+  remove: "Remove {name}",
+  download: "Download {name}",
+  loading: "Loading\u2026",
+  forbidden: "You do not have access to this file."
+};
+export {
+  DEFAULT_ATTACHMENT_LABELS
+};

package/dist/calendar-model.d.ts

@@ -19,9 +19,149 @@ declare function startOfMonth(value: string): string;
 /** A weekday in `Date.getUTCDay()` numbering: 0 = Sunday … 6 = Saturday. */
 type CalendarWeekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 declare function buildMonthGrid(month: string, weekStartsOn?: CalendarWeekday): CalendarDay[];
+/**
+ * A shared `Intl.DateTimeFormat` for `locale` and `options`. Formatters are expensive to
+ * build, so one instance is kept per locale and options shape (key order does not matter);
+ * the cache holds up to 64 shapes and drops the oldest past that.
+ */
+declare function cachedDateTimeFormat(locale: string | readonly string[] | undefined, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+/** The calendar date (`YYYY-MM-DD`) of an instant in `timeZone`. */
 declare function zonedDateKey(instant: string | Date, timeZone: string): string;
+/**
+ * The 24-hour wall-clock time (`HH:MM`) of an instant in `timeZone`. It reads the same
+ * cached formatter as the zone math, so it adds no `Intl.DateTimeFormat` instance.
+ */
+declare function zonedTimeOfDay(instant: string | number | Date, timeZone: string): string;
+interface ZonedDayBounds {
+    /** The first instant of the day in the zone (local 00:00, or the first existing time after a gap). */
+    start: Date;
+    /** The first instant of the next day: `end` of D equals `start` of D + 1. */
+    end: Date;
+}
+/**
+ * The half-open interval `[start, end)` of a calendar day in `timeZone`. DST days are 23 or
+ * 25 hours long; a day whose midnight does not exist starts at its first existing instant.
+ */
+declare function zonedDayBounds(dateKey: string, timeZone: string): ZonedDayBounds;
+interface ZonedHourSlot {
+    /** The real instant the local hour starts. */
+    instant: Date;
+    /** The local hour, two digits (`'00'` … `'23'`). */
+    label: string;
+    /**
+     * The UTC offset (`'+02:00'`) when this local hour occurs twice in the day (clocks went
+     * back), set on both occurrences; otherwise `null`.
+     */
+    offsetLabel: string | null;
+}
+/**
+ * One entry per real hour start in the day `[start, end)` in `timeZone`: 24 on most days,
+ * 23 when clocks go forward (no slot for the skipped hour) and 25 when they go back (the
+ * repeated hour twice, each with an `offsetLabel`).
+ */
+declare function zonedHourSlots(dateKey: string, timeZone: string): ZonedHourSlot[];
+interface ZonedDayShift {
+    instant: Date;
+    /** `'gap_forward'` when the target wall-clock time did not exist and moved forward past the gap. */
+    adjusted: 'gap_forward' | null;
+}
+/**
+ * Moves an instant by `days` calendar days in `timeZone`, keeping its wall-clock time
+ * ("+1 day" is the same local time on the next day, whether that day has 23, 24 or 25
+ * hours). A wall time that occurs twice keeps the source's offset when it can (else the
+ * earlier one). A wall time that does not exist moves forward by the gap, once, and the
+ * result says so (`adjusted: 'gap_forward'`).
+ */
+declare function addZonedDays(instant: string | Date, days: number, timeZone: string): ZonedDayShift;
+/**
+ * Calendar days `[start, end)` as date keys: `end` is the first day NOT covered.
+ * Produced by `zonedDaySpan`, read by `enumerateDateKeys`.
+ */
+interface ZonedDaySpan {
+    start: string;
+    end: string;
+}
+/**
+ * The calendar days an instant interval `[start, end)` touches in `timeZone`, end-exclusive:
+ * an entry ending exactly at local 00:00 occupies only the day before. Throws a `RangeError`
+ * when `end` is not after `start`; it never swaps the ends.
+ */
+declare function zonedDaySpan(start: string | Date, end: string | Date, timeZone: string): ZonedDaySpan;
+/**
+ * The date keys of a `ZonedDaySpan` (`[start, end)`), at most `limit` of them (default
+ * 370; `Infinity` for no limit). `truncated` is true when the span has more days than were
+ * returned, so a long span is never cut silently. Throws a `RangeError` on an inverted span.
+ */
+declare function enumerateDateKeys(span: ZonedDaySpan, options?: {
+    limit?: number;
+}): {
+    dates: string[];
+    truncated: boolean;
+};
+/**
+ * Inclusive date keys of an instant interval, with inverted ends swapped.
+ * @deprecated Use `zonedDaySpan`, which is end-exclusive (an entry ending at local 00:00
+ * does not paint the next day) and throws on an inverted interval instead of swapping.
+ * The behaviour here is unchanged in 2.x; changing it follows the contract-change process (E13).
+ */
 declare function zonedDateSpan(start: string, end: string, timeZone: string): ZonedDateSpan;
+/**
+ * Date keys of an inclusive span, stopping silently after `limit` (370).
+ * @deprecated Use `enumerateDateKeys`, which reads an end-exclusive `ZonedDaySpan` and
+ * reports `truncated` instead of stopping silently. The behaviour here is unchanged in 2.x (E13).
+ */
 declare function enumerateDateSpan(span: ZonedDateSpan, limit?: number): string[];
+interface LaneInterval {
+    id: string;
+    /** Half-open `[start, end)`: ISO string, epoch ms or Date. */
+    start: string | number | Date;
+    end: string | number | Date;
+}
+interface LanePlacement {
+    /** 0-based lane, or `null` when the interval did not fit in `maxLanes`. */
+    lane: number | null;
+    /** Index into `PackedLanes.clusters`. */
+    cluster: number;
+}
+interface LaneCluster {
+    /** Ids of one run of transitively overlapping intervals, by start, then end, then id. */
+    ids: string[];
+    /** Lanes the cluster uses (≤ `maxLanes`); a renderer divides the width by this. */
+    laneCount: number;
+    /** Intervals of the cluster that got no lane. */
+    overflow: number;
+}
+interface PackedLanes {
+    lanes: Record<string, LanePlacement>;
+    clusters: LaneCluster[];
+    /** Intervals that got no lane, over all clusters. */
+    overflow: number;
+}
+interface PackLanesOptions {
+    /**
+     * `'start'` (default): greedy first-fit by start, then end, then id, so the result does
+     * not depend on input order. `'given'`: first-fit in input order, so the consumer's
+     * ranking decides which intervals get a lane when there are not enough.
+     */
+    order?: 'start' | 'given';
+}
+/**
+ * Assigns half-open intervals to at most `maxLanes` lanes, first-fit. Two intervals that
+ * overlap never share a lane; two that only touch (`a.end === b.start`) may. Intervals
+ * that do not fit get `lane: null` and count towards their cluster's `overflow`. A
+ * zero-length interval occupies its start instant. Throws on `end < start` (it never
+ * swaps) and on a duplicate id.
+ */
+declare function packLanes(intervals: readonly LaneInterval[], maxLanes: number, options?: PackLanesOptions): PackedLanes;
+/**
+ * Sorts a copy of `items` with `compare` (stable) and cuts it after `n`. `hidden` is the
+ * number of items not shown, so it is a true total only when `items` is complete; a
+ * consumer that knows a larger total shows that instead.
+ */
+declare function rankOverflow<T>(items: readonly T[], compare: (a: T, b: T) => number, n: number): {
+    visible: T[];
+    hidden: number;
+};
 declare function selectRangeDate(current: DateRangeValue, date: string): DateRangeValue;
 declare function isDateInRange(date: string, value: DateRangeValue): boolean;
 declare function isDateUnavailable(date: string, options: {
@@ -30,4 +170,4 @@ declare function isDateUnavailable(date: string, options: {
     isDisabled?: (date: string) => boolean;
 }): boolean;
 
-export { type CalendarDay, type CalendarWeekday, type DateRangeValue, type ZonedDateSpan, addCalendarDays, addCalendarMonths, buildMonthGrid, enumerateDateSpan, isDateInRange, isDateUnavailable, selectRangeDate, startOfMonth, toDateKey, zonedDateKey, zonedDateSpan };
+export { type CalendarDay, type CalendarWeekday, type DateRangeValue, type LaneCluster, type LaneInterval, type LanePlacement, type PackLanesOptions, type PackedLanes, type ZonedDateSpan, type ZonedDayBounds, type ZonedDayShift, type ZonedDaySpan, type ZonedHourSlot, addCalendarDays, addCalendarMonths, addZonedDays, buildMonthGrid, cachedDateTimeFormat, enumerateDateKeys, enumerateDateSpan, isDateInRange, isDateUnavailable, packLanes, rankOverflow, selectRangeDate, startOfMonth, toDateKey, zonedDateKey, zonedDateSpan, zonedDayBounds, zonedDaySpan, zonedHourSlots, zonedTimeOfDay };