@elaraai/east-ui 1.0.4 → 1.0.6

package/dist/src/collections/planner/index.d.ts

@@ -2,321 +2,492 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { type ExprType, type SubtypeExprOrValue, StructType, ArrayType, DictType, StringType, FloatType, OptionType, FunctionType, IntegerType, NullType, type TypeOf } from "@elaraai/east";
-import { TableCellClickEventType, TableRowClickEventType, TableSortEventType } from "../table/types.js";
-import { EventAddEventType } from "./types.js";
-import { StatusTokenType } from "../../style/interaction.js";
-import { ColorSchemeType, AlignType, LabelInputType, type ColorSchemeLiteral, type AlignLiteral, type LabelInput } from "../../style.js";
-import { UIComponentType, OverlayInputType } from "../../component.js";
-import { TableCellType, TableColumnType, type TableColumnConfig } from "../table/index.js";
-import { PlannerStyleType, SlotModeType, type PlannerStyle, EventClickEventType, EventDragEventType, EventResizeEventType, EventDeleteEventType, PlannerBoundaryType, EventIconType, type EventIcon } from "./types.js";
-export { PlannerStyleType, SlotModeType, type PlannerStyle, type SlotModeLiteral, EventClickEventType, EventDragEventType, EventResizeEventType, EventDeleteEventType, ResizeEdgeType, PlannerBoundaryType, type PlannerBoundary, EventIconType, type EventIcon, } from "./types.js";
 /**
- * East StructType for a Planner event.
+ * `Planner` — the discrete `rows × ordered slots` scheduling primitive. Rows are
+ * typed resources; slots are positions on a typed axis ({@link PlannerSlotType});
+ * each cell holds zero or more events in one of three audit states
+ * ({@link PlannerStateType}). The interface follows the `Chart.Spec` style: a
+ * builder namespace (`Planner.axis.*` / `Planner.at.*` / `Planner.event`) with a
+ * `.Types.*` mirror, and flat-object factories that normalise `some` / `none` /
+ * `variant`.
  *
- * @remarks
- * Represents an event that occupies one or more slots. In `single` mode
- * only `start` is used; in `span` mode `start` and `end` define the
- * inclusive range.
- *
- * Two rich-content slots:
- * - `tooltip` — hover-triggered, a Chakra Tooltip wraps the event bar.
- * - `popover` — click-triggered, a Chakra Popover wraps the event bar.
- *
- * `overlays` paints additional UIComponents (badges, icons, status
- * chips) at axis-aligned positions inside the event bar — same axis
- * pattern as Matrix overlays.
+ * @packageDocumentation
+ */
+import { type ExprType, type SubtypeExprOrValue, type TypeOf, ArrayType, StructType, DictType, OptionType, FunctionType, StringType, FloatType, DateTimeType, NullType } from "@elaraai/east";
+import { UIComponentType } from "../../component.js";
+import { DensityType, type DensityLiteral } from "../../style/interaction.js";
+import { PlannerSlotType, PlannerScaleType, PlannerBucketType, PlannerRangeType, PlannerAxisType, PlannerFlavourType, PlannerStateType, PlannerMarkerType, PlannerAlignType, type PlannerAlignLiteral, PlannerColumnType, PlannerCellType, PlannerVariantType, PlannerSelectEventType, type AxisTimeOptions, type AxisNumberOptions, type AxisOrdinalOptions } from "./types.js";
+import { type StatusValueLiteral } from "../../feedback/status/types.js";
+export { PlannerSlotType, PlannerScaleType, type PlannerScaleLiteral, PlannerBucketType, PlannerRangeType, PlannerAxisType, PlannerFlavourType, PlannerStateType, PlannerMarkerType, PlannerAlignType, type PlannerAlignLiteral, PlannerColumnType, PlannerCellType, PlannerVariantType, PlannerSelectEventType, type AxisOptions, type AxisTimeOptions, type AxisNumberOptions, type AxisOrdinalOptions, } from "./types.js";
+/**
+ * A single placed event. `slot` is the (start) coordinate; `endSlot` is set on
+ * Span events; `bucket` references a declared bucket key (none = unbucketed).
+ * `popover` is the click-triggered rich body (popover-only — there is no
+ * tooltip). Conflict markers are declared separately, on the row's `conflicts`.
  *
- * @property start - Start slot (or single slot if mode=single)
- * @property end - End slot (only used if mode=span)
- * @property label - Optional rich label (text + alignment + typography)
- * @property icon - Optional icon configuration
- * @property colorPalette - Optional color scheme for the event background
- * @property background - Optional background/fill colour (overrides colorPalette)
- * @property stroke - Optional stroke/border colour (overrides colorPalette)
- * @property opacity - Optional opacity (0-1)
- * @property overlays - Per-event overlay annotations
- * @property tooltip - Optional rich tooltip content (hover-triggered, UIComponent)
- * @property popover - Optional rich popover content (click-triggered, UIComponent)
+ * @property slot - The event's (start) slot coordinate
+ * @property endSlot - The span end (Span variant; none for Point)
+ * @property bucket - The declared bucket key the event sits in (none = unbucketed)
+ * @property label - The event's text
+ * @property state - The audit state (see {@link PlannerStateType})
+ * @property key - Optional stable event identity (drag-grammar cell refs)
+ * @property popover - Optional click-triggered rich body (UIComponent)
  */
 export declare const PlannerEventType: StructType<{
-    start: FloatType;
-    end: OptionType<FloatType>;
-    label: OptionType<LabelInputType>;
-    icon: OptionType<EventIconType>;
-    colorPalette: OptionType<ColorSchemeType>;
-    background: OptionType<StringType>;
-    stroke: OptionType<StringType>;
-    opacity: OptionType<FloatType>;
-    overlays: ArrayType<OverlayInputType>;
-    tooltip: OptionType<UIComponentType>;
+    key: OptionType<StringType>;
+    slot: PlannerSlotType;
+    endSlot: OptionType<PlannerSlotType>;
+    bucket: OptionType<StringType>;
+    label: StringType;
+    state: PlannerStateType;
     popover: OptionType<UIComponentType>;
 }>;
 export type PlannerEventType = typeof PlannerEventType;
 /**
- * East type for an Planner row.
+ * One Planner row — a typed resource. `cells` are the left-column values keyed
+ * by column key; `events` is the row's slot timeline; `markers` are the row's
+ * status markers (declared parallel to events, not on them); `group` is the
+ * optional group-head label. Rows are identified by index.
  *
- * @remarks
- * Each row has table cells (displayed on the left) and events (displayed on the right as slots).
- *
- * @property cells - Dict of column key to cell content (same as Table)
- * @property events - Array of events
+ * @property group - Optional group-head label (`groupBy`)
+ * @property cells - The left-column cell values keyed by column key
+ * @property events - The row's events ({@link PlannerEventType})
+ * @property markers - The row's status markers ({@link PlannerMarkerType})
  */
 export declare const PlannerRowType: StructType<{
-    cells: DictType<StringType, typeof TableCellType>;
+    group: OptionType<StringType>;
+    cells: DictType<StringType, PlannerCellType>;
     events: ArrayType<PlannerEventType>;
+    markers: ArrayType<PlannerMarkerType>;
 }>;
