import { type DateSlot, type MeasureSlot, type NumberSlot, type SelectSlot, type ShapeBaseProps, type ShapeFrameProps, type TextSlot } from "./shape_frame";
/**
 * THE RESOURCE SCHEDULE — work put on a resource, in order, under a ceiling: a
 * despatch board, a bay plan, a crew roster, a machine queue. *"What is this van
 * doing today, what is it still free for, and what have I not placed at all?"*
 *
 * THE BOARD IS THE BAND AND THE WORK IS THE REGISTER, so the strip, the search,
 * the lenses and the record behind a block are the frame's here as under every
 * other shape. The register opens on WHAT IS NOT PLACED.
 *
 * THE GAPS LEAD: the lane column of an unplaced row is the menu of every opening
 * the board has, and choosing one writes the lane and the start TOGETHER.
 *
 * THE LANE DRAWS ITS LOAD AGAINST ITS CEILING, and against TWO of them where the
 * model states two. The ceiling belongs to the RESOURCE, so it arrives on each
 * block and the lane's reading is what its blocks add up to against it.
 *
 * THE BOARD IS OVER THE WHOLE READ, never the band in view: a board narrowed by
 * the search would report a van as free and sell the same hour twice.
 */
export interface ResourceScheduleProps<T> extends ShapeBaseProps<T>, Pick<ShapeFrameProps<T>, "above"> {
    /** The `party` or `parent` role — the RESOURCE each block is put on. */
    lane: ScheduleLaneSlot<T>;
    /** The `identity` role — what the block is called. */
    identity: TextSlot<T>;
    /** The supporting line under the name — the block's reference, its drop code. */
    caption?: (row: T) => string;
    /** The `when` role — where the block STARTS. It also rules the axis: a value
     *  carrying a time of day makes this a board of one day's hours, a plain date
     *  a board of days, and the duration counts in that same unit. */
    when: DateSlot<T>;
    /** The `measure` role bound to `duration` — how long a block runs, in the axis's own unit. */
    duration?: NumberSlot<T>;
    /** The `measure` role bound to `load`, read against the LANE's ceiling. */
    load?: MeasureSlot<T>;
    /** The `measure` role bound to `bulk` — the second ceiling the lane fills against. */
    bulk?: MeasureSlot<T>;
    /** The `lifecycle` role — what a block is coloured by. */
    stage?: SelectSlot<T>;
    /** This block is LATE — the board hatches it rather than only reddening it. */
    late?: (row: T) => boolean;
    /** Put this block on that lane, starting then — ONE write of two fields. */
    onAssign?: (row: T, to: {
        lane: string;
        start: string;
    }) => void;
    /** The clock the board is drawn against; the real one by default. */
    now?: Date;
}
/** THE LANE A BLOCK IS ON — the key it is filed under and the words for that
 *  key, which are two different values: two vans with one registration are
 *  still two vans. */
export interface ScheduleLaneSlot<T> {
    label: string;
    /** Which lane this block is on; `""` where it is on none. */
    by: (row: T) => string;
    /** What that lane is CALLED. */
    name: (key: string) => string;
    /** EVERY LANE THERE IS, where the field declares a set. With none, the lanes
     *  are the ones the blocks name, so a resource with nothing on it is not
     *  drawn — and the empty lane is the most valuable row on the board. */
    keys?: readonly string[];
}
export declare function ResourceSchedule<T>(props: ResourceScheduleProps<T>): import("react").JSX.Element;