@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/scheduler/model/SchedulerModel.d.ts

@@ -0,0 +1,377 @@
+import { TimeZone } from '../../../parts/dates/time-zone';
+import type { SchedulerBlockedTime } from '../scheduler-blocked-time';
+import type { SchedulerCell } from '../scheduler-cell';
+import type { SchedulerFields } from '../scheduler-fields';
+import type { SchedulerRange } from '../scheduler-range';
+import type { SchedulerTimeCheck } from '../scheduler-time-check';
+import type { AgendaDay } from './agenda-day';
+import type { AnyPiece } from './any-piece';
+import type { CellPlace } from './cell-place';
+import type { DayBlock } from './day-block';
+import type { Draft } from './draft';
+import type { HeaderCell } from './header-cell';
+import type { HeaderRow } from './header-row';
+import type { OccurrenceInfo } from './occurrence-info';
+import { Occurrences } from './Occurrences';
+import type { OverlapMode } from './overlap-mode';
+import type { ResolvedView } from './resolved-view';
+import type { Resources } from './Resources';
+import type { ScaleCell } from './scale-cell';
+import type { SchedulerColumn } from './scheduler-column';
+import type { SchedulerDay } from './scheduler-day';
+import type { SchedulerGroup } from './scheduler-group';
+import type { StripRow } from './strip-row';
+import type { TimeSlot } from './time-slot';
+import type { TimeTick } from './time-tick';
+import type { TimedPiece } from './timed-piece';
+import type { TimelineRow } from './timeline-row';
+import { type ViewKind } from './view-kind';
+/** A rule of the developer's: whether an appointment may be at a time. */
+export type TimeRule<T> = (check: SchedulerTimeCheck<T>) => boolean;
+/**
+ * The steps the model works its state out in, in order: a step uses what the ones before it wrote.
+ * `update(step)` asks for that step and every one after it.
+ */
+declare const STEPS: readonly ['groups', 'days', 'slots', 'ticks', 'rows', 'blocks', 'collect', 'layout'];
+export type ModelStep = (typeof STEPS)[number];
+/**
+ * What changed, told to the views (`onChanged`): `layout` after a step ran (the days, the columns,
+ * the pieces; the focus may have moved with them), `focus` when the focus or the selection moved,
+ * `window` when a big view's window moved, `now` when the clock moved on.
+ */
+export type ModelChange = 'layout' | 'focus' | 'window' | 'now';
+/** What the model reads from its scheduler, when it works its state out. Nothing is followed: the scheduler says what changed with `update`. */
+export interface SchedulerModelOptions<T> {
+    /** The date the view is built around. */
+    date: () => Date;
+    items: () => readonly T[];
+    fields: () => SchedulerFields;
+    view: () => ResolvedView;
+    firstDayOfWeek: () => number;
+    workDays: () => readonly number[];
+    isHoliday: () => ((date: Date) => boolean) | null;
+    overlapMode: () => OverlapMode;
+    /** The lines a week of the month and the all-day panel have room for (measured); `Infinity` before. */
+    room: () => {
+        month: number;
+        allDay: number;
+    };
+    /** An appointment being moved or resized, shown where it would go. */
+    draft?: () => Draft<T> | null;
+    /** The clock the days and hours are on. Default: the browser's. */
+    zone?: () => TimeZone;
+    /** The resource kinds: the colours they give, and the groups of the columns. */
+    resources?: Resources;
+    /** The scheduler's work hours (a resource's own win). Default 9 to 17. */
+    workHours?: () => {
+        start: number;
+        end: number;
+    };
+    blockedTimes?: () => readonly SchedulerBlockedTime[];
+    /** Whether an appointment may overlap another in its group; or a rule that decides the whole check. Default `true`. */
+    allowOverlap?: () => boolean | TimeRule<T>;
+    /** Whether an appointment may be outside the work hours. Default `true`. */
+    allowOffHours?: () => boolean;
+    /** A timeline row's sizes in pixels (measured): a lane, the gap around lanes, the least a row is. */
+    lineMetrics?: () => {
+        lane: number;
+        gap: number;
+        min: number;
+    };
+}
+interface ModelState<T> {
+    /** Now, in milliseconds; moved on by the scheduler's clock. */
+    now: number;
+    days: SchedulerDay[];
+    /** The groups of the columns; none without `groups`. */
+    groups: SchedulerGroup[];
+    /** The columns: each day, in each group (in the month, over all the weeks). */
+    columns: SchedulerColumn[];
+    /** The heads of the dates (the weekdays in the month) and the rows of group heads, outer first. */
+    dates: HeaderCell[];
+    heads: HeaderRow[];
+    slots: TimeSlot[];
+    /** The timed pieces of every column, in one list: a piece keeps its object (and its box) when it moves to another column. */
+    timed: TimedPiece<T>[];
+    allDay: StripRow<T>;
+    weeks: StripRow<T>[];
+    /** The cell with keyboard focus, and the other end of the selection. */
+    focus: CellPlace;
+    anchor: CellPlace | null;
+    /** Moves on each time the appointments shown (`shown()`) change. */
+    shownVersion: number;
+    /** Moves on each time the appointments are to be read again (a refresh, an edit). */
+    changes: number;
+    /** Moves on each time everything is read again (`refresh()` with no appointment): what the developer gave besides the appointments, the blocked times, is read again too. */
+    refreshed: number;
+    /** A timeline's cells along the time, its rows (a group each), and the heads over the cells: days or months over hours or days. */
+    ticks: TimeTick[];
+    rows: TimelineRow<T>[];
+    upper: ScaleCell[];
+    lower: ScaleCell[];
+    /** The agenda's days (in each group), with their appointments. */
+    agenda: AgendaDay<T>[];
+    /** What a big view builds: the columns of the day views, or the cells along a timeline's time, from `first`. */
+    window: {
+        first: number;
+        count: number;
+    };
+    /** Moves on each time the appointments of the days shown are read again. */
+    revision: number;
+    /** Moves on each time what the cells show is written again (the days, their columns, the time rows, the blocked times): a view that writes its cells once reads this instead of every cell's sources. */
+    look: number;
+}
+/**
+ * The scheduler without its DOM: the days and times the view shows, the groups of resources its
+ * columns are split into, where every appointment goes (filled in place: a day, a column, a cell
+ * row and an appointment's piece stay the same objects while they stay on screen), the
+ * occurrences of the series in the days shown, the focused cell, the selection and whether a time
+ * is free. Days and hours are on the scheduler's clock (its time zone): an appointment is placed
+ * by its wall clock times there, so on the day summer time changes an hour is skipped or doubled,
+ * and a box never ends before its end's row nor shows shorter than it lasts.
+ *
+ * The appointments and their fields are read as they are, plain or reactive, and read again on
+ * `refresh` (the scheduler's, its edits, its data source's changes). Nothing in the model is
+ * reactive and nothing is followed: its state is plain, worked out when `update` asks for it, and
+ * what changed is told to `onChanged` listeners, which draw it.
+ */
+export declare class SchedulerModel<T> {
+    private readonly options;
+    readonly state: ModelState<T>;
+    readonly occurrences: Occurrences<T>;
+    private readonly timedCache;
+    private readonly stripCache;
+    /** Group heads by their resources (and date): a head keeps its object while its item is shown. */
+    private readonly headCache;
+    private readonly lineCache;
+    private readonly agendaCache;
+    private readonly agendaDays;
+    private readonly ids;
+    private fieldsNow;
+    /** The shape of the columns last made: the days, the groups and how they stand. */
+    private shape;
+    /** The resource kinds while a layout runs (read once for all its appointments). */
+    private kindsNow;
+    /** The timed pieces as written last, with each one's column. */
+    private timedRaw;
+    /** The appointments shown, as written last. */
+    private shownRaw;
+    /**
+     * What was written last into each piece kept, by the piece's id: a piece may come back as another object than
+     * the one made (a list that wraps what it is given), its id is its own.
+     */
+    private readonly written;
+    private readonly rowPieces;
+    /** What a timeline row was laid out from last: a row whose appointments read the same is not laid out again. */
+    private readonly rowMarks;
+    private zoneNow;
+    private nextId;
+    /** How many times every appointment, and each one (by itself, or by its series), was read again. */
+    private everything;
+    private readonly touched;
+    private readonly stops;
+    /** The first step to work out again (`STEPS.length`: none), and whether a run is waiting. */
+    private dirty;
+    private queued;
+    /** The view's settings as read for the code running now (see `view`). */
+    private viewNow;
+    private started;
+    private readonly listeners;
+    /** The appointments of the days shown, read once for every layout until they change (a drag only adds its draft). */
+    private base;
+    private baseById;
+    /** The base's appointments by the group they are in, made again when the base or the groups change. */
+    private buckets;
+    /** The groups each appointment read is in, and the groups by their key. */
+    private groupsCache;
+    private groupIndex;
+    /** What the timeline was last laid out for: a draft alone lays out only the rows it touches. */
+    private laid;
+    constructor(options: SchedulerModelOptions<T>);
+    /** Works everything out once and from then on when asked (`update`); call `dispose` to stop. */
+    start(): void;
+    dispose(): void;
+    /**
+     * Asks for `step` and every step after it to be worked out again (an option changed, the
+     * appointments, a measure, a drag): once, in the next microtask, however many ask before then.
+     */
+    update(step?: ModelStep): void;
+    /** Works out now what was asked for: for code that needs the result at once. */
+    flush(): void;
+    /** Calls `listener` with what changed (see `ModelChange`); returns the function that stops it. */
+    onChanged(listener: (change: ModelChange) => void): () => void;
+    private tell;
+    private work;
+    /** Moves now on (the scheduler's clock): the days are worked out again when today is another day. */
+    setNow(now: number): void;
+    /**
+     * Reads the appointments again: what changed in them in place shows. With `item`, that one's
+     * boxes (an occurrence's: its series') read it again; without, every box does.
+     */
+    refresh(item?: T | null): void;
+    /** The appointments shown, in time order */
+    shown(): readonly T[];
+    /** The appointment a piece shows. */
+    itemOf(piece: AnyPiece<T>): T;
+    /** How many times an appointment was read again (for an occurrence: its series). */
+    private versionOf;
+    get view(): ResolvedView;
+    /** The layout the view uses */
+    get kind(): ViewKind;
+    /** The scheduler's clock. */
+    get zone(): TimeZone;
+    /** The fields it reads: while the appointments are read, the ones read at the start (each read of an option has its cost, and the appointments are many). */
+    private fields;
+    /** Whether the view builds only what is in view: set so, or (`'auto'`) its cells are many */
+    get virtual(): boolean;
+    /** Sets what a big view builds: from `first`, `count` columns (day views) or cells along the time (a timeline). */
+    setWindow(first: number, count: number): void;
+    /** The columns the day views build: all of them, or the window's */
+    shownColumns(): SchedulerColumn[];
+    /** Whether a run of columns (`first`, `span`) is in what the day views build */
+    columnsShown(first: number, span: number): boolean;
+    /** The timed pieces the day views build */
+    shownTimed(): TimedPiece<T>[];
+    /** Of heads over runs of columns, in the order of their first column, the ones in what the day views build */
+    shownHeads<H extends {
+        first: number;
+        span: number;
+    }>(heads: readonly H[]): readonly H[];
+    /** The cells along a timeline's time it builds */
+    shownTicks(): TimeTick[];
+    /** Whether a run of a timeline's cells (`from`, `span`, shares of a cell too) is in what it builds */
+    ticksShown(from: number, span: number): boolean;
+    /** Where now is along a timeline, in cells; `null` when it is not in the days and hours shown */
+    nowTick(): number | null;
+    /** The minutes of the day the time rows show, and the minutes in a row. */
+    private hours;
+    /** Whether the columns are grouped */
+    get grouped(): boolean;
+    /** The dates stand over the groups: by date, or with a single day */
+    get datesFirst(): boolean;
+    /** The columns of a row of the month (a week), or of the day views */
+    get perRow(): number;
+    /** The days shown, `end` not included */
+    range(): SchedulerRange;
+    /** Today's start, in milliseconds */
+    today(): number;
+    /** Today's start on the wall clock */
+    todayWall(): number;
+    /** The columns of today, empty when it is not shown */
+    todayColumns(): SchedulerColumn[];
+    /** Where now is in a day column (0–1), or `null` outside the hours shown */
+    nowAt(): number | null;
+    /** The key the layout uses for an appointment (an occurrence's: its series' and its start). */
+    idOf(item: T): string;
+    /** An appointment's start and end, `end` never before `start`. */
+    timeOf(item: T): {
+        start: Date;
+        end: Date;
+        allDay: boolean;
+    } | null;
+    /** Where an occurrence of a series comes from; `null` for any other appointment. */
+    occurrenceOf(item: T): OccurrenceInfo<T> | null;
+    /** The series of an occurrence (or of one changed apart from it, by its `recurrenceId`), a series itself, or `null`. */
+    seriesOf(item: T): T | null;
+    /** Whether an appointment is an occurrence changed apart from its series. */
+    isException(item: T): boolean;
+    /** The appointments between `start` and `end` (any part of them); with `group`, the ones in it. */
+    appointmentsIn(start: Date, end: Date, group?: SchedulerGroup | null): T[];
+    /** The group of a column, `null` without groups */
+    groupOf(column: number): SchedulerGroup | null;
+    /** The values an appointment's resource fields would have in another group: only the values of the fields grouped by change (in a list, the one of the group it leaves). */
+    movedValues(item: T, from: SchedulerGroup | null, to: SchedulerGroup | null): Record<string, unknown> | null;
+    /**
+     * Whether an appointment may be at a time (with `resources`, the values its resource fields
+     * would have there): not over a blocked time, not outside the work hours unless allowed, not over
+     * another appointment of its groups unless allowed; a rule of the developer's decides it all.
+     */
+    check(item: T, start: Date, end: Date, allDay: boolean, resources?: Record<string, unknown> | null): {
+        free: boolean;
+        check: SchedulerTimeCheck<T>;
+    };
+    /** Whether a time is outside the work hours of its groups (without groups: of its resources that have their own, else the scheduler's). */
+    private offHours;
+    /** The time of a cell: `slot` -1 is the all-day panel (and every day of the month view). */
+    cellOf(place: CellPlace): SchedulerCell | null;
+    /** The cells between the anchor and the focus, as one time in the anchor's group; `null` without a selection */
+    selection(): SchedulerCell | null;
+    /** Whether a cell is in the selection */
+    isSelected(column: number, slot: number): boolean;
+    /** The blocked time a cell is in, or `null` */
+    blockAt(column: number, slot: number): DayBlock | null;
+    /** Puts the focus on a cell; `extend` keeps the anchor (a range), otherwise the cell alone is selected. */
+    focusCell(place: CellPlace, extend?: boolean): void;
+    clearSelection(): void;
+    private fillGroups;
+    private fillDays;
+    /** The columns: in each group the days (or, by date, in each day the groups), and the heads over them. */
+    private fillColumns;
+    /** The heads over a row of columns: a date (a weekday) per day, and a row of group heads per level. */
+    private fillHeads;
+    private fillWeeks;
+    private fillSlots;
+    /** A timeline's cells along the time (a time row of each day, or each whole day) and the heads over them. */
+    private fillTicks;
+    /** A timeline's rows: a row per group (one without groups), with what its head cells show. */
+    private fillRows;
+    /** Writes into each column the blocked times of its day that are for its group. */
+    private fillBlocks;
+    /** Reads the appointments of the days shown (without a draft): every layout places them from here until they change. */
+    private collect;
+    /** Places the appointments read (and a draft): the views each their own way. */
+    private layout;
+    /** The appointments read, by the group they are in: made again when they or the groups change; a draft changes only its own groups. */
+    private byGroup;
+    /** The groups by their key, made again when they change; the key of them all. */
+    private indexGroups;
+    /** The indices of the groups an appointment is in: one for each set of its values of the fields grouped by. */
+    private groupsOf;
+    /** Writes into each column the blocked times of its day that are for its group. */
+    private placeBlocks;
+    /** The appointments between `from` and `to`, with the draft (where it would go, in place of the appointment moved). */
+    private entries;
+    private read;
+    private readWith;
+    /** A draft as the layout reads it: moved, it keeps its id (and its box); a copy is one more. */
+    private draftEntry;
+    private lookOf;
+    /** An entry's colour in a column: its own, else its resources' (the group's item, where it is grouped by the colouring kind). */
+    private colorIn;
+    /** Places the timed pieces of a column: of the appointments of its group, the ones on its day. */
+    private placeColumn;
+    /**
+     * Places the bars over a row of columns (the all-day panel, a week of the month): in each group
+     * on the days of its columns, each bar on the lowest line free; a bar over columns that do not
+     * stand side by side (the groups under each date) is cut into a piece per run of them.
+     */
+    private placeStrip;
+    /**
+     * Lays out a row of a timeline on its own: each appointment of its group from where it starts to
+     * where it ends along the row (cut to the days and hours shown), stacked on the lowest lane free;
+     * the row is as tall as its lanes. With a number for `maxAppointmentsPerCell`, lanes past it are
+     * left out and each day says how many ("+N more").
+     */
+    /** What a row's layout comes from, besides the view's settings: its group and each appointment's time and look. */
+    private markOf;
+    private placeLine;
+    /**
+     * Where an appointment is along a timeline's row, in cells: from its start to its end, cut to the
+     * days and hours shown (`before`, `after`: it goes on past them); `null` when none of it is shown.
+     * In a timeline of days (the month) it takes its days whole.
+     */
+    private along;
+    /** The agenda: in each group, each day with its appointments in time order (one that lasts days on each of them); a day with none is left out. */
+    private placeAgenda;
+    private clearAgenda;
+    private clearLines;
+    /**
+     * The cached piece with the new values written into it (only what changed), or a new one. The
+     * piece holds the kit's own values only; its appointment is kept beside it, plain, and its
+     * `version` moves on when that is read again or is another object.
+     */
+    /** A piece no longer kept, and what was written into it. */
+    private drop;
+    private keep;
+}
+export {};