+export type PlannerRowType = typeof PlannerRowType;
 /**
- * Type representing the Planner row structure.
+ * The Planner root IR — shared by Point and Span (the `variant` arm
+ * discriminates). Content (`rows` / `columns`), the axis, and behaviour
+ * (`onSelectRow`) sit on the root.
+ *
+ * @property variant - Which chassis configuration (point / span)
+ * @property axis - The axis declaration (scale / buckets / range / format)
+ * @property columns - The left-side columns
+ * @property rows - The rows
+ * @property now - Optional explicit committed/proposed divider; else derived from the data
+ * @property density - Optional density (row / header rhythm)
+ * @property slotMinWidth - Optional min-width (CSS) per x-axis slot column; the timeline scrolls when slots can't fit
+ * @property onSelectRow - Optional row-selection callback
  */
-export type PlannerRowType = typeof PlannerRowType;
+export declare const PlannerRootType: StructType<{
+    readonly variant: import("@elaraai/east").VariantType<{
+        readonly point: NullType;
+        readonly span: NullType;
+    }>;
+    readonly axis: StructType<{
+        readonly scale: import("@elaraai/east").VariantType<{
+            readonly time: NullType;
+            readonly number: NullType;
+            readonly ordinal: NullType;
+        }>;
+        readonly buckets: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly range: OptionType<import("@elaraai/east").VariantType<{
+            readonly time: StructType<{
+                readonly min: DateTimeType;
+                readonly max: DateTimeType;
+            }>;
+            readonly number: StructType<{
+                readonly min: FloatType;
+                readonly max: FloatType;
+            }>;
+            readonly ordinal: ArrayType<StringType>;
+        }>>;
+        readonly format: OptionType<StringType>;
+    }>;
+    readonly columns: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly header: StringType;
+        readonly width: OptionType<StringType>;
+        readonly frozen: OptionType<import("@elaraai/east").BooleanType>;
+        readonly align: OptionType<import("@elaraai/east").VariantType<{
+            readonly start: NullType;
+            readonly end: NullType;
+        }>>;
+    }>>;
+    readonly rows: ArrayType<StructType<{
+        group: OptionType<StringType>;
+        cells: DictType<StringType, PlannerCellType>;
+        events: ArrayType<PlannerEventType>;
+        markers: ArrayType<PlannerMarkerType>;
+    }>>;
+    readonly now: OptionType<import("@elaraai/east").VariantType<{
+        readonly time: DateTimeType;
+        readonly number: FloatType;
+        readonly ordinal: StringType;
+    }>>;
+    readonly density: OptionType<import("@elaraai/east").VariantType<{
+        readonly comfortable: NullType;
+        readonly compact: NullType;
+        readonly condensed: NullType;
+    }>>;
+    readonly slotMinWidth: OptionType<StringType>;
+    readonly onSelectRow: OptionType<FunctionType<[StructType<{
+        readonly rowIndex: import("@elaraai/east").IntegerType;
+    }>], NullType>>;
+}>;
+export type PlannerRootType = typeof PlannerRootType;
 /**
- * Standalone East StructType mirror of the inline `Planner` variant in
- * `component.ts`.
+ * Builds a datetime axis (calendar slots).
+ *
+ * @param options - Buckets, format, and an optional datetime range
+ * @returns An East expression of {@link PlannerAxisType}
  *
  * @remarks
- * main carries content (`rows` / `columns` / `frozen`),
- * timeline configuration (`slotMode` / `minSlot` / `maxSlot` /
- * `stepSize` / `slotLabel` / `boundaries`), structured state
- * (`rowStatus`), and behaviour (callbacks); `style` carries visual
- * fields only. Per-event hover-tooltip and click-popover are now
- * UIComponent slots on each event itself (`event.tooltip`,
- * `event.popover`) — no root-level `eventPopover` callback.
+ * Pass `options.range` to fix the visible extent to a closed datetime interval;
+ * omit it to derive the extent from the data. `options.buckets` subdivides each
+ * slot column into named bands (e.g. AM / PM). `options.format` controls the
+ * tick-label format pattern forwarded to the renderer.
+ * Pair every event and `now` coordinate with {@link slotTime}.
+ */
+declare function axisTime(options?: AxisTimeOptions): ExprType<PlannerAxisType>;
+/**
+ * Builds a numeric axis (day-of-X, hour-of-Y).
+ *
+ * @param options - Buckets, format, and an optional numeric range
+ * @returns An East expression of {@link PlannerAxisType}
  *
- * @property rows - Array of Planner rows
- * @property columns - Array of column definitions (same as Table)
- * @property frozen - Column keys to freeze (pin left)
- * @property slotMode - Slot mode (single / span)
- * @property minSlot - Optional min slot override
- * @property maxSlot - Optional max slot override
- * @property stepSize - Step size for snapping
- * @property slotLabel - Custom slot label function
- * @property boundaries - Vertical boundary lines at specific slot positions
- * @property rowStatus - Row-status callback `(rowIndex) => StatusToken`
- * @property onCellClick - Cell click callback
- * @property onCellDoubleClick - Cell double-click callback
- * @property onRowClick - Row click callback
- * @property onRowDoubleClick - Row double-click callback
- * @property onSortChange - Sort change callback
- * @property onEventClick - Event click callback
- * @property onEventDoubleClick - Event double-click callback
- * @property onEventDrag - Event drag callback (presence enables drag)
- * @property onEventResize - Event resize callback (presence enables resize)
- * @property onEventAdd - Empty-slot click callback (presence enables add)
- * @property onEventEdit - Context-menu edit callback (presence enables edit)
- * @property onEventDelete - Context-menu delete callback (presence enables delete)
- * @property style - Optional visual style sub-struct
+ * @remarks
+ * Pass `options.range` (`{ min, max }`) to fix the slot extent; omit it to
+ * derive the domain from the event coordinates. `options.buckets` subdivides
+ * each slot column into named bands (e.g. AM / PM). `options.format` controls
+ * the tick-label format pattern forwarded to the renderer.
+ * Pair every event and `now` coordinate with {@link slotNumber}.
  */
