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

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

@@ -0,0 +1,17 @@
+/** An appointment along a row: from `start` to `end` (any unit, `end` not included). */
+export interface StackSpan {
+    id: string;
+    start: number;
+    end: number;
+    /** Ones that start together go in this order. */
+    order: number;
+}
+/**
+ * Gives each span the lowest lane free at its start, so the ones at the same time stack; earlier
+ * first, and of those the longer one, so it stays on top. A row's lanes are counted on that row
+ * alone.
+ */
+export declare function placeStack(spans: readonly StackSpan[]): {
+    lanes: Map<string, number>;
+    count: number;
+};

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

@@ -0,0 +1,18 @@
+/** An appointment's time in a day column, in minutes. */
+export interface TimedSpan {
+    id: string;
+    start: number;
+    end: number;
+}
+/** Where a span sits among the ones at the same time: its column, how many columns its group has, and how many it widens over. */
+export interface TimedPlace {
+    column: number;
+    columns: number;
+    spread: number;
+}
+/**
+ * Lays out one day column: spans that overlap (directly or through others) form a group; each
+ * takes the first column free at its start, the group is as wide as its most columns, and a span
+ * widens to the right over the columns nothing of its time is in.
+ */
+export declare function placeTimed(spans: readonly TimedSpan[]): Map<string, TimedPlace>;

package/dist/components/scheduler/model/range-filter-options.d.ts

@@ -0,0 +1,8 @@
+/** What else `rangeFilter` keeps to. */
+export interface RangeFilterOptions {
+    /**
+     * Resource fields and the values shown of each (`{ roomId: [1, 2] }`): only appointments with one
+     * of them come. For fields that hold one value; a field holding a list cannot be asked this way.
+     */
+    resources?: Record<string, readonly unknown[]>;
+}

package/dist/components/scheduler/model/range-filter.d.ts

@@ -0,0 +1,13 @@
+import type { data } from '@motifx-community/data';
+import type { SchedulerFields } from '../scheduler-fields';
+import type { SchedulerRange } from '../scheduler-range';
+import type { RangeFilterOptions } from './range-filter-options';
+/**
+ * The data layer's filter for the appointments a range may show: they start before it ends and
+ * end at or after it starts, or they repeat (a series that began before the range may happen in
+ * it; its occurrences are found by its rule). With `resources`, only the ones of those resources.
+ *
+ * @example
+ * source.setFilter(rangeFilter(scheduler.visibleRange, scheduler.fields, { resources: { roomId: [1, 2] } }));
+ */
+export declare function rangeFilter(range: SchedulerRange, fields: Pick<SchedulerFields, 'start' | 'end' | 'recurrenceRule'>, options?: RangeFilterOptions): data.FilterExpression;

package/dist/components/scheduler/model/resolved-view.d.ts

@@ -0,0 +1,23 @@
+import type { SchedulerViewType } from '../scheduler-view-type';
+import type { ScrollingMode } from './scrolling-mode';
+/** The view on screen with every setting decided (its own value, else the scheduler's). */
+export interface ResolvedView {
+    name: string;
+    type: SchedulerViewType;
+    intervalCount: number;
+    /** The date its intervals are counted from (with `intervalCount` over 1); `null`: the date shown. */
+    startDate?: Date | null;
+    startDayHour: number;
+    endDayHour: number;
+    cellDuration: number;
+    allDayPanel: boolean;
+    maxAppointmentsPerCell: number | 'auto';
+    /** The resource fields the columns are grouped by, outer first (the ones of a resource kind). */
+    groups: string[];
+    /** The groups stand under each date, not the dates under each group. */
+    groupByDate: boolean;
+    /** The days the agenda shows. Default 7. */
+    agendaDuration?: number;
+    /** Default `'auto'`. */
+    scrolling?: ScrollingMode;
+}

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

@@ -0,0 +1,5 @@
+import type { GroupResource } from './group-resource';
+/** A resource item an appointment has, with the item itself (`undefined` when no item has its value). */
+export interface ResourceEntry extends GroupResource {
+    item: unknown;
+}

package/dist/components/scheduler/model/same-value.d.ts

@@ -0,0 +1,2 @@
+/** Two resource values are the same: equal, or the same text (a key read as a number from one place, as a text from another). */
+export declare function sameValue(a: unknown, b: unknown): boolean;

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