package/dist/components/scheduler/model/SeriesEdit.d.ts

@@ -0,0 +1,49 @@
+import type { SchedulerFields } from '../scheduler-fields';
+import type { Occurrences } from './Occurrences';
+import type { SeriesPlan } from './series-plan';
+import type { SeriesScope } from './series-scope';
+/** What the series edits read from their scheduler. */
+export interface SeriesEditOptions<T> {
+    fields: () => SchedulerFields;
+    occurrences: Occurrences<T>;
+    /** The key an occurrence changed apart from its series names that series by. */
+    keyOf: (item: T) => unknown;
+}
+/**
+ * What a change to an occurrence of a series comes to, without writing it:
+ * - this occurrence: a new appointment in its place (naming its series by `recurrenceId`) and its
+ *   time left out of the series (`EXDATE`);
+ * - this and the following: the series ends before it (`UNTIL`, or a smaller `COUNT`) and a new
+ *   series starts from it, with the change;
+ * - the whole series: the series takes the change; a time moved moves every occurrence by as much
+ *   (a weekly series moved to another day moves its weekdays too).
+ * Deleting works the same way. Changing the first occurrence and the ones after it is the whole series.
+ */
+export declare class SeriesEdit<T> {
+    private readonly options;
+    constructor(options: SeriesEditOptions<T>);
+    update(occurrence: T, changes: Partial<T>, scope: SeriesScope): SeriesPlan<T>;
+    /** `exceptions`: the occurrences changed apart from the series (they go with it). */
+    remove(occurrence: T, scope: SeriesScope, exceptions?: readonly T[]): SeriesPlan<T>;
+    private allDay;
+    /** A wall clock time of a start or an end: an all-day one's by its fields, a timed one's on the series' clock. */
+    private wallOf;
+    private isFirst;
+    /** The occurrence's time as an exception date of its series. */
+    private dateOf;
+    /** Whether an exception date of a series is before an occurrence. */
+    private before;
+    private leaveOut;
+    /** How many times the rule happens before an occurrence (they count, left out or not). */
+    private countBefore;
+    /** The series' changes so it ends before an occurrence: a smaller count, or an end just before it. */
+    private ended;
+    /** The rule of the series that goes on from an occurrence: what is left of its count. */
+    private rest;
+    /** Days a change moves an occurrence by (on its clock). */
+    private dayShift;
+    /** The changes of the whole series for a change made on one occurrence: times move by as much as that one's did. */
+    private moved;
+    /** An occurrence's fields as a new appointment's: without the key, the rule and the exceptions. */
+    private copy;
+}