-export declare const PlannerRootType: StructType<{
-    rows: ArrayType<PlannerRowType>;
-    columns: ArrayType<typeof TableColumnType>;
-    frozen: ArrayType<StringType>;
-    slotMode: OptionType<SlotModeType>;
-    minSlot: OptionType<FloatType>;
-    maxSlot: OptionType<FloatType>;
-    stepSize: OptionType<FloatType>;
-    slotLabel: OptionType<FunctionType<[FloatType], StringType>>;
-    boundaries: OptionType<ArrayType<PlannerBoundaryType>>;
-    rowStatus: OptionType<FunctionType<[IntegerType], StatusTokenType>>;
-    onCellClick: OptionType<FunctionType<[TableCellClickEventType], NullType>>;
-    onCellDoubleClick: OptionType<FunctionType<[TableCellClickEventType], NullType>>;
-    onRowClick: OptionType<FunctionType<[TableRowClickEventType], NullType>>;
-    onRowDoubleClick: OptionType<FunctionType<[TableRowClickEventType], NullType>>;
-    onSortChange: OptionType<FunctionType<[TableSortEventType], NullType>>;
-    onEventClick: OptionType<FunctionType<[EventClickEventType], NullType>>;
-    onEventDoubleClick: OptionType<FunctionType<[EventClickEventType], NullType>>;
-    onEventDrag: OptionType<FunctionType<[EventDragEventType], NullType>>;
-    onEventResize: OptionType<FunctionType<[EventResizeEventType], NullType>>;
-    onEventAdd: OptionType<FunctionType<[EventAddEventType], NullType>>;
-    onEventEdit: OptionType<FunctionType<[EventClickEventType], NullType>>;
-    onEventDelete: OptionType<FunctionType<[EventDeleteEventType], NullType>>;
-    style: OptionType<PlannerStyleType>;
-}>;
+declare function axisNumber(options?: AxisNumberOptions): ExprType<PlannerAxisType>;
 /**
- * Type representing the Planner structure.
+ * Builds an ordinal axis (phase / stage / week-number).
+ *
+ * @param options - Buckets, format, and an optional ordered category range
+ * @returns An East expression of {@link PlannerAxisType}
+ *
+ * @remarks
+ * Pass `options.range` as a `string[]` to fix the column order and set of
+ * visible categories; omit it to derive the domain from the event coordinates.
+ * `options.buckets` subdivides each slot column into named bands.
+ * `options.format` controls the tick-label format pattern forwarded to the
+ * renderer. Pair every event and `now` coordinate with {@link slotOrdinal}.
  */
