@art-tools/react-gantt 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1042 @@
+import { ComponentProps } from 'react';
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { ElementType } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * Key of the built-in edit/add/delete column, dropped when `readOnly` is set.
+ *
+ * Exported so a consumer can extend the built-in set rather than replace it:
+ * `[...DEFAULT_COLUMNS.filter((c) => c.key !== ACTION_COLUMN_KEY), myColumn]`.
+ */
+export declare const ACTION_COLUMN_KEY = "__action";
+
+declare interface BarA11yProps {
+    role: string;
+    "aria-colindex": number;
+    "aria-colspan": number;
+    "aria-label": string;
+    "aria-selected": boolean | undefined;
+    title: string;
+}
+
+/** State passed to the function form of each BarProgress slotProps. */
+export declare interface BarProgressOwnerState {
+    progress: number;
+    width: number;
+    height: number;
+}
+
+/** State passed to the function form of the BarProgressResizeHandle slotProps. */
+export declare interface BarProgressResizeHandleOwnerState {
+    width: number;
+    parentWidth: number;
+}
+
+export declare type BarProgressResizeHandleSlotConfig = SlotConfig<BarProgressResizeHandleSlots, BarProgressResizeHandleSlotProps>;
+
+export declare interface BarProgressResizeHandleSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, BarProgressResizeHandleOwnerState>;
+}
+
+export declare interface BarProgressResizeHandleSlots {
+    /** The progress resize handle element. Default: `"div"`. */
+    root?: ElementType;
+}
+
+/** Slot config for the bar progress fill. */
+export declare type BarProgressSlotConfig = SlotConfig<BarProgressSlots, BarProgressSlotProps>;
+
+export declare interface BarProgressSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, BarProgressOwnerState>;
+}
+
+export declare interface BarProgressSlots {
+    /** The progress fill element. Default: `"div"`. */
+    root?: ElementType;
+}
+
+/** Axis-aligned pixel bounds. */
+export declare interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+
+export declare function Calendar({ colWidth, rowHeight, scales, dates, colRange, }: CalendarProps): JSX.Element;
+
+/** State passed to the function form of the CalendarRow `cell` slotProps (per group). */
+export declare interface CalendarCellOwnerState {
+    scale: Scale;
+    /** Start date of the group this cell represents. */
+    date: Date;
+    /** Index of the group's first date column. */
+    startIndex: number;
+    /** Number of date columns the group spans. */
+    count: number;
+    /**
+     * Whether the calendar excludes this cell from working time. Prefer this over
+     * {@link CalendarCellOwnerState.isWeekend} — it also covers holidays.
+     */
+    isNonWorking: boolean;
+    /** Why the cell is non-working, for styling weekends and holidays apart. */
+    nonWorkingReason?: NonWorkingReason;
+    /**
+     * @deprecated Use {@link CalendarCellOwnerState.isNonWorking}. Retained as an
+     * alias so existing slot code keeps working.
+     */
+    isWeekend: boolean;
+    colWidth: number;
+}
+
+export declare type CalendarProps = {
+    colWidth: number;
+    rowHeight: number;
+    scales?: Scale[];
+    dates: Date[];
+    /** Half-open range of date indices in view (virtualization window). */
+    colRange: IndexRange;
+};
+
+/** State passed to the function form of the CalendarRow `row` slotProps. */
+export declare interface CalendarRowOwnerState {
+    scale: Scale;
+    colWidth: number;
+    rowHeight: number;
+    highlightWeekends: boolean;
+}
+
+/**
+ * Slot config for a calendar (header) row. Pass via the calendar's slot props.
+ *
+ * NOTE: pass a referentially stable / memoized object so downstream memoization
+ * is not defeated by a fresh object each render.
+ */
+export declare type CalendarRowSlotConfig = SlotConfig<CalendarRowSlots, CalendarRowSlotProps>;
+
+export declare interface CalendarRowSlotProps {
+    row?: SlotPropsInput<ComponentProps<"div">, CalendarRowOwnerState>;
+    cell?: SlotPropsInput<ComponentProps<"div">, CalendarCellOwnerState>;
+}
+
+export declare interface CalendarRowSlots {
+    /** The row container. Default: `"div"`. */
+    row?: ElementType;
+    /** A per-group header cell. Default: `"div"`. */
+    cell?: ElementType;
+}
+
+export declare type CalendarUnit = "minute" | "hour" | "day" | "week" | "month" | "quarter" | "year";
+
+/** API passed as the 2nd arg to `ColumnDef.render`, for building actionable columns. */
+export declare interface ColumnApi extends GanttHandle {
+    /** Fires the consumer's `onTaskEdit` callback for this task. */
+    editTask: (task: GanttTask) => void;
+    /**
+     * The chart's `readOnly` prop. The mutating members above still work (they are
+     * the imperative API — see ADR-021), so a column that renders edit/delete
+     * controls should check this and render nothing instead.
+     */
+    readOnly: boolean;
+    /** Resolved accessible strings, for labelling controls a column renders.
+     *  `ColumnDef.render` is a plain function, not a component, so it can't call
+     *  `useGanttLabels()` — this is its channel to the `labels` prop. */
+    labels: ResolvedGanttLabels;
+    /**
+     * Display helpers that already know the chart's calendar and `durationUnit` —
+     * the same channel as `labels`, for the same reason.
+     *
+     * Stored dates are exclusive instants, which read wrong in a column: a task
+     * running Monday to Friday stores Saturday. Use these to show a user-facing
+     * end date or duration rather than formatting `task.endDate` directly.
+     */
+    format: {
+        /** The inclusive last-occupied day, or `undefined` for an instant. */
+        endDate: (task: GanttTask) => Date | undefined;
+        /** Working time the task occupies, in the chart's `durationUnit`. */
+        duration: (task: GanttTask) => number;
+    };
+}
+
+export declare interface ColumnDef<T extends GanttTask = GanttTask> {
+    key: string;
+    header: string;
+    width?: number;
+    render: (task: T, api: ColumnApi) => default_2.ReactNode;
+    isTreeColumn?: boolean;
+}
+
+declare type ConnectorHandle = "start" | "end";
+
+/** State passed to the function form of each ConnectorHandles slotProps. */
+export declare interface ConnectorHandlesOwnerState {
+    taskId: Id;
+    barLeft: number;
+    barWidth: number;
+    barCenterY: number;
+    show: boolean;
+    isDragging: boolean;
+}
+
+export declare type ConnectorHandlesSlotConfig = SlotConfig<ConnectorHandlesSlots, ConnectorHandlesSlotProps>;
+
+export declare interface ConnectorHandlesSlotProps {
+    startHandle?: SlotPropsInput<ComponentProps<"div">, ConnectorHandlesOwnerState>;
+    endHandle?: SlotPropsInput<ComponentProps<"div">, ConnectorHandlesOwnerState>;
+}
+
+export declare interface ConnectorHandlesSlots {
+    /** The left/start dependency-connector handle. Default: `"div"`. */
+    startHandle?: ElementType;
+    /** The right/end dependency-connector handle. Default: `"div"`. */
+    endHandle?: ElementType;
+}
+
+/**
+ * Working hours for a single day, or `false` for a day off. Gaps *between*
+ * ranges are non-working — that is how a lunch break is expressed:
+ * `["8:00-12:00", "13:00-17:00"]`.
+ */
+export declare type DayHours = WorkTimeRange[] | false;
+
+/**
+ * The columns `<Gantt>` renders when no `columns` prop is given.
+ *
+ * Treat as immutable — it is module state shared by every chart on the page.
+ */
+export declare const DEFAULT_COLUMNS: ColumnDef[];
+
+/** Index of the default (month / day) rung in {@link DEFAULT_ZOOM_LEVELS}. */
+export declare const DEFAULT_ZOOM_INDEX = 3;
+
+/**
+ * Default zoom ladder, ordered coarse → fine. Zooming in moves toward finer
+ * (higher-index) levels; each rung pairs a coarse header row with a finer
+ * bottom row whose unit is the column unit.
+ */
+export declare const DEFAULT_ZOOM_LEVELS: ZoomLevel[];
+
+/** State passed to the `deleteButton` slotProps. */
+export declare interface DependencyDeleteButtonOwnerState {
+    /** The dependency the button will delete when clicked. */
+    dependency: TaskDependency;
+}
+
+declare interface DependencyDragState {
+    fromTaskId: Id;
+    handle: ConnectorHandle;
+    startX: number;
+    startY: number;
+    currentX: number;
+    currentY: number;
+}
+
+/** State passed to the `lagLabel` slotProps. */
+export declare interface DependencyLagLabelOwnerState extends DependencyLinkOwnerState {
+    /** The lag value in days (non-zero when the label renders). */
+    lag: number;
+}
+
+export declare interface DependencyLink {
+    /** Stable key, e.g. `"1->2"`. */
+    id: string;
+    type: TaskDependencyType;
+    /** Orthogonal polyline from the source edge to the target edge. */
+    points: Point[];
+    /** Bounding box of {@link DependencyLink.points}, precomputed for culling. */
+    bounds: Bounds;
+    /** The original dependency for callbacks. */
+    dep: TaskDependency;
+}
+
+/** State shared by the per-link slots (`arrow`). */
+export declare interface DependencyLinkOwnerState {
+    /** The dependency link being rendered. */
+    link: DependencyLink;
+    /** Whether this link is currently selected. */
+    isSelected: boolean;
+}
+
+/** State passed to the function form of the `layer` slotProps. */
+export declare interface DependencyLinksLayerOwnerState {
+    width: number;
+    height: number;
+    /** Number of dependency links currently in the layer. */
+    linkCount: number;
+}
+
+/** Slot config for the dependency links layer. */
+export declare type DependencyLinksSlotConfig = SlotConfig<DependencyLinksSlots, DependencyLinksSlotProps>;
+
+export declare interface DependencyLinksSlotProps {
+    layer?: SlotPropsInput<ComponentProps<"div">, DependencyLinksLayerOwnerState>;
+    segment?: SlotPropsInput<ComponentProps<"div">, DependencySegmentOwnerState>;
+    arrow?: SlotPropsInput<ComponentProps<"div">, DependencyLinkOwnerState>;
+    lagLabel?: SlotPropsInput<ComponentProps<"div">, DependencyLagLabelOwnerState>;
+    deleteButton?: SlotPropsInput<ComponentProps<"button">, DependencyDeleteButtonOwnerState>;
+}
+
+export declare interface DependencyLinksSlots {
+    /** The absolutely-positioned links layer container. Default: `"div"`. */
+    layer?: ElementType;
+    /** A single visible link segment. Default: `"div"`. */
+    segment?: ElementType;
+    /** The arrowhead at the target end of a link. Default: `"div"`. */
+    arrow?: ElementType;
+    /** The `+Nd` / `-Nd` lag label. Default: `"div"`. */
+    lagLabel?: ElementType;
+    /** The `×` delete button shown for the selected link. Default: `"button"`. */
+    deleteButton?: ElementType;
+}
+
+/** State passed to the function form of the `root` slotProps. */
+export declare interface DependencyPreviewOwnerState {
+    /** The in-progress dependency drag. */
+    drag: DependencyDragState;
+    /** Horizontal length of the rubber-band, in pixels. */
+    length: number;
+    /** Rotation of the rubber-band, in degrees. */
+    angle: number;
+}
+
+/** Slot config for the dependency drag preview. */
+export declare type DependencyPreviewSlotConfig = SlotConfig<DependencyPreviewSlots, DependencyPreviewSlotProps>;
+
+export declare interface DependencyPreviewSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, DependencyPreviewOwnerState>;
+}
+
+export declare interface DependencyPreviewSlots {
+    /** The rubber-band preview line. Default: `"div"`. */
+    root?: ElementType;
+}
+
+/** State passed to the `segment` slotProps, per visible segment of a link. */
+export declare interface DependencySegmentOwnerState extends DependencyLinkOwnerState {
+    /** Start point of this segment. */
+    from: Point;
+    /** End point of this segment. */
+    to: Point;
+    /** Index of this segment within the link's polyline. */
+    index: number;
+}
+
+/**
+ * The inclusive last-occupied civil day, for **display only**.
+ *
+ * Stored dates are exclusive instants, which reads wrong in a column: a task
+ * running Monday through Friday stores Saturday. This converts back for humans —
+ * the day containing the last worked moment. Never write the result back to a task.
+ */
+export declare function displayEndDate(startDate: Date, endInstant: Date): Date;
+
+/** The unit an input `duration` is expressed in, and the unit it displays in. */
+export declare type DurationUnit = "day" | "hour" | "minute";
+
+/**
+ * Inverse of {@link displayEndDate} for a whole-day edit: the exclusive instant
+ * starting the day after `displayEnd`.
+ *
+ * This is what a `<input type="date">` end-date editor needs — the user picks the
+ * last day they mean, and the task stores the following midnight.
+ */
+export declare function endInstantFromDisplayDate(displayEnd: Date): Date;
+
+export declare function Gantt({ tasks, dependencies, rowHeight, colWidth, height, scales, padDays, zoomLevels, defaultZoomIndex, onZoomChange, zoomWheel, zoomKeyboard, onTaskClick, columns: columnsProp, defaultTaskListWidth, onDependencyCreate, onDependencyDelete, onTaskCreate, onTaskDelete, onTaskEdit, onTasksChange, calendar, snapToWorking, durationUnit, readOnly, apiRef, hideTaskList, taskList, bars, dependencySlots, timeline, labels, }: GanttProps): JSX.Element;
+
+/** Slots for the timeline bars and their handles. Delivered via context. */
+export declare interface GanttBarsSlots {
+    taskBar?: TaskBarSlotConfig;
+    projectBar?: ProjectBarSlotConfig;
+    milestoneBar?: MilestoneBarSlotConfig;
+    barProgress?: BarProgressSlotConfig;
+    barProgressResizeHandle?: BarProgressResizeHandleSlotConfig;
+    taskResizer?: TaskResizerSlotConfig;
+    connectorHandles?: ConnectorHandlesSlotConfig;
+}
+
+/**
+ * The chart's working-time calendar. Three scopes resolve in the order
+ * `dates` → `days` → `hours`, so a specific date beats a weekday rule, which
+ * beats the global default.
+ *
+ * Passing a calendar at all is the opt-in: with no `calendar` prop the chart
+ * schedules in plain linear time exactly as it did before this feature existed.
+ *
+ * The object may be written inline — it is keyed by content, not identity, so a
+ * fresh-but-equal object on every render costs nothing.
+ */
+export declare interface GanttCalendar {
+    /**
+     * Working hours for every day with no override below. Omitted means the
+     * *full* day (`"0:00-24:00"`), so a calendar that only lists weekend days off
+     * stays day-granular rather than silently acquiring business hours.
+     */
+    hours?: DayHours;
+    /** Per-weekday override. Beats {@link GanttCalendar.hours}. */
+    days?: Partial<Record<Weekday, DayHours>>;
+    /**
+     * Per-date override keyed by local civil date, `"YYYY-MM-DD"`. Beats both
+     * {@link GanttCalendar.days} and {@link GanttCalendar.hours}. Use it for
+     * holidays (`false`), half days, or a one-off working Saturday.
+     */
+    dates?: Record<string, DayHours>;
+}
+
+/** Slots for dependency links. Delivered via context. */
+export declare interface GanttDependenciesSlots {
+    links?: DependencyLinksSlotConfig;
+    preview?: DependencyPreviewSlotConfig;
+}
+
+/**
+ * Everything the chart engine needs: data, callbacks, scheduling, zoom.
+ *
+ * Shared verbatim by `<Gantt>` and `<GanttProvider>` — `<Gantt>` destructures
+ * every one of these and forwards it untouched, then adds layout and slots of its
+ * own. Declared once so the two cannot drift apart, which they already had:
+ * `GanttProps.height` was required while the provider's was optional, with a doc
+ * on the required one saying "omit to grow with content".
+ */
+export declare interface GanttEngineProps {
+    tasks: GanttTask[];
+    rowHeight?: number;
+    colWidth?: number;
+    /** Total component height in px. When set, rows scroll vertically within it
+     *  (calendar/header stay pinned); omit to grow with content. */
+    height?: number;
+    scales?: Scale[];
+    padDays?: number;
+    /** Custom zoom ladder (coarse → fine). Defaults to the built-in ladder; when
+     *  omitted, `scales`/`colWidth` seed the default rung. */
+    zoomLevels?: ZoomLevel[];
+    /** Starting rung of the zoom ladder (default: the month/day level). */
+    defaultZoomIndex?: number;
+    /** Fired when the zoom level changes (and once on mount). */
+    onZoomChange?: (state: {
+        index: number;
+        count: number;
+    }) => void;
+    /** Enable Ctrl/Cmd + mouse-wheel zoom over the grid (anchors on the cursor). */
+    zoomWheel?: boolean;
+    /** Enable +/- keyboard zoom when the grid is focused. */
+    zoomKeyboard?: boolean;
+    onTaskClick?: (task: GanttTask) => void;
+    dependencies?: TaskDependency[];
+    onDependencyCreate?: (dep: TaskDependency) => void;
+    onDependencyDelete?: (dep: TaskDependency) => void;
+    onTaskCreate?: (task: GanttTask, afterId?: Id | null) => void;
+    onTaskDelete?: (id: Id) => void;
+    /** Fired when a column's edit action is invoked (e.g. the actions-column pencil button). */
+    onTaskEdit?: (task: GanttTask) => void;
+    /** Fired with the resolved task list whenever it changes (after create/delete/edit/undo/redo). */
+    onTasksChange?: (tasks: GanttTask[]) => void;
+    /**
+     * Working-time calendar. Supplying it is the opt-in: with no `calendar` the
+     * chart schedules in plain linear time exactly as before. Safe to write inline —
+     * it is keyed by content, not identity.
+     */
+    calendar?: GanttCalendar;
+    /**
+     * Snap library-authored dates (drag commits, cascade results) onto working
+     * time. Defaults to `true` when a `calendar` is supplied; `false` keeps the
+     * non-working shading but leaves dates untouched.
+     */
+    snapToWorking?: boolean;
+    /** How an input `duration` is interpreted and displayed. Defaults to `"day"`. */
+    durationUnit?: DurationUnit;
+    /**
+     * Remove every editing affordance: bars stop moving/resizing, the progress
+     * handle and dependency connectors disappear, links can no longer be selected
+     * or deleted, and the built-in actions column is dropped.
+     *
+     * Viewing is untouched — selection, expand/collapse, scroll and zoom all still
+     * work — and so is `apiRef`: `readOnly` is about the pointer, not the data (see
+     * ADR-021). Custom `columns` are yours to gate; read `api.readOnly` in `render`.
+     */
+    readOnly?: boolean;
+    /** Receives the imperative API: `apiRef.current.createTask(...)`, `.undo()`, etc. */
+    apiRef?: default_2.Ref<GanttHandle>;
+    /**
+     * Overrides for the library's accessible strings (screen-reader names).
+     * Pass a referentially stable object — see `GanttLabels`.
+     */
+    labels?: GanttLabels;
+}
+
+export declare function GanttGrid({ slots: slotsProp, slotProps: slotPropsProp }?: GanttGridProps): JSX.Element | null;
+
+export declare namespace GanttGrid {
+    var displayName: string;
+}
+
+declare interface GanttGridProps {
+    slots?: GridSlots;
+    slotProps?: GridSlotProps;
+}
+
+/** Imperative API exposed via `<Gantt apiRef={ref} />` for create/update/delete/undo/redo. */
+export declare interface GanttHandle {
+    createTask: (task: GanttTask, afterId?: Id | null) => void;
+    updateTask: (id: Id, patch: TaskPatch) => void;
+    deleteTask: (id: Id) => void;
+    undo: () => void;
+    redo: () => void;
+    /**
+     * Bring a task into view. Vertical by default; pass `{ horizontal: true }` to
+     * also scroll the grid to the task's bar.
+     *
+     * Expands any collapsed ancestors first, so a task nested under a collapsed
+     * parent is revealed rather than silently ignored. Still a no-op for an id that
+     * is not in the chart at all.
+     */
+    revealTask: (id: Id, options?: RevealOptions) => void;
+    /** Step the zoom ladder one level finer. No-op at the finest level. */
+    zoomIn: () => void;
+    /** Step the zoom ladder one level coarser. No-op at the coarsest level. */
+    zoomOut: () => void;
+    /** Jump to a zoom-ladder index (clamped to the ladder bounds). */
+    setZoom: (index: number) => void;
+}
+
+/**
+ * Overrides for every accessible string the library emits. Pass any subset via
+ * `<Gantt labels={...} />`; omitted keys keep their English defaults (see
+ * `DEFAULT_LABELS` in `core/labels.ts`).
+ *
+ * NOTE: pass a referentially stable / memoized object — a fresh object each render
+ * invalidates the labels context and re-renders every row and bar.
+ */
+export declare interface GanttLabels {
+    /** Accessible name for the whole widget. Default: `"Gantt chart"`. */
+    gantt?: string;
+    /** Accessible name for the task-list treegrid. Default: `"Task list"`. */
+    taskList?: string;
+    /** Accessible name for the timeline grid. Default: `"Timeline"`. */
+    timeline?: string;
+    /** Expand toggle, collapsed state. Default: `"Expand"`. */
+    expand?: string;
+    /** Expand toggle, expanded state. Default: `"Collapse"`. */
+    collapse?: string;
+    /** The task-list / timeline splitter. Default: `"Resize task list"`. */
+    resizeTaskList?: string;
+    /** The dependency-link delete button. Default: `"Delete dependency"`. */
+    deleteDependency?: string;
+    /** Actions-column edit button. Default: `` `Edit ${task.name}` ``. */
+    editTask?: (task: GanttTask) => string;
+    /** Actions-column insert button. Default: `` `Add task after ${task.name}` ``. */
+    addTaskAfter?: (task: GanttTask) => string;
+    /** Actions-column delete button. Default: `` `Delete ${task.name}` ``. */
+    deleteTask?: (task: GanttTask) => string;
+    /**
+     * The single announcement for a timeline bar. The bar's inner subtree is
+     * `aria-hidden`, so this must carry everything the bar shows visually.
+     * Default: `"{name}, {type}, {start} to {end}, {progress}% complete"`.
+     */
+    bar?: (task: GanttTask, state: {
+        progress: number;
+    }) => string;
+}
+
+/** Props of the all-in-one `<Gantt>`: the engine plus layout and slots. */
+export declare interface GanttProps extends GanttEngineProps {
+    columns?: ColumnDef[];
+    defaultTaskListWidth?: number;
+    hideTaskList?: boolean;
+    /**
+     * Slot overrides for the task-list pane (`treeCell`, `header`). Prop-drilled.
+     * Pass a referentially stable object — rows are memoized, so a fresh object each
+     * render re-renders every row.
+     */
+    taskList?: GanttTaskListSlots;
+    /** Slot overrides for the timeline bars and their handles. */
+    bars?: GanttBarsSlots;
+    /** Slot overrides for dependency links (named `dependencySlots` to avoid
+     *  colliding with the `dependencies` data prop above). */
+    dependencySlots?: GanttDependenciesSlots;
+    /** Slot overrides for the calendar/grid timeline chrome. */
+    timeline?: GanttTimelineSlots;
+}
+
+/**
+ * The composition root: owns every piece of chart state and publishes it through
+ * the twelve contexts defined in `contexts.ts`.
+ *
+ * The provider nesting at the bottom is ordered stable-outermost, hottest-inside,
+ * mirroring the cadence table in `contexts.ts`. That order is not load-bearing
+ * today — no layer derives its value from another, and React resolves `useContext`
+ * to the nearest provider at any depth — but it documents the architecture, and it
+ * *becomes* load-bearing the moment a layer starts reading another context. Keep
+ * it.
+ */
+export declare function GanttProvider({ tasks, rowHeight, colWidth, height, scales, padDays, zoomLevels, defaultZoomIndex, onZoomChange, zoomWheel, zoomKeyboard, dependencies, onTaskClick, onDependencyCreate, onDependencyDelete, onTaskCreate: onTaskCreateProp, onTaskDelete, onTaskEdit, onTasksChange, apiRef, labels, calendar, snapToWorking, durationUnit, readOnly, children, }: GanttProviderProps): JSX.Element;
+
+/** Props of the composable `<GanttProvider>`: the engine plus its subtree. */
+export declare interface GanttProviderProps extends GanttEngineProps {
+    children: default_2.ReactNode;
+}
+
+export declare function GanttSlotsProvider({ value, children, }: {
+    value: GanttSlotsValue;
+    children: ReactNode;
+}): JSX.Element;
+
+/**
+ * The grid-side slot groups delivered through context (bars/dependencies/
+ * timeline). The `taskList` group is prop-drilled separately and is NOT here.
+ */
+export declare interface GanttSlotsValue {
+    bars?: GanttBarsSlots;
+    dependencies?: GanttDependenciesSlots;
+    timeline?: GanttTimelineSlots;
+}
+
+export declare interface GanttTask {
+    id: Id;
+    name: string;
+    startDate: Date;
+    endDate?: Date;
+    duration?: number;
+    progress?: number;
+    type?: GanttTaskType;
+    parentId?: Id | null;
+}
+
+/** Slots for the task-list pane. Delivered by prop-drilling (see `<Gantt taskList>`). */
+export declare interface GanttTaskListSlots {
+    treeCell?: TreeCellSlotConfig;
+    header?: TaskListHeaderSlotConfig;
+}
+
+declare type GanttTaskType = "task" | "milestone" | "summary";
+
+/** Slots for the calendar/grid timeline chrome. Delivered via context. */
+export declare interface GanttTimelineSlots {
+    calendarRow?: CalendarRowSlotConfig;
+    gridColumn?: GridColumnsSlotConfig;
+    grid?: GridSlotConfig;
+    gridResizeHandle?: GridResizeHandleSlotConfig;
+}
+
+/** State passed to the function form of the GridColumns `column` slotProps (per day). */
+export declare interface GridColumnOwnerState {
+    /** The day this column paints. */
+    date: Date;
+    /** Absolute date-column index. */
+    index: number;
+    /**
+     * Whether the calendar excludes this column from working time. Prefer this over
+     * {@link GridColumnOwnerState.isWeekend} — it also covers holidays and, at hour
+     * scale, off-hours.
+     */
+    isNonWorking: boolean;
+    /** Why the column is non-working, for styling weekends and holidays apart. */
+    nonWorkingReason?: NonWorkingReason;
+    /**
+     * @deprecated Use {@link GridColumnOwnerState.isNonWorking}. Retained as an
+     * alias so existing slot code keeps working; it is now true for any
+     * non-working column, not only Saturday and Sunday.
+     */
+    isWeekend: boolean;
+    colWidth: number;
+    bodyHeight: number;
+}
+
+/**
+ * Slot config for the grid background columns. Pass via the grid's slot props.
+ *
+ * NOTE: pass a referentially stable / memoized object so downstream memoization
+ * is not defeated by a fresh object each render.
+ */
+export declare type GridColumnsSlotConfig = SlotConfig<GridColumnsSlots, GridColumnsSlotProps>;
+
+export declare interface GridColumnsSlotProps {
+    column?: SlotPropsInput<ComponentProps<"div">, GridColumnOwnerState>;
+}
+
+export declare interface GridColumnsSlots {
+    /** A per-day background column. Default: `"div"`. */
+    column?: ElementType;
+}
+
+/** State passed to the function form of the Grid slotProps. */
+export declare interface GridOwnerState {
+    /** Total content width in px (`dates.length * colWidth`). */
+    totalWidth: number;
+    /** Total body height in px (`visibleTasks.length * rowHeight`). */
+    bodyHeight: number;
+    /** Fixed grid-wrapper height when configured, else `undefined` (auto). */
+    height: number | undefined;
+}
+
+/** State passed to the function form of the GridResizeHandle slotProps. */
+export declare interface GridResizeHandleOwnerState {
+    /** Whether a resize drag is currently in progress. */
+    isResizing: boolean;
+}
+
+export declare type GridResizeHandleSlotConfig = SlotConfig<GridResizeHandleSlots, GridResizeHandleSlotProps>;
+
+export declare interface GridResizeHandleSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, GridResizeHandleOwnerState>;
+}
+
+export declare interface GridResizeHandleSlots {
+    /** The pane splitter element. Default: `"div"`. */
+    root?: ElementType;
+}
+
+/**
+ * Slot config for the Gantt grid. Threaded from `<Gantt>` in a later pass.
+ *
+ * NOTE: pass a referentially stable / memoized object so downstream memoization
+ * is not defeated by a fresh object each render.
+ */
+export declare type GridSlotConfig = SlotConfig<GridSlots, GridSlotProps>;
+
+export declare interface GridSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, GridOwnerState>;
+    body?: SlotPropsInput<ComponentProps<"div">, GridOwnerState>;
+}
+
+export declare interface GridSlots {
+    /** The scroll wrapper (`styles.gridWrapper`). Default: `"div"`. */
+    root?: ElementType;
+    /** The scrollable body layer (`styles.body`). Default: `"div"`. */
+    body?: ElementType;
+}
+
+export declare type Id = string | number;
+
+export declare interface IndexRange {
+    /** First visible item index (inclusive). */
+    start: number;
+    /** One past the last visible item index (exclusive). */
+    end: number;
+}
+
+/**
+ * Merge library-owned internal props with a consumer's `slotProps` for one slot.
+ *
+ * - `className`: `clsx(internal, external)` — both apply, the consumer's comes last.
+ * - `style`: shallow-merged, the consumer wins per key.
+ * - all other props: the consumer overrides the internal value (MUI semantics — e.g.
+ *   passing `onClick` replaces the default handler; this is the consumer's
+ *   responsibility to preserve behavior).
+ */
+export declare function mergeSlotProps<Props extends {
+    className?: string;
+    style?: CSSProperties;
+}, OwnerState>(internalProps: Props, slotProps: SlotPropsInput<Props, OwnerState> | undefined, ownerState: OwnerState): Props;
+
+export declare function MilestoneBar({ size, centerLeft, top, colWidth, title, a11y, onMove, onMoveEnd, slots: slotsProp, slotProps: slotPropsProp, }: MilestoneBarProps): JSX.Element;
+
+export declare interface MilestoneBarOwnerState {
+    size: number;
+    title: string;
+}
+
+declare interface MilestoneBarProps {
+    size: number;
+    centerLeft: number;
+    top: number;
+    colWidth: number;
+    title: string;
+    a11y?: BarA11yProps;
+    /** Editing handlers; omitted on a read-only chart (see `TaskBar`). */
+    onMove?: (newCenterLeft: number) => void;
+    onMoveEnd?: (newCenterLeft: number) => void;
+    slots?: MilestoneBarSlots;
+    slotProps?: MilestoneBarSlotProps;
+}
+
+export declare type MilestoneBarSlotConfig = SlotConfig<MilestoneBarSlots, MilestoneBarSlotProps>;
+
+export declare interface MilestoneBarSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, MilestoneBarOwnerState>;
+    shape?: SlotPropsInput<ComponentProps<"div">, MilestoneBarOwnerState>;
+}
+
+export declare interface MilestoneBarSlots {
+    /** The draggable bar wrapper. Default: `DraggableBar`. */
+    root?: ElementType;
+    /** The diamond shape. Default: `"div"`. */
+    shape?: ElementType;
+}
+
+/** Why a column is shaded. Weekend vs holiday matters only for styling. */
+export declare type NonWorkingReason = "weekend" | "holiday" | "offHours";
+
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+export declare function ProjectBar({ width, height, left, top, colWidth, title, a11y, progress, onProgressChange, onProgressEnd, onMove, onMoveEnd, slots: slotsProp, slotProps: slotPropsProp, }: ProjectBarProps): JSX.Element;
+
+/** State passed to the function form of each ProjectBar slotProps. */
+export declare interface ProjectBarOwnerState {
+    width: number;
+    height: number;
+    progress: number;
+    title: string;
+}
+
+declare interface ProjectBarProps {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    colWidth: number;
+    title: string;
+    a11y?: BarA11yProps;
+    progress: number;
+    /** Editing handlers; omitted on a read-only chart (see `TaskBar`). */
+    onProgressChange?: (newProgress: number) => void;
+    onProgressEnd?: (newProgress: number) => void;
+    onMove?: (newLeft: number) => void;
+    onMoveEnd?: (newLeft: number) => void;
+    slots?: ProjectBarSlots;
+    slotProps?: ProjectBarSlotProps;
+}
+
+/** Slot config for the project bar. */
+export declare type ProjectBarSlotConfig = SlotConfig<ProjectBarSlots, ProjectBarSlotProps>;
+
+export declare interface ProjectBarSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, ProjectBarOwnerState>;
+    inner?: SlotPropsInput<ComponentProps<"div">, ProjectBarOwnerState>;
+    label?: SlotPropsInput<ComponentProps<"div">, ProjectBarOwnerState>;
+}
+
+export declare interface ProjectBarSlots {
+    /** The draggable bar wrapper. Default: `DraggableBar`. */
+    root?: ElementType;
+    /** The inner layout wrapper holding progress/label. Default: `"div"`. */
+    inner?: ElementType;
+    /** The title label. Default: `"div"`. */
+    label?: ElementType;
+}
+
+/** {@link DEFAULT_COLUMNS} without the actions column — the `readOnly` default. */
+export declare const READ_ONLY_COLUMNS: ColumnDef[];
+
+/** `GanttLabels` with every key filled in from the defaults. */
+export declare type ResolvedGanttLabels = Required<GanttLabels>;
+
+/** Which axes to reveal on. Defaults match the historical `scrollToTask(id)`. */
+export declare interface RevealOptions {
+    /** Reveal the task's row vertically, in whichever pane is mounted. Default `true`. */
+    vertical?: boolean;
+    /** Reveal the task's bar horizontally in the grid. Default `false`. */
+    horizontal?: boolean;
+}
+
+export declare type Scale = {
+    unit: CalendarUnit;
+    step: number;
+    format: (date: Date) => string;
+    ariaFormat?: (date: Date) => string;
+};
+
+/** Convenience shape for a component's public `{ slots, slotProps }` config prop. */
+export declare interface SlotConfig<Slots, SlotProps> {
+    slots?: Slots;
+    slotProps?: SlotProps;
+}
+
+/**
+ * A consumer-supplied `slotProps` value for a single slot: either a props object,
+ * or a function of the component's `ownerState` returning props.
+ *
+ * `P` is the target element's prop type. Per-slot we pass the native element props
+ * (e.g. `ComponentProps<"button">`) so consumers get `className` / `onClick` / aria /
+ * `data-*` autocomplete. If a consumer replaces the element with a custom component
+ * via `slots`, the props stay loosely typed against the native shape (MUI's default).
+ */
+export declare type SlotPropsInput<P, OwnerState> = Partial<P> | ((ownerState: OwnerState) => Partial<P>);
+
+export declare function TaskBar({ width, height, left, top, colWidth, title, a11y, progress, onProgressChange, onProgressEnd, onResize, onResizeEnd, onMove, onMoveEnd, slots: slotsProp, slotProps: slotPropsProp, }: TaskBarProps): JSX.Element;
+
+/** State passed to the function form of each TaskBar slotProps. */
+export declare interface TaskBarOwnerState {
+    width: number;
+    height: number;
+    progress: number;
+    title: string;
+}
+
+declare interface TaskBarProps {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    colWidth: number;
+    title: string;
+    a11y?: BarA11yProps;
+    progress: number;
+    /**
+     * Editing handlers. All optional: a read-only chart omits them, and each
+     * affordance is only rendered/wired when its handlers are present.
+     */
+    onProgressChange?: (newProgress: number) => void;
+    onProgressEnd?: (newProgress: number) => void;
+    onResize?: (newWidth: number, newLeft: number) => void;
+    onResizeEnd?: (edge: "start" | "end", edgePx: number) => void;
+    onMove?: (newLeft: number) => void;
+    onMoveEnd?: (newLeft: number) => void;
+    slots?: TaskBarSlots;
+    slotProps?: TaskBarSlotProps;
+}
+
+/** Slot config for the task bar. */
+export declare type TaskBarSlotConfig = SlotConfig<TaskBarSlots, TaskBarSlotProps>;
+
+export declare interface TaskBarSlotProps {
+    root?: SlotPropsInput<ComponentProps<"div">, TaskBarOwnerState>;
+    inner?: SlotPropsInput<ComponentProps<"div">, TaskBarOwnerState>;
+    label?: SlotPropsInput<ComponentProps<"div">, TaskBarOwnerState>;
+}
+
+export declare interface TaskBarSlots {
+    /** The draggable bar wrapper. Default: `DraggableBar`. */
+    root?: ElementType;
+    /** The inner layout wrapper holding progress/label/resizer. Default: `"div"`. */
+    inner?: ElementType;
+    /** The title label. Default: `"div"`. */
+    label?: ElementType;
+}
+
+export declare type TaskDependency = {
+    from: Id;
+    to: Id;
+    type: TaskDependencyType;
+    lag?: number;
+};
+
+export declare type TaskDependencyType = "FS" | "FF" | "SS" | "SF";
+
+export declare function TaskList({ columns, taskList }: TaskListProps): JSX.Element;
+
+/** State passed to the function form of the per-column slotProps. */
+export declare interface TaskListHeaderCellOwnerState {
+    column: ColumnDef;
+    index: number;
+}
+
+/** State passed to the function form of the header (container) slotProps. */
+export declare interface TaskListHeaderOwnerState {
+    columns: ColumnDef[];
+    headerHeight: number;
+}
+
+export declare type TaskListHeaderSlotConfig = SlotConfig<TaskListHeaderSlots, TaskListHeaderSlotProps>;
+
+export declare interface TaskListHeaderSlotProps {
+    header?: SlotPropsInput<ComponentProps<"div">, TaskListHeaderOwnerState>;
+    headerCell?: SlotPropsInput<ComponentProps<"div">, TaskListHeaderCellOwnerState>;
+    columnResizeHandle?: SlotPropsInput<ComponentProps<"div">, TaskListHeaderCellOwnerState>;
+}
+
+export declare interface TaskListHeaderSlots {
+    /** The header row container. Default: `"div"`. */
+    header?: ElementType;
+    /** A per-column header cell. Default: `"div"`. */
+    headerCell?: ElementType;
+    /** The per-column resize handle (divider). Default: `"div"`. */
+    columnResizeHandle?: ElementType;
+}
+
+declare interface TaskListProps {
+    columns?: ColumnDef[];
+    /** Slot overrides for the task-list pane (`treeCell`, `header`). Pass a stable object. */
+    taskList?: GanttTaskListSlots;
+}
+
+/** Patch passed to the imperative `updateTask`; only the provided fields change. */
+export declare interface TaskPatch {
+    name?: string;
+    startDate?: Date;
+    endDate?: Date;
+    progress?: number;
+}
+
+/** State passed to the function form of each TaskResizer slotProps. */
+export declare interface TaskResizerOwnerState {
+    width: number;
+    left: number;
+}
+
+export declare type TaskResizerSlotConfig = SlotConfig<TaskResizerSlots, TaskResizerSlotProps>;
+
+export declare interface TaskResizerSlotProps {
+    startHandle?: SlotPropsInput<ComponentProps<"button">, TaskResizerOwnerState>;
+    endHandle?: SlotPropsInput<ComponentProps<"button">, TaskResizerOwnerState>;
+}
+
+export declare interface TaskResizerSlots {
+    /** The left/start resize button. Default: `"button"`. */
+    startHandle?: ElementType;
+    /** The right/end resize button. Default: `"button"`. */
+    endHandle?: ElementType;
+}
+
+/** State passed to the function form of each TreeCell slotProps. */
+export declare interface TreeCellOwnerState {
+    taskId: Id;
+    depth: number;
+    isParent: boolean;
+    isExpanded: boolean;
+}
+
+/**
+ * Slot config for the tree cell. Pass via `<Gantt treeCell={...} />`.
+ *
+ * NOTE: pass a referentially stable / memoized object — `TaskListRow` is memoized,
+ * so a fresh object each render defeats its memo and re-renders every row.
+ */
+export declare type TreeCellSlotConfig = SlotConfig<TreeCellSlots, TreeCellSlotProps>;
+
+export declare interface TreeCellSlotProps {
+    root?: SlotPropsInput<ComponentProps<"span">, TreeCellOwnerState>;
+    expandButton?: SlotPropsInput<ComponentProps<"button">, TreeCellOwnerState>;
+    placeholder?: SlotPropsInput<ComponentProps<"span">, TreeCellOwnerState>;
+}
+
+export declare interface TreeCellSlots {
+    /** The `nameContent` wrapper. Default: `"span"`. */
+    root?: ElementType;
+    /** The ▾/▸ expand/collapse toggle. Default: `"button"`. */
+    expandButton?: ElementType;
+    /** The spacer rendered for leaf (non-parent) rows. Default: `"span"`. */
+    placeholder?: ElementType;
+}
+
+export declare function useGanttReadOnly(): boolean;
+
+/** Read the grid-side slot groups. Returns `{}` outside a provider. */
+export declare function useGanttSlots(): GanttSlotsValue;
+
+/** `0` = Sunday … `6` = Saturday, matching `Date.prototype.getDay`. */
+export declare type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+/**
+ * A span of working hours within one day, `"H:MM-H:MM"` in local civil time with
+ * minute precision — e.g. `"8:30-12:00"`. Half-open: the end minute is the first
+ * non-working minute. `"24:00"` is legal only as an end.
+ */
+export declare type WorkTimeRange = string;
+
+/**
+ * One rung of the zoom ladder: the calendar `scales` to render and the pixel
+ * width of a single (finest-unit) column. Zooming steps between levels.
+ */
+export declare interface ZoomLevel {
+    scales: Scale[];
+    colWidth: number;
+}
+
+export { }