package/dist/components/scheduler/model/SeriesWriter.d.ts

@@ -0,0 +1,18 @@
+import type { AppointmentStore } from './AppointmentStore';
+import type { SeriesPlan } from './series-plan';
+import type { SeriesRun } from './series-run';
+/**
+ * Writes what a change to a series comes to, one write after another through the store (so
+ * through the data source's adapter): the appointments to add first, then the changes, then the
+ * deletes. When a write fails, the ones saved before it are taken back in the opposite order (a
+ * row added is deleted, a change is written back, a row deleted is added again), and the result
+ * says what was saved, what was not, and whether it was all taken back.
+ */
+export declare class SeriesWriter<T> {
+    private readonly store;
+    constructor(store: AppointmentStore<T>);
+    run(plan: SeriesPlan<T>): Promise<SeriesRun<T>>;
+    private write;
+    /** Takes saved writes back, the last first; `true` when every one was. */
+    private undo;
+}

package/dist/components/scheduler/model/agenda-day.d.ts

@@ -0,0 +1,14 @@
+import type { AgendaPiece } from './agenda-piece';
+import type { SchedulerDay } from './scheduler-day';
+import type { SchedulerGroup } from './scheduler-group';
+/** A day of the agenda (in a group, with groups) and its appointments in time order; a day with none is left out. */
+export interface AgendaDay<T> {
+    key: string;
+    day: SchedulerDay;
+    group: SchedulerGroup | null;
+    /** The first day of its group: its group's head stands over it. */
+    first: boolean;
+    /** Its group's names; empty without groups. */
+    label: string;
+    items: AgendaPiece<T>[];
+}