@@ -0,0 +1,14 @@
+import type { SchedulerDay } from './scheduler-day';
+/** A head over a timeline's cells: a month or a day (the upper tier), an hour or a day (the lower). */
+export interface ScaleCell {
+    key: string;
+    /** The first cell it is over, and how many. */
+    first: number;
+    span: number;
+    kind: 'month' | 'day' | 'hour';
+    day: SchedulerDay;
+    /** Minutes after the day's start (an hour's). */
+    minutes: number;
+    /** The first hour of its day. */
+    dayStart: boolean;
+}

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

@@ -0,0 +1,21 @@
+import type { ColumnEdge } from './column-edge';
+import type { DayBlock } from './day-block';
+import type { SchedulerDay } from './scheduler-day';
+import type { SchedulerGroup } from './scheduler-group';
+/** A column of the view: a day, in a group. The same object stays at its place while the dates change. */
+export interface SchedulerColumn {
+    /** Its place in the view (in the month: over all the weeks). */
+    index: number;
+    day: SchedulerDay;
+    group: SchedulerGroup | null;
+    edge: ColumnEdge;
+    /** Its day is a work day for its group, and the work hours there. */
+    work: boolean;
+    workStart: number;
+    workEnd: number;
+    /** The blocked times of its day there; `blocked`: one takes the whole day. */
+    blocks: DayBlock[];
+    blocked: boolean;
+    /** Its group's names, read out with its cells; empty without groups. */
+    label: string;
+}

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

@@ -0,0 +1,21 @@
+/** A day the view shows. The same object stays at its place while the dates change. */
+export interface SchedulerDay {
+    /** Its place in the view, from 0. */
+    index: number;
+    /** The day's start, on the scheduler's clock. */
+    date: Date;
+    /** The day as a date of the browser's clock (what `isHoliday` and the calendar get). */
+    local: Date;
+    /** The day's start as a wall clock time (milliseconds of UTC with its fields): the layout counts on it. */
+    wall: number;
+    today: boolean;
+    /** A day before today. */
+    past: boolean;
+    /** A day of the work week. */
+    work: boolean;
+    /** Saturday or Sunday (by the locale's week). */
+    weekend: boolean;
+    holiday: boolean;
+    /** Month view: a day of the month before or after. */
+    outside: boolean;
+}

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

@@ -0,0 +1,14 @@
+import type { GroupResource } from './group-resource';
+/** A group of columns: one item of each resource kind grouped by, outer first. */
+export interface SchedulerGroup {
+    index: number;
+    /** Its values joined, the same while the items stay. */
+    key: string;
+    /** Its values by field (`{ roomId: 1, ownerId: 3 }`). */
+    values: Record<string, unknown>;
+    path: GroupResource[];
+    /** Its work hours and days: the innermost item's own, else the scheduler's. */
+    workStart: number;
+    workEnd: number;
+    workDays: readonly number[];
+}

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

@@ -0,0 +1,5 @@
+/**
+ * How a view builds what it shows: `'standard'` every cell and row, `'virtual'` only what is in
+ * view (and a little on each side), `'auto'` virtual once the cells pass a few thousand.
+ */
+export type ScrollingMode = 'auto' | 'standard' | 'virtual';

package/dist/components/scheduler/model/series-plan.d.ts

@@ -0,0 +1,9 @@
+/** The writes a change to a series comes to: appointments to add, to change and to delete, in that order. */
+export interface SeriesPlan<T> {
+    add: Partial<T>[];
+    update: {
+        item: T;
+        changes: Partial<T>;
+    }[];
+    remove: T[];
+}

package/dist/components/scheduler/model/series-run.d.ts

@@ -0,0 +1,14 @@
+import type { SeriesWrite } from './series-write';
+/** How the writes of a change to a series went. */
+export interface SeriesRun<T> {
+    /** The first appointment added (an occurrence changed apart, the series that goes on). */
+    added: T | null;
+    /** A write failed: `error` is why. */
+    failed: boolean;
+    error: unknown;
+    /** The writes saved before the failure, and the ones not made. */
+    saved: SeriesWrite<T>[];
+    unsaved: SeriesWrite<T>[];
+    /** Every saved write was taken back: the data is as it was. */
+    undone: boolean;
+}

package/dist/components/scheduler/model/series-scope.d.ts

@@ -0,0 +1,2 @@
+/** What a change to an occurrence of a series reaches: this one alone, this one and the ones after it, or every one. */
+export type SeriesScope = 'occurrence' | 'following' | 'series';

package/dist/components/scheduler/model/series-write.d.ts