-export type PlannerRootType = typeof PlannerRootType;
+declare function axisOrdinal(options?: AxisOrdinalOptions): ExprType<PlannerAxisType>;
 /**
- * TypeScript interface for the ergonomic input passed to {@link createEvent}
- * (`Planner.Event`).
+ * Builds a datetime slot coordinate.
+ *
+ * @param d - A `Date` or East `DateTimeType` expression identifying the slot
+ * @returns An East expression of {@link PlannerSlotType} with the `time` arm
  *
  * @remarks
- * The factory normalises this flat input into a fully-shaped East
- * `PlannerEventType` value — wrapping each optional field in its
- * `OptionType` envelope and converting variant string literals
- * (`"blue"`, `"start"`, `"bold"`) to East variant values.
+ * Use wherever a datetime position is required — the `slot` / `endSlot` fields
+ * of an event, the `now` divider on the config, and the `now` option on
+ * {@link axisTime}. Must be paired with a `time`-scale axis ({@link axisTime}).
+ */
+declare function slotTime(d: SubtypeExprOrValue<DateTimeType>): ExprType<PlannerSlotType>;
+/**
+ * Builds a numeric slot coordinate.
  *
- * Every field accepts either a plain JS value or an East expression
- * via {@link SubtypeExprOrValue}.
+ * @param n - A number or East `FloatType` expression identifying the slot
+ * @returns An East expression of {@link PlannerSlotType} with the `number` arm
  *
- * @property start - Start slot (or single slot if mode=single)
- * @property end - End slot (only used if mode=span)
- * @property label - Optional rich label (text + alignment + typography)
- * @property icon - Optional Font Awesome icon configuration
- * @property colorPalette - Color scheme for the event background
- * @property background - Explicit background/fill colour (overrides colorPalette)
- * @property stroke - Explicit stroke/border colour (overrides colorPalette)
- * @property opacity - Opacity (0-1)
- * @property overlays - Axis-aligned UIComponent overlays painted inside the bar
- * @property tooltip - Hover-triggered rich tooltip content (UIComponent)
- * @property popover - Click-triggered rich popover content (UIComponent), coexists with `onEventClick`
+ * @remarks
+ * Use wherever a numeric position is required — the `slot` / `endSlot` fields
+ * of an event, the `now` divider on the config, and the `now` option on
+ * {@link axisNumber}. Must be paired with a `number`-scale axis ({@link axisNumber}).
  */