package/dist/components/scheduler/model/agenda-piece.d.ts

@@ -0,0 +1,21 @@
+/** An appointment on a day of the agenda (one that lasts days is on each of them). Kept while it stays on screen. */
+export interface AgendaPiece<T> {
+    id: string;
+    /** Moves on when its appointment was read again (a refresh, an edit) or is another object: what shows it reads it again. The appointment itself is the model's `itemOf(piece)`. */
+    version: number;
+    /** The group it is listed under (-1 without groups). */
+    group: number;
+    /** Its time on this day; `whole`: it takes the day (all day, or going on through it). */
+    start: Date;
+    end: Date;
+    whole: boolean;
+    before: boolean;
+    after: boolean;
+    draft: boolean;
+    invalid: boolean;
+    text: string;
+    color: string;
+    disabled: boolean;
+    series: boolean;
+    exception: boolean;
+}

package/dist/components/scheduler/model/any-piece.d.ts

@@ -0,0 +1,6 @@
+import type { AgendaPiece } from './agenda-piece';
+import type { LinePiece } from './line-piece';
+import type { StripPiece } from './strip-piece';
+import type { TimedPiece } from './timed-piece';
+/** Any part of an appointment a view shows. */
+export type AnyPiece<T> = TimedPiece<T> | StripPiece<T> | LinePiece<T> | AgendaPiece<T>;