@@ -0,0 +1,8 @@
+/** One write of a change to a series: an appointment added, changed or deleted. */
+export interface SeriesWrite<T> {
+    kind: 'add' | 'update' | 'delete';
+    /** The values added, or the appointment changed or deleted. */
+    appointment: T | Partial<T>;
+    /** What an update wrote. */
+    changes?: Partial<T>;
+}

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

@@ -0,0 +1,29 @@
+/** An all-day or multi-day appointment drawn as a bar over a row of days (the all-day panel, a week of the month). */
+export interface StripPiece<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 first column of the row it covers, and how many; the group's index (-1 without groups). */
+    first: number;
+    span: number;
+    group: number;
+    /** Its line in the row, from 0. */
+    lane: number;
+    /** Lines past what the row has room for are left out ("+N more"). */
+    hidden: boolean;
+    before: boolean;
+    after: boolean;
+    /** For a timed appointment shown in a month: its start time is written before the text. */
+    timed: boolean;
+    start: Date;
+    end: Date;
+    draft: boolean;
+    invalid: boolean;
+    /** The appointment's text, colour and whether it is disabled, as its box shows them. */
+    text: string;
+    color: string;
+    disabled: boolean;
+    /** An occurrence of a series, or one changed apart from its series. */
+    series: boolean;
+    exception: boolean;
+}

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

@@ -0,0 +1,17 @@
+import type { SchedulerColumn } from './scheduler-column';
+import type { SchedulerDay } from './scheduler-day';
+import type { StripPiece } from './strip-piece';
+/** A row of days with bars over it: the all-day panel, or a week of the month view. */
+export interface StripRow<T> {
+    index: number;
+    days: SchedulerDay[];
+    /** Its columns: a day, in a group. */
+    columns: SchedulerColumn[];
+    pieces: StripPiece<T>[];
+    /** Per column: the appointments left out. */
+    more: number[];
+    /** Per column: the line "+N more" goes on. */
+    moreAt: number[];
+    /** How many lines the bars take. */
+    lanes: number;
+}

package/dist/components/scheduler/model/time-slot.d.ts

@@ -0,0 +1,8 @@
+/** A row of the day columns: a cell's time of day. */
+export interface TimeSlot {
+    index: number;
+    /** Minutes after midnight. */
+    minutes: number;
+    /** The first cell of an hour (it carries the hour's label). */
+    hourStart: boolean;
+}

package/dist/components/scheduler/model/time-tick.d.ts

@@ -0,0 +1,14 @@
+import type { SchedulerDay } from './scheduler-day';
+/** A cell along a timeline's time: a time row of a day, or a whole day (`slot` -1). The same object stays at its place while the dates change. */
+export interface TimeTick {
+    /** Its place along the time, from 0. */
+    index: number;
+    day: SchedulerDay;
+    /** The time row of the day (`-1`: the whole day). */
+    slot: number;
+    /** Minutes after the day's start on the clock. */
+    minutes: number;
+    /** The first cell of an hour, and of a day of hours (a whole day's cell is not one). */
+    hourStart: boolean;
+    dayStart: boolean;
+}

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

@@ -0,0 +1,31 @@
+/** The part of an appointment shown in one day column, placed by the overlap layout. Kept while it stays on screen. */
+export interface TimedPiece<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 column it stands in (a day, in a group), and the group's index (-1 without groups). */
+    column: number;
+    group: number;
+    /** The part's own time, within the day. */
+    start: Date;
+    end: Date;
+    /** Fractions of the column (0–1). */
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+    /** It began on an earlier day, or goes on after this one. */
+    before: boolean;
+    after: boolean;
+    /** It is the appointment being moved or resized, shown where it would go. */
+    draft: boolean;
+    /** …where it may not go. */
+    invalid: boolean;
+    /** The appointment's text, colour and whether it is disabled, as its box shows them. */
+    text: string;
+    color: string;
+    disabled: boolean;
+    /** An occurrence of a series, or one changed apart from its series. */
+    series: boolean;
+    exception: boolean;
+}

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