-export interface EventInput {
-    /** Start slot (or single slot if mode=single) */
-    start: SubtypeExprOrValue<FloatType>;
-    /** End slot (only used if mode=span) */
-    end?: SubtypeExprOrValue<FloatType>;
-    /** Optional rich label (text + alignment + typography) */
-    label?: LabelInput;
-    /** Optional Font Awesome icon configuration */
-    icon?: EventIcon;
-    /** Color scheme for the event background */
-    colorPalette?: SubtypeExprOrValue<ColorSchemeType> | ColorSchemeLiteral;
-    /** Explicit background/fill colour (overrides colorPalette) */
-    background?: SubtypeExprOrValue<StringType>;
-    /** Explicit stroke/border colour (overrides colorPalette) */
-    stroke?: SubtypeExprOrValue<StringType>;
-    /** Opacity (0-1) */
-    opacity?: SubtypeExprOrValue<FloatType>;
-    /** Axis-aligned UIComponent overlays painted inside the bar */
-    overlays?: PlannerOverlayInput[];
-    /** Hover-triggered rich tooltip content (UIComponent) */
-    tooltip?: SubtypeExprOrValue<UIComponentType>;
-    /** Click-triggered rich popover content (UIComponent). Coexists with `onEventClick`. */
-    popover?: SubtypeExprOrValue<UIComponentType>;
-}
+declare function slotNumber(n: SubtypeExprOrValue<FloatType>): ExprType<PlannerSlotType>;
 /**
- * TypeScript interface for a Planner event overlay — UIComponent painted
- * at an axis-aligned position inside the event bar.
+ * Builds an ordinal slot coordinate.
+ *
+ * @param s - A string or East `StringType` expression naming the category
+ * @returns An East expression of {@link PlannerSlotType} with the `ordinal` arm
  *
  * @remarks
- * Mirrors the Matrix overlay pattern. Defaults (when align /
- * verticalAlign omitted) are `"center"` / `"center"`. Pointer events
- * pass through the overlay so drag / click / popover triggers still hit
- * the bar.
+ * Use wherever a category label is required — the `slot` / `endSlot` fields of
+ * an event, the `now` divider on the config, and the `now` option on
+ * {@link axisOrdinal}. The string must match one of the category labels
+ * declared in `options.range` (or present in the data when range is omitted).
+ * Must be paired with an `ordinal`-scale axis ({@link axisOrdinal}).
+ */
+declare function slotOrdinal(s: SubtypeExprOrValue<StringType>): ExprType<PlannerSlotType>;
+/**
+ * Flat input for {@link createEvent} (`Planner.event`).
  *
- * @property content - The UIComponent painted at the chosen corner
- * @property align - Horizontal alignment (start / center / end). Default `"center"`.
- * @property verticalAlign - Vertical alignment (start / center / end). Default `"center"`.
+ * @property slot - The event's (start) slot coordinate
+ * @property endSlot - The span end (Span variant only)
+ * @property bucket - The declared bucket key the event sits in
+ * @property label - The event's text
+ * @property state - The audit state — a `PlannerStateType` value or a string shorthand
+ * @property popover - Optional click-triggered rich body (UIComponent)
  */
-export interface PlannerOverlayInput {
-    /** The UIComponent painted at the chosen corner */
-    content: SubtypeExprOrValue<UIComponentType>;
-    /** Horizontal alignment (start / center / end). Default `"center"`. */
-    align?: AlignLiteral | SubtypeExprOrValue<AlignType>;
-    /** Vertical alignment (start / center / end). Default `"center"`. */
-    verticalAlign?: AlignLiteral | SubtypeExprOrValue<AlignType>;
+export interface EventInput {
+    /** Optional stable event identity — referenced by drag-grammar cell refs. */
+    key?: SubtypeExprOrValue<StringType>;
+    /** The event's (start) slot coordinate. */
+    slot: SubtypeExprOrValue<PlannerSlotType>;
+    /** The span end (Span variant only). */
+    endSlot?: SubtypeExprOrValue<PlannerSlotType>;
+    /** The declared bucket key the event sits in. */
+    bucket?: SubtypeExprOrValue<StringType>;
+    /** The event's text. */
+    label: SubtypeExprOrValue<StringType>;
+    /** The audit state — a `PlannerStateType` value, or one of the string shorthands. */
+    state: SubtypeExprOrValue<PlannerStateType> | "committed" | "rejected" | "added" | "model" | "removed";
+    /** Optional click-triggered rich body (UIComponent). */
+    popover?: SubtypeExprOrValue<UIComponentType>;
 }
 /**
- * Builds a single Planner event East value from an ergonomic TS input.
+ * Builds a single Planner event from a flat TS input. Normalises optional fields
+ * into their `OptionType` envelopes and resolves the `state` string shorthands
+ * (`"committed"` / `"rejected"` / `"added"` / `"model"` / `"removed"`).
  *
- * @param input - Event configuration ({@link EventInput})
+ * @param input - The event configuration ({@link EventInput})
  * @returns An East expression of {@link PlannerEventType}
+ */
+declare function createEvent(input: EventInput): ExprType<PlannerEventType>;
+/**
+ * Flat input for {@link createMarker} (`Planner.marker`).
  *
- * @remarks
- * Use inside the `events` callback of {@link createPlanner}. The callback
- * returns `SubtypeExprOrValue<ArrayType<PlannerEventType>>`, so callers
- * pass either an East-side ArrayExpr (e.g. mapping over an East array
- * field) or a plain JS array of values built by this factory. The
- * factory normalises optional fields (`label` / `icon` / `colorPalette`
- * / `tooltip` / `popover` / `overlays`) into their `OptionType`
- * envelopes and converts variant string literals (`"blue"`, `"start"`,
- * `"bold"`) to East variant values — so callers don't have to reach
- * for `some` / `none` / `variant(...)` directly.
+ * @property slot - The slot coordinate of the cell the marker rings
+ * @property status - The semantic status — drives the colour + paired icon (`"danger"` default)
+ * @property message - The marker text surfaced as a hover tooltip
+ */
+export interface MarkerInput {
+    /** The slot coordinate of the cell the marker rings. */
+    slot: SubtypeExprOrValue<PlannerSlotType>;
+    /** The semantic status (success / warning / danger / info / neutral). Defaults to `"danger"`. */
+    status?: StatusValueLiteral;
+    /** The marker text surfaced as a hover tooltip. */
+    message: SubtypeExprOrValue<StringType>;
+}
+/**
+ * Builds a single status marker from a flat input — declared parallel to events
+ * (in a row's `markers`), not on an event. The renderer rings the cell at `slot`,
+ * paints the paired status icon in the corner, and shows `message` on hover.
  *
- * @example
- * ```ts
- * import { East } from "@elaraai/east";
- * import { Planner, UIComponentType } from "@elaraai/east-ui";
+ * @param input - The marker configuration ({@link MarkerInput})
+ * @returns An East expression of {@link PlannerMarkerType}
+ */
+declare function createMarker(input: MarkerInput): ExprType<PlannerMarkerType>;
+type Accessor<R extends StructType> = (row: ExprType<R>) => SubtypeExprOrValue<StringType>;
+/**
+ * A left-side column definition. `value` is the cell text — a field or an East
+ * expression (a derived column is just `value: r => East.print(...)`, recomputed
+ * reactively); `sublabel` is the optional muted eyebrow line.
  *
- * const example = East.function([], UIComponentType, _$ => {
- *     return Planner.Root(
- *         [{ name: "Alice", start: 1.0, end: 4.0 }],
- *         ["name"],
- *         row => [Planner.Event({
- *             start: row.start,
- *             end: row.end,
- *             label: { value: "Task", color: "white" },
- *             colorPalette: "blue",
- *         })],
- *     );
- * });
- * ```
+ * @property key - The column identity and the row's cell key
+ * @property header - Optional header text (defaults to `key`)
+ * @property width - Optional CSS width
+ * @property frozen - Whether the column is pinned sticky-left
+ * @property align - Optional horizontal alignment
+ * @property value - The cell text accessor over the row
+ * @property sublabel - The optional muted eyebrow accessor over the row
  */
-declare function createEvent(input: EventInput): ExprType<PlannerEventType>;
-type ExtractStructFields<T> = T extends ArrayType<infer S> ? S extends StructType ? S["fields"] : never : never;
-type ExtractElement<T> = T extends ArrayType<infer E> ? E : never;
-type ExtractRowType<T> = T extends ArrayType<infer S> ? S extends StructType ? S : StructType : StructType;
-type DataFields<T extends SubtypeExprOrValue<ArrayType<StructType>>> = ExtractStructFields<TypeOf<T>>;
-type RowElement<T extends SubtypeExprOrValue<ArrayType<StructType>>> = ExtractElement<TypeOf<T>>;
-type DataRowType<T extends SubtypeExprOrValue<ArrayType<StructType>>> = ExtractRowType<TypeOf<T>>;
-type ColumnSpec<T extends SubtypeExprOrValue<ArrayType<StructType>>> = (keyof DataFields<NoInfer<T>>)[] | {
-    [K in keyof DataFields<NoInfer<T>>]?: TableColumnConfig<DataFields<NoInfer<T>>[K], DataRowType<NoInfer<T>>>;
-};
-type DataFieldKeys<T extends SubtypeExprOrValue<ArrayType<StructType>>> = Extract<keyof DataFields<NoInfer<T>>, string>;
+export interface PlannerColumnDef<R extends StructType> {
+    /** The column identity and the row's cell key. */
+    key: string;
+    /** Optional header text (defaults to `key`). */
+    header?: string;
+    /** Optional CSS width. */
+    width?: string;
+    /** Whether the column is pinned sticky-left. */
+    frozen?: boolean;
+    /** Optional horizontal alignment. */
+    align?: PlannerAlignLiteral;
+    /** The cell text accessor over the row. */
+    value: Accessor<R>;
+    /** The optional muted eyebrow accessor over the row. */
+    sublabel?: Accessor<R>;
+}
+/**
+ * Configuration for {@link createPoint} / {@link createSpan}.
+ *
+ * @typeParam R - The struct type of each data row
+ * @property axis - The axis declaration (use `Planner.axis.*`)
+ * @property columns - The left-side columns
+ * @property events - Per-row accessor returning the row's events
+ * @property markers - Optional per-row accessor returning the row's status markers (parallel to events)
+ * @property groupBy - Optional per-row accessor returning the group-head label
+ * @property now - Optional explicit committed/proposed divider slot
+ * @property density - Optional density
+ * @property slotMinWidth - Optional min-width (CSS) per x-axis slot column; the timeline scrolls horizontally when slots would otherwise be squeezed below it
+ * @property onSelectRow - Optional row-selection callback
+ */
+export interface PlannerConfig<R extends StructType> {
+    /** The axis declaration (use `Planner.axis.*`). */
+    axis: SubtypeExprOrValue<PlannerAxisType>;
+    /** The left-side columns. */
+    columns: PlannerColumnDef<R>[];
+    /** Per-row accessor returning the row's events. */
+    events: (row: ExprType<R>) => SubtypeExprOrValue<ArrayType<PlannerEventType>>;
+    /** Optional per-row accessor returning the row's status markers. */
+    markers?: (row: ExprType<R>) => SubtypeExprOrValue<ArrayType<PlannerMarkerType>>;
+    /** Optional per-row accessor returning the group-head label. */
+    groupBy?: (row: ExprType<R>) => SubtypeExprOrValue<StringType>;
+    /** Optional explicit committed/proposed divider slot. */
+    now?: SubtypeExprOrValue<PlannerSlotType>;
+    /** Optional density (row / header rhythm). */
+    density?: SubtypeExprOrValue<DensityType> | DensityLiteral;
+    /** Optional min-width (CSS) per x-axis slot column. With it set, the
+     *  timeline scrolls horizontally rather than squeezing slots below it. */
+    slotMinWidth?: SubtypeExprOrValue<StringType>;
+    /** Optional row-selection callback. */
+    onSelectRow?: SubtypeExprOrValue<FunctionType<[PlannerSelectEventType], NullType>>;
+}
+export type RowElement<T extends SubtypeExprOrValue<ArrayType<StructType>>> = TypeOf<T> extends ArrayType<infer S> ? (S extends StructType ? S : never) : never;
 /**
- * Creates an Planner component following the Table/Gantt pattern.
+ * Creates a Point Planner — slot-bound events (each event sits in one
+ * slot/bucket). The Roster default.
  *
- * @typeParam T - The struct type of each data row
- * @param data - Array of data structs
- * @param columns - Column specification for the left-side table columns
- * @param events - Function to extract events from each row
- * @param style - Optional Planner styling
- * @returns An East expression representing the Planner component
+ * @typeParam R - The struct type of each data row
+ * @param data - The rows
+ * @param config - The Planner configuration ({@link PlannerConfig})
+ * @returns An East expression of `UIComponentType`
  *
  * @example
  * ```ts
- * import { East, IntegerType, StringType } from "@elaraai/east";
+ * import { East } from "@elaraai/east";
  * import { Planner, UIComponentType } from "@elaraai/east-ui";
  *
- * const example = East.function([], UIComponentType, $ => {
- *     return Planner.Root(
- *         [
- *             { name: "Alice", start: 1n, end: 3n },
- *             { name: "Bob", start: 2n, end: 5n },
- *         ],
- *         ["name"],
- *         row => [{ start: row.start, end: row.end }],
+ * const example = East.function([], UIComponentType, _$ =>
+ *     Planner.Point(
+ *         [{ id: "a", name: "Alice", events: [] }],
  *         {
- *             slotLabel: East.function([IntegerType], StringType, ($, slot) => {
- *                 return East.str`Day ${slot}`;
- *             }),
- *         }
- *     );
- * });
+ *             axis: Planner.axis.number({ buckets: [{ key: "am", label: "AM" }, { key: "pm", label: "PM" }] }),
+ *             columns: [{ key: "name", frozen: true, value: r => r.name }],
+ *             events: r => r.events,
+ *         },
+ *     ),
+ * );
  * ```
  */
-declare function createPlanner<T extends SubtypeExprOrValue<ArrayType<StructType>>, C extends ColumnSpec<T> = ColumnSpec<T>>(data: T, columns: C, events: (row: ExprType<RowElement<T>>) => SubtypeExprOrValue<ArrayType<PlannerEventType>>, style?: PlannerStyle<DataFieldKeys<T>>): ExprType<UIComponentType>;
-/** Type for the Planner namespace */
-interface PlannerNamespace {
-    Root: typeof createPlanner;
-    Event: typeof createEvent;
+declare function createPoint<T extends SubtypeExprOrValue<ArrayType<StructType>>>(data: T, config: PlannerConfig<RowElement<T>>): ExprType<UIComponentType>;
+/**
+ * Creates a Span Planner — multi-slot span events (start → end).
+ *
+ * @typeParam R - The struct type of each data row
+ * @param data - The rows
+ * @param config - The Planner configuration ({@link PlannerConfig})
+ * @returns An East expression of `UIComponentType`
+ */
+declare function createSpan<T extends SubtypeExprOrValue<ArrayType<StructType>>>(data: T, config: PlannerConfig<RowElement<T>>): ExprType<UIComponentType>;
+/**
+ * The type of the {@link Planner} namespace. Declared explicitly (rather than
+ * inferred from `as const`) so the declaration emit stays within TypeScript's
+ * serialization limit.
+ */
+export interface PlannerNamespace {
+    /** Creates a Point Planner (slot-bound events). */
+    Point: typeof createPoint;
+    /** Creates a Span Planner (multi-slot span events). */
+    Span: typeof createSpan;
+    /** Typed axis builders — `time` / `number` / `ordinal`. */
+    axis: {
+        /**
+         * Builds a datetime axis (calendar slots).
+         *
+         * @remarks
+         * Accepts an optional datetime range, bucket list, and format string.
+         * Pair every event and `now` coordinate with `Planner.at.time`.
+         */
+        time: typeof axisTime;
+        /**
+         * Builds a numeric axis (day-of-X, hour-of-Y).
+         *
+         * @remarks
+         * Accepts an optional `{ min, max }` numeric range, bucket list, and
+         * format string. Pair every event and `now` coordinate with
+         * `Planner.at.number`.
+         */
+        number: typeof axisNumber;
+        /**
+         * Builds an ordinal axis (phase / stage / week-number).
+         *
+         * @remarks
+         * Accepts an optional ordered `string[]` range, bucket list, and format
+         * string. Pair every event and `now` coordinate with
+         * `Planner.at.ordinal`.
+         */
+        ordinal: typeof axisOrdinal;
+    };
+    /** Slot-coordinate shorthands — `time` / `number` / `ordinal`. */
+    at: {
+        /**
+         * Wraps a `Date` or `DateTimeType` expression in the `time` arm of
+         * {@link PlannerSlotType}.
+         *
+         * @remarks
+         * Must be paired with a `time`-scale axis (`Planner.axis.time`).
+         */
+        time: typeof slotTime;
+        /**
+         * Wraps a number or `FloatType` expression in the `number` arm of
+         * {@link PlannerSlotType}.
+         *
+         * @remarks
+         * Must be paired with a `number`-scale axis (`Planner.axis.number`).
+         */
+        number: typeof slotNumber;
+        /**
+         * Wraps a string or `StringType` expression in the `ordinal` arm of
+         * {@link PlannerSlotType}.
+         *
+         * @remarks
+         * The string must name a category present in the axis range.
+         * Must be paired with an `ordinal`-scale axis (`Planner.axis.ordinal`).
+         */
+        ordinal: typeof slotOrdinal;
+    };
+    /** Builds a single event from a flat input. */
+    event: typeof createEvent;
+    /** Builds a single status marker from a flat input (parallel to events). */
+    marker: typeof createMarker;
+    /** The Planner East types. */
     Types: {
+        /** The Planner root IR ({@link PlannerRootType}). */
         Root: typeof PlannerRootType;
-        Row: typeof PlannerRowType;
+        /** Which chassis configuration (point / span). */
+        Variant: typeof PlannerVariantType;
+        /** A typed slot coordinate (time / number / ordinal). */
+        Slot: typeof PlannerSlotType;
+        /** The axis scale kind. */
+        Scale: typeof PlannerScaleType;
+        /** A labelled sub-slot bucket. */
+        Bucket: typeof PlannerBucketType;
+        /** An explicit axis domain. */
+        Range: typeof PlannerRangeType;
+        /** The axis declaration. */
+        Axis: typeof PlannerAxisType;
+        /** The proposed sub-flavour. */
+        Flavour: typeof PlannerFlavourType;
+        /** The three event states. */
+        State: typeof PlannerStateType;
+        /** A status marker (slot + status + message). */
+        Marker: typeof PlannerMarkerType;
+        /** A single placed event. */
         Event: typeof PlannerEventType;
-        Label: typeof LabelInputType;
-        EventIcon: typeof EventIconType;
-        Align: typeof AlignType;
-        Style: typeof PlannerStyleType;
-        SlotMode: typeof SlotModeType;
-        Boundary: typeof PlannerBoundaryType;
-        ClickEvent: typeof EventClickEventType;
-        DragEvent: typeof EventDragEventType;
-        ResizeEvent: typeof EventResizeEventType;
-        AddEvent: typeof EventAddEventType;
-        DeleteEvent: typeof EventDeleteEventType;
-        Column: typeof TableColumnType;
-        Cell: typeof TableCellType;
+        /** A column's horizontal alignment. */
+        Align: typeof PlannerAlignType;
+        /** A left-side column. */
+        Column: typeof PlannerColumnType;
+        /** A per-row cell (value + eyebrow). */
+        Cell: typeof PlannerCellType;
+        /** A Planner row. */
+        Row: typeof PlannerRowType;
+        /** The `onSelectRow` payload. */
+        SelectEvent: typeof PlannerSelectEventType;
     };
 }
 /**
- * Planner namespace for creating integer-slot-based scheduling components.
- *
- * @remarks
- * Planner displays rows with integer-based events (slots).
- * Each row has table columns on the left and a slot grid with events on the right.
- * The API follows the Table/Gantt pattern for column configuration.
+ * The `Planner` namespace — the discrete `rows × ordered slots` scheduling
+ * primitive. Assemble a Planner with `Planner.Point` / `Planner.Span`, declare
+ * the axis with `Planner.axis.*`, place events with `Planner.event` /
+ * `Planner.at.*`, and reach every East type via `Planner.Types.*`.
  */
 export declare const Planner: PlannerNamespace;
 //# sourceMappingURL=index.d.ts.map