package/dist/components/scheduler/model/blocked-spans.d.ts

@@ -0,0 +1,14 @@
+import { TimeZone } from '../../../parts/dates/time-zone';
+import type { SchedulerBlockedTime } from '../scheduler-blocked-time';
+/** A blocked time as it happens once: wall clock times of the scheduler's clock. */
+export interface BlockedSpan {
+    start: number;
+    end: number;
+    block: SchedulerBlockedTime;
+}
+/**
+ * The times the blocked times take between two wall clock times (a repeating one, each time it happens there). The
+ * blocked times are the developer's and are read as they are (untracked): a new list given shows, a change in place
+ * after the scheduler's refresh.
+ */
+export declare function blockedSpans(blocks: readonly SchedulerBlockedTime[], from: number, to: number, zone: TimeZone): BlockedSpan[];

package/dist/components/scheduler/model/cell-place.d.ts

@@ -0,0 +1,5 @@
+/** A cell by its place: the column's index (a day, in a group), and the time row's (`-1`: the all-day panel, or a day of the month view). */
+export interface CellPlace {
+    column: number;
+    slot: number;
+}

package/dist/components/scheduler/model/column-edge.d.ts

@@ -0,0 +1,2 @@
+/** Where a divider stands before a column or a head: at the outermost change (`outer`), at a deeper one (`inner`), or none. */
+export type ColumnEdge = '' | 'outer' | 'inner';