@@ -0,0 +1,27 @@
+import type { LinePiece } from './line-piece';
+import type { SchedulerGroup } from './scheduler-group';
+/** A row of a timeline: a group of resources (one row without groups). The same object stays at its place while its group does. */
+export interface TimelineRow<T> {
+    index: number;
+    key: string;
+    group: SchedulerGroup | null;
+    /** The column of its first day: its cells are the columns from here, a day each. */
+    first: number;
+    /** Per level of the groups: this row is the first of its item there (its head cell shows the name). */
+    starts: boolean[];
+    /** The outer item changes here (the line over it is the group's divider). */
+    edge: 'outer' | 'inner' | '';
+    /** Its group's names, read out with its cells; empty without groups. */
+    label: string;
+    /** Its appointments, each on a lane, and how many lanes they take (with the line of "+N more"). */
+    pieces: LinePiece<T>[];
+    lanes: number;
+    /** Its height in pixels: the lanes it takes, or the least a row has. */
+    height: number;
+    /** The days with appointments left out (by the day's index) and how many, and the lane "+N more" stands on. */
+    more: {
+        day: number;
+        count: number;
+    }[];
+    moreLane: number;
+}

package/dist/components/scheduler/model/to-date.d.ts

@@ -0,0 +1,2 @@
+/** A field value as a date: a `Date`, an ISO text or milliseconds; `null` for anything else. */
+export declare function toDate(value: unknown): Date | null;

package/dist/components/scheduler/model/view-dates.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedView } from './resolved-view';
+/** The start of the week `date` is in. */
+export declare function weekStart(date: Date, firstDayOfWeek: number): Date;
+/** The days a view shows around `date`. */
+export declare function viewDates(view: ResolvedView, date: Date, firstDayOfWeek: number, workDays: readonly number[]): Date[];
+/** The date one step (`by` = 1) or more after or before `date` in a view: a day, a week or a month times its interval (the agenda: its days). */
+export declare function stepDate(view: ResolvedView, date: Date, by: number): Date;

package/dist/components/scheduler/model/view-kind.d.ts

@@ -0,0 +1,6 @@
+import type { SchedulerViewType } from '../scheduler-view-type';
+/** The layout a view type uses: day columns with hours (`time`), the month, a timeline, or the agenda. */
+export type ViewKind = 'time' | 'month' | 'timeline' | 'agenda';
+export declare function viewKind(type: SchedulerViewType): ViewKind;
+/** A view whose cells are whole days (the month, the timeline month): no hours. */
+export declare function dayCells(type: SchedulerViewType): boolean;

package/dist/components/scheduler/more-list-context.d.ts

@@ -0,0 +1,7 @@
+/** What a "+N more" list template gets: the day, its appointments and how to open one. */
+export interface MoreListContext<T> {
+    readonly date: Date | null;
+    readonly appointments: readonly T[];
+    /** Closes the list and does what a click on the appointment does. */
+    choose(appointment: T, event: MouseEvent | KeyboardEvent): void;
+}