package/dist/components/scheduler/model/day-block.d.ts

@@ -0,0 +1,6 @@
+/** The part of a blocked time in a column's day: minutes after the day's start on the clock. */
+export interface DayBlock {
+    from: number;
+    to: number;
+    text: string;
+}

package/dist/components/scheduler/model/draft.d.ts

@@ -0,0 +1,15 @@
+/** Where an appointment being moved or resized would go: the layout shows it there (the same box), or a copy of it. */
+export interface Draft<T> {
+    item: T;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    /** A copy goes there; the appointment stays. */
+    copy: boolean;
+    /** It may not go there (an event or the time's availability said so). */
+    invalid: boolean;
+    /** Moved to another group: the values its resource fields would get, by field. */
+    resources?: Record<string, unknown> | null;
+    /** A finger lifted it (a long press, or a handle). */
+    touch?: boolean;
+}

package/dist/components/scheduler/model/group-resource.d.ts

@@ -0,0 +1,8 @@
+/** A resource item at one level of a group (the room, then the person): its value, name and colour; the item itself is its kind's `find(value)`. */
+export interface GroupResource {
+    /** The appointment field of its kind. */
+    field: string;
+    value: unknown;
+    text: string;
+    color: string;
+}

package/dist/components/scheduler/model/header-cell.d.ts

@@ -0,0 +1,16 @@
+import type { ColumnEdge } from './column-edge';
+import type { GroupResource } from './group-resource';
+import type { SchedulerDay } from './scheduler-day';
+/** A head over columns: a date (a weekday in the month), or a resource of the groups. */
+export interface HeaderCell {
+    key: string;
+    /** The first column it is over (in the month: of a week), and how many. */
+    first: number;
+    span: number;
+    level: number;
+    edge: ColumnEdge;
+    day: SchedulerDay | null;
+    resource: GroupResource | null;
+    /** The group's values up to its level. */
+    values: Record<string, unknown>;
+}

package/dist/components/scheduler/model/header-row.d.ts

@@ -0,0 +1,8 @@
+import type { HeaderCell } from './header-cell';
+/** A row of group heads: one level of the groups. */
+export interface HeaderRow {
+    level: number;
+    /** The kind's name, read out with it. */
+    label: string;
+    cells: HeaderCell[];
+}

package/dist/components/scheduler/model/line-piece.d.ts

@@ -0,0 +1,29 @@
+/** An appointment in a row of a timeline, on its lane (stacked under the ones at the same time). Kept while it stays on screen. */
+export interface LinePiece<T> {
+    id: string;
+    /** Moves on when its appointment was read again (a refresh, an edit) or is another object: what shows it reads it again. The appointment itself is the model's `itemOf(piece)`. */
+    version: number;
+    /** The row it is in (its group's index, -1 without groups). */
+    group: number;
+    /** The appointment's time (its box may show only part of it). */
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    /** Where it starts along the row and how far it goes, in cells (a share of a cell for a time inside one). */
+    from: number;
+    span: number;
+    /** Its lane in the row, from 0. */
+    lane: number;
+    /** Lanes past what the row has room for are left out ("+N more"). */
+    hidden: boolean;
+    /** It began before what is shown, or goes on after it. */
+    before: boolean;
+    after: boolean;
+    draft: boolean;
+    invalid: boolean;
+    text: string;
+    color: string;
+    disabled: boolean;
+    series: boolean;
+    exception: boolean;
+}

package/dist/components/scheduler/model/make-groups.d.ts

@@ -0,0 +1,14 @@
+import type { ResourceKind } from './ResourceKind';
+import type { SchedulerGroup } from './scheduler-group';
+/** The work time a group falls back on. */
+export interface BaseWork {
+    start: number;
+    end: number;
+    days: readonly number[];
+}
+/**
+ * The groups of the columns: every item of the first kind, each with every item of the next
+ * (only its own, when the next kind says whose it is by `parentExpr`), and so on. A group's work
+ * time is the innermost item's own, else the base.
+ */
+export declare function makeGroups(kinds: readonly ResourceKind<unknown>[], base: BaseWork): Omit<SchedulerGroup, 'index'>[];

package/dist/components/scheduler/model/occurrence-info.d.ts

@@ -0,0 +1,8 @@
+/** Where an occurrence of a series comes from. */
+export interface OccurrenceInfo<T> {
+    series: T;
+    /** The time the rule gives it, in the form of the start field (a moment, or the day of an all-day one); its `recurrenceId` in RFC 5545. */
+    start: Date;
+    /** Its key in the layout. */
+    id: string;
+}

package/dist/components/scheduler/model/overlap-mode.d.ts

@@ -0,0 +1,2 @@
+/** How appointments at the same time share a column: side by side, or each a little to the side of the one under it. */
+export type OverlapMode = 'columns' | 'cascade';

package/dist/components/scheduler/model/place-lanes.d.ts

@@ -0,0 +1,10 @@
+/** A bar over a row of days: from day `first` to day `last`, both included. */
+export interface LaneSpan {
+    id: string;
+    first: number;
+    last: number;
+    /** Bars that begin on the same day go in this order. */
+    order: number;
+}
+/** Gives each bar the lowest line free over all its days; longer bars first, so they stay on top. */
+export declare function placeLanes(spans: readonly LaneSpan[]): Map<string, number>;