package/dist/components/scheduler/more-opening-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** "+N more" was pressed: the day's list is about to open; `cancel = true` keeps it closed (to show the day yourself). */
+export interface MoreOpeningEventArgs<T = unknown> extends EventArgs {
+    date: Date;
+    appointments: readonly T[];
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/presentation-changed-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { Scheduler } from './Scheduler';
+import type { SchedulerPresentationKind } from './scheduler-presentation-kind';
+export interface SchedulerPresentationChangedEventArgs<T = unknown> {
+    from: SchedulerPresentationKind;
+    to: SchedulerPresentationKind;
+    width: number;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/presentation-changing-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+import type { SchedulerPresentationKind } from './scheduler-presentation-kind';
+/** The scheduler is about to show itself another way; `cancel = true` keeps the way it is (until the width or the setting changes again). */
+export interface SchedulerPresentationChangingEventArgs<T = unknown> extends EventArgs {
+    from: SchedulerPresentationKind;
+    to: SchedulerPresentationKind;
+    /** The scheduler's width, in pixels. */
+    width: number;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/printed-event-args.d.ts

@@ -0,0 +1,5 @@
+import type { Scheduler } from './Scheduler';
+/** The print dialog has closed. */
+export interface PrintedEventArgs<T = unknown> {
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/printing-event-args.d.ts

@@ -0,0 +1,6 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** The scheduler is about to be printed; `cancel = true` prints nothing. */
+export interface PrintingEventArgs<T = unknown> extends EventArgs {
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/recurrence-editor-props.d.ts

@@ -0,0 +1,30 @@
+import type { Bind } from '@motifx/core';
+import type { ControlProps } from '../../core/control';
+import type { UiStrings } from '../../core/ui-strings';
+import type { RecurrenceFrequency } from '../../parts/recurrence/recurrence-frequency';
+import type { ValueChangedEventArgs } from '../../parts/field/value-changed-event-args';
+/** Props of `RecurrenceEditor`. Each one is also a settable property: setting it updates the editor. */
+export interface RecurrenceEditorProps extends ControlProps {
+    /** Names the editor for screen readers. The same property as `text`. */
+    label?: Bind<string>;
+    /** The rule, as RFC 5545 text (`FREQ=WEEKLY;BYDAY=MO,WE`); empty when it does not repeat. Two-way with `x-model`. */
+    value?: Bind<string>;
+    /** When what repeats starts: a rule's weekday and day of the month come from it unless it names them. Default now. */
+    start?: Bind<Date | null>;
+    /** An all-day series: its last date is written as a date. Default `false`. */
+    allDay?: Bind<boolean>;
+    /** The time zone the series repeats in (an IANA name); its last date ends on that clock. Default: the browser's. */
+    timeZone?: Bind<string | null>;
+    /** The choices of the repeat list, in order. Default: never, daily, weekly, monthly and yearly. */
+    frequencies?: Bind<readonly ('never' | RecurrenceFrequency)[]>;
+    /** 0 Sunday … 6 Saturday: the first of the weekday buttons. Default: the locale's. */
+    firstDayOfWeek?: Bind<number | null>;
+    /** The line under it that says how it repeats. Default `true`. */
+    summary?: Bind<boolean>;
+    readOnly?: Bind<boolean>;
+    /** Default: the page's language. */
+    locale?: Bind<string>;
+    /** Changes the texts it writes; the rest come from `uiLocale`. */
+    texts?: Bind<Partial<UiStrings>>;
+    onValueChanged?: (e: ValueChangedEventArgs<string>) => void;
+}

package/dist/components/scheduler/resource-header-context.d.ts

@@ -0,0 +1,17 @@
+/** What a resource header template gets: the item a group head stands for. */
+export interface ResourceHeaderContext {
+    /** The appointment field of its kind, and the kind's name. */
+    field: string;
+    label: string;
+    value: unknown;
+    /** The resource item itself (`undefined` when only its value is known). */
+    item: unknown;
+    text: string;
+    color: string;
+    /** Its level in the groups, from 0 (the outermost). */
+    level: number;
+    /** The values of its group down to it, by field. */
+    values: Record<string, unknown>;
+    /** Under `groupByDate`, the date it stands under; otherwise `null`. */
+    date: Date | null;
+}

package/dist/components/scheduler/scheduler-blocked-time.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A time nothing may be put in: a lunch break, a room under repair. It is shaded on the days
+ * shown; with `resources`, only for those (`{ roomId: 2 }`, or a list of values).
+ */
+export interface SchedulerBlockedTime {
+    start: Date;
+    end: Date;
+    /** Read out with the cells it covers. */
+    text?: string;
+    /** Whole days, from the day of `start` up to the day of `end`. */
+    allDay?: boolean;
+    /** It repeats by an RFC 5545 rule (`FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR`), on the scheduler's clock. */
+    recurrenceRule?: string;
+    /** The resources it is for, by field; left out, it is for every one. */
+    resources?: Record<string, unknown>;
+}

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

@@ -0,0 +1,9 @@
+/** A time on the scheduler's grid: a cell, or several cells selected together. */
+export interface SchedulerCell {
+    start: Date;
+    end: Date;
+    /** A cell of the all-day panel, or a day of the month view. */
+    allDay: boolean;
+    /** In a group: its resource values, by field (`{ roomId: 1 }`); a new appointment there gets them. */
+    resources?: Record<string, unknown> | null;
+}

package/dist/components/scheduler/scheduler-editing.d.ts

@@ -0,0 +1,24 @@
+import type { SchedulerForm } from './scheduler-form';
+/** What the user may change, and the form. Each is a switch of its own; an appointment's own field (`fields.allowDrag`…) wins over it. */
+export interface SchedulerEditing<T = unknown> {
+    /** A double click (or Enter) on cells opens the form for a new appointment. Default `true`. */
+    allowAdding: boolean;
+    /** The form edits an appointment. Default `true`. */
+    allowUpdating: boolean;
+    /** Delete, and the form's and the tooltip's Delete. Default `true`. */
+    allowDeleting: boolean;
+    /** Moving by dragging and by the keys. Default `true`. */
+    allowDragging: boolean;
+    /** Changing the start or the end by its edges and by the keys. Default `true`. */
+    allowResizing: boolean;
+    /** Ctrl while dragging drops a copy. Default `true`. */
+    allowCopying: boolean;
+    /** Asks before deleting. Default `true`. */
+    confirmDelete: boolean;
+    /** The form edits how an appointment repeats. Default `true`. */
+    allowRecurrence: boolean;
+    /** The form edits the time zones of the start and the end. Default `false`. */
+    allowTimeZones: boolean;
+    /** What the appointment form holds and how it is laid out, without events (`onFormOpening` still gets the items). */
+    form?: SchedulerForm<T>;
+}

package/dist/components/scheduler/scheduler-fields.d.ts

@@ -0,0 +1,39 @@
+/** The fields of an appointment object the scheduler reads. */
+export interface SchedulerFields {
+    /** Default `'id'`: what tells two appointments apart. */
+    key: string;
+    /** Default `'startDate'`: a `Date`, an ISO text or a number of milliseconds. */
+    start: string;
+    /** Default `'endDate'`. */
+    end: string;
+    /** Default `'text'`. */
+    text: string;
+    /** Default `'allDay'`. */
+    allDay: string;
+    /** Default `'description'`. */
+    description: string;
+    /** Default `'color'`: a CSS colour of its own. */
+    color: string;
+    /** Default `'disabled'`. */
+    disabled: string;
+    /** Default `'visible'`: `false` leaves it out. */
+    visible: string;
+    /** Default `'allowDrag'`: `false` keeps it in place, whatever `editing` says. */
+    allowDrag: string;
+    /** Default `'allowResize'`. */
+    allowResize: string;
+    /** Default `'allowEdit'`: `false` opens no form for it. */
+    allowEdit: string;
+    /** Default `'allowDelete'`. */
+    allowDelete: string;
+    /** Default `'recurrenceRule'`: how it repeats, an RFC 5545 rule (`FREQ=WEEKLY;BYDAY=MO,WE`); empty for once. */
+    recurrenceRule: string;
+    /** Default `'recurrenceException'`: the times of a series left out (`EXDATE`), a text apart by commas or a list of dates. */
+    recurrenceException: string;
+    /** Default `'recurrenceId'`: on an occurrence changed apart from its series, the key of that series. */
+    recurrenceId: string;
+    /** Default `'startDateTimeZone'`: the IANA time zone the start is set in (and a series repeats in); empty for the scheduler's. */
+    startTimeZone: string;
+    /** Default `'endDateTimeZone'`: the time zone the end is set in; empty for the start's. */
+    endTimeZone: string;
+}

package/dist/components/scheduler/scheduler-form-item.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentBase } from '@motifx/core';
+import type { FormItem } from '../formlayout/form-item';
+import type { FormTemplateContext } from '../formlayout/form-template-context';
+import type { ValidationRule } from '../../parts/validation/validation-rule';
+import type { AppointmentFormContext } from './appointment-form-context';
+import type { FormBind } from './form-bind';
+import type { SchedulerFormTab } from './scheduler-form-tab';
+/**
+ * An item of the appointment form: a kit form item, whose settings may also be functions of the
+ * form (shown, locked or required for one appointment only), and whose groups and tabs hold
+ * items given the same way.
+ */
+export interface SchedulerFormItem<T = unknown> extends Omit<FormItem, 'label' | 'required' | 'rules' | 'helpText' | 'visible' | 'enabled' | 'readOnly' | 'group' | 'items' | 'tabs' | 'template'> {
+    label?: FormBind<string, T>;
+    required?: FormBind<boolean, T>;
+    /** Added to the rules a built-in item has. */
+    rules?: FormBind<readonly ValidationRule[], T>;
+    helpText?: FormBind<string, T>;
+    visible?: FormBind<boolean, T>;
+    enabled?: FormBind<boolean, T>;
+    readOnly?: FormBind<boolean, T>;
+    group?: FormBind<string, T>;
+    items?: readonly (string | SchedulerFormItem<T>)[];
+    tabs?: readonly SchedulerFormTab<T>[];
+    /** Any MotifJS component, made for this place: bind it to `form.data[place.field]`. */
+    template?: (form: AppointmentFormContext<T>, place: FormTemplateContext) => ComponentBase;
+}

package/dist/components/scheduler/scheduler-form-tab.d.ts

@@ -0,0 +1,9 @@
+import type { FormBind } from './form-bind';
+import type { SchedulerFormItem } from './scheduler-form-item';
+/** A tab of the appointment form: its caption and its items (by name, or items of the form's own). */
+export interface SchedulerFormTab<T = unknown> {
+    title: FormBind<string, T>;
+    items: readonly (string | SchedulerFormItem<T>)[];
+    columns?: number;
+    visible?: FormBind<boolean, T>;
+}