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

package/dist/components/scheduler/RecurrenceEditor.d.ts

@@ -0,0 +1,66 @@
+import { type Bind, type Event as MotifEvent, type IBaseProp } from '@motifx/core';
+import { Control } from '../../core/control';
+import type { UiStrings } from '../../core/ui-strings';
+import type { ValueChangedEventArgs } from '../../parts/field/value-changed-event-args';
+import type { RecurrenceFrequency } from '../../parts/recurrence/recurrence-frequency';
+import type { RecurrenceRule } from '../../parts/recurrence/recurrence-rule';
+import type { RecurrenceEditorProps } from './recurrence-editor-props';
+/**
+ * How something repeats, edited: the repeat list (never, daily, weekly, monthly, yearly), every how
+ * many, the weekdays of a week, a day of the month or a weekday by its place (the second Tuesday,
+ * the last Friday), the month of a year, and the end (never, after a number of times, on a date).
+ * It reads and writes an RFC 5545 rule (`value`, two-way with `x-model`) and says it in plain words
+ * under it. The scheduler's appointment form holds one; it works on its own anywhere else, and in
+ * a `FormLayout` (`FormLayout.editors.set('recurrence', (p) => new RecurrenceEditor(p))`). Its editors
+ * are made once and written by hand when a choice, a property or the language changes.
+ *
+ * @example
+ * <RecurrenceEditor x-model={() => state.rule} start={() => state.start} />
+ */
+export declare class RecurrenceEditor extends Control<HTMLDivElement, RecurrenceEditorProps> {
+    constructor(props?: IBaseProp<RecurrenceEditorProps>);
+    get label(): string;
+    set label(value: Bind<string>);
+    /** The rule as RFC 5545 text; empty when it does not repeat. */
+    get value(): string;
+    set value(value: Bind<string>);
+    get start(): Date | null;
+    set start(value: Bind<Date | null>);
+    get allDay(): boolean;
+    set allDay(value: Bind<boolean>);
+    get timeZone(): string | null;
+    set timeZone(value: Bind<string | null>);
+    get frequencies(): readonly ('never' | RecurrenceFrequency)[];
+    set frequencies(value: Bind<readonly ('never' | RecurrenceFrequency)[]>);
+    get firstDayOfWeek(): number;
+    set firstDayOfWeek(value: Bind<number | null>);
+    get summary(): boolean;
+    set summary(value: Bind<boolean>);
+    get readOnly(): boolean;
+    set readOnly(value: Bind<boolean>);
+    get locale(): string;
+    set locale(value: Bind<string>);
+    get texts(): Partial<UiStrings>;
+    set texts(value: Bind<Partial<UiStrings>>);
+    /** The rule read from `value`; `null` when it does not repeat (or the text is not a rule). Reactive. */
+    get rule(): RecurrenceRule | null;
+    /** How it repeats, in plain words. Reactive. */
+    get summaryText(): string;
+    get onValueChanged(): MotifEvent<ValueChangedEventArgs<string>>;
+    onConfigured(): void;
+    onConfig(): void;
+    private get parts();
+    /** The editors of the choices, made once; `show` writes them. Each tells a choice of the user's to `chosen`. */
+    private makeEditors;
+    /** The rule (or what it is read for) changed: the choices show it. */
+    private readValue;
+    /** The user changed a choice: the rule is written from the choices. */
+    private chosen;
+    /** Every editor shows its choice, its texts and whether the choices want it. */
+    private show;
+    /** A list's items, given again only when they changed (another language, another first day of the week). */
+    private list;
+    private draftContext;
+    private strings;
+    private textOf;
+}

package/dist/components/scheduler/Scheduler.d.ts

@@ -0,0 +1,515 @@
+import { type Bind, type ComponentBase, type Event as MotifEvent, type IBaseProp } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import { Control } from '../../core/control';
+import type { UiStrings } from '../../core/ui-strings';
+import type { AppointmentAddedEventArgs } from './appointment-added-event-args';
+import type { AppointmentAddingEventArgs } from './appointment-adding-event-args';
+import type { AppointmentClickEventArgs } from './appointment-click-event-args';
+import type { AppointmentDeletedEventArgs } from './appointment-deleted-event-args';
+import type { AppointmentDeletingEventArgs } from './appointment-deleting-event-args';
+import type { AppointmentUpdatedEventArgs } from './appointment-updated-event-args';
+import type { AppointmentUpdatingEventArgs } from './appointment-updating-event-args';
+import type { DataErrorEventArgs } from './data-error-event-args';
+import type { DragEventArgs } from './drag-event-args';
+import type { FormOpeningEventArgs } from './form-opening-event-args';
+import type { SchedulerEditing } from './scheduler-editing';
+import type { AppointmentTemplateContext } from './appointment-template-context';
+import type { AgendaRowContext } from './agenda-row-context';
+import type { CellTemplateContext } from './cell-template-context';
+import type { DateTemplateContext } from './date-template-context';
+import type { MoreListContext } from './more-list-context';
+import type { TimeTemplateContext } from './time-template-context';
+import type { TooltipTemplateContext } from './tooltip-template-context';
+import type { ScrollingMode } from './model/scrolling-mode';
+import type { CellClickEventArgs } from './cell-click-event-args';
+import type { ContentReadyEventArgs } from './content-ready-event-args';
+import type { DateChangedEventArgs } from './date-changed-event-args';
+import type { DateChangingEventArgs } from './date-changing-event-args';
+import type { OverlapMode } from './model/overlap-mode';
+import type { ResolvedView } from './model/resolved-view';
+import type { SeriesScope } from './model/series-scope';
+import type { MoreOpeningEventArgs } from './more-opening-event-args';
+import type { SchedulerCell } from './scheduler-cell';
+import type { SchedulerFields } from './scheduler-fields';
+import type { SchedulerKeys } from './scheduler-keys';
+import type { SchedulerProps } from './scheduler-props';
+import type { ResourceHeaderContext } from './resource-header-context';
+import type { SchedulerBlockedTime } from './scheduler-blocked-time';
+import type { SchedulerResource } from './scheduler-resource';
+import type { SchedulerTimeCheck } from './scheduler-time-check';
+import type { SchedulerRange } from './scheduler-range';
+import type { SchedulerView } from './scheduler-view';
+import type { SchedulerViewType } from './scheduler-view-type';
+import type { SelectionChangedEventArgs } from './selection-changed-event-args';
+import type { SeriesAction } from './series-action';
+import type { SeriesAnsweredEventArgs } from './series-answered-event-args';
+import type { SeriesAskingEventArgs } from './series-asking-event-args';
+import type { SeriesEditMode } from './series-edit-mode';
+import type { ViewChangedEventArgs } from './view-changed-event-args';
+import type { ViewChangingEventArgs } from './view-changing-event-args';
+import type { SchedulerPresentation } from './scheduler-presentation';
+import type { SchedulerPresentationKind } from './scheduler-presentation-kind';
+import type { SchedulerTabletWhen } from './scheduler-tablet-when';
+import type { SchedulerPresentationChangingEventArgs } from './presentation-changing-event-args';
+import type { SchedulerPresentationChangedEventArgs } from './presentation-changed-event-args';
+import type { TimeZoomChangingEventArgs } from './time-zoom-changing-event-args';
+import type { TimeZoomChangedEventArgs } from './time-zoom-changed-event-args';
+import type { ICalendarExportOptions } from './icalendar-export-options';
+import type { ICalendarExportingEventArgs } from './icalendar-exporting-event-args';
+import type { ICalendarExportedEventArgs } from './icalendar-exported-event-args';
+import type { ICalendarImportingEventArgs } from './icalendar-importing-event-args';
+import type { ICalendarImportedEventArgs } from './icalendar-imported-event-args';
+import type { ICalendarImportResult } from './icalendar-import-result';
+import type { PrintingEventArgs } from './printing-event-args';
+import type { PrintedEventArgs } from './printed-event-args';
+/**
+ * A scheduler: appointments over days and hours, in day, week, work week and month views. The
+ * appointments come from an array or a `DataSource`; the fields it reads are options. The array
+ * and the appointments may be plain or reactive: they are read as they are, the objects handed
+ * back are the ones given, and a change made in place shows after `refresh()` (its own edits and
+ * the data source's changes show at once). It moves by day, week or month (today, previous, next, a date chosen from a
+ * calendar), selects cells with the pointer and the keyboard, places appointments at the same
+ * time side by side, shows all-day and multi-day ones as bars, and what does not fit a month day
+ * as "+N more". Resources colour the appointments and split the columns into groups (nested, or
+ * under each date); blocked times, work hours per resource and an overlap rule say where an
+ * appointment may go. Every setting is a value or a function that is followed; a view's own
+ * settings win over the scheduler's.
+ *
+ * @example
+ * <Scheduler appointments={state.meetings} currentView="week" startDayHour={7} onAppointmentDblClick={(e) => open(e.appointment)} />
+ */
+export declare class Scheduler<T = Record<string, unknown>> extends Control<HTMLDivElement, SchedulerProps<T>> {
+    constructor(props?: IBaseProp<SchedulerProps<T>>);
+    get label(): string;
+    set label(value: Bind<string>);
+    get appointments(): readonly T[];
+    set appointments(value: Bind<readonly T[]>);
+    get dataSource(): data.DataSource<T, unknown> | null;
+    set dataSource(value: Bind<data.DataSource<T, unknown> | null>);
+    get remoteFiltering(): boolean;
+    set remoteFiltering(value: Bind<boolean>);
+    get fields(): SchedulerFields;
+    set fields(value: Bind<Partial<SchedulerFields>>);
+    get views(): readonly (SchedulerViewType | SchedulerView<T>)[];
+    set views(value: Bind<readonly (SchedulerViewType | SchedulerView<T>)[]>);
+    /** The view on screen, by name. */
+    get currentView(): string;
+    set currentView(value: Bind<string>);
+    get currentDate(): Date;
+    set currentDate(value: Bind<Date>);
+    get firstDayOfWeek(): number;
+    set firstDayOfWeek(value: Bind<number | null>);
+    get workDays(): readonly number[];
+    set workDays(value: Bind<readonly number[]>);
+    get workStartHour(): number;
+    set workStartHour(value: Bind<number>);
+    get workEndHour(): number;
+    set workEndHour(value: Bind<number>);
+    get startDayHour(): number;
+    set startDayHour(value: Bind<number>);
+    get endDayHour(): number;
+    set endDayHour(value: Bind<number>);
+    get cellDuration(): number;
+    set cellDuration(value: Bind<number>);
+    get allDayPanel(): boolean;
+    set allDayPanel(value: Bind<boolean>);
+    get allDayLines(): number;
+    set allDayLines(value: Bind<number>);
+    get maxAppointmentsPerCell(): number | 'auto';
+    set maxAppointmentsPerCell(value: Bind<number | 'auto'>);
+    /** The days the agenda shows. */
+    get agendaDuration(): number;
+    set agendaDuration(value: Bind<number>);
+    /** Whether a view builds every cell and row or only what is in view. */
+    get scrolling(): ScrollingMode;
+    set scrolling(value: Bind<ScrollingMode>);
+    get overlapMode(): OverlapMode;
+    set overlapMode(value: Bind<OverlapMode>);
+    get isHoliday(): ((date: Date) => boolean) | null;
+    set isHoliday(value: Bind<((date: Date) => boolean) | null>);
+    get showCurrentTime(): boolean;
+    set showCurrentTime(value: Bind<boolean>);
+    get dimPast(): boolean;
+    set dimPast(value: Bind<boolean>);
+    get scrollHour(): number | null;
+    set scrollHour(value: Bind<number | null>);
+    get toolbar(): boolean;
+    set toolbar(value: Bind<boolean>);
+    get locale(): string;
+    set locale(value: Bind<string>);
+    /** The clock the days and hours are on, an IANA time zone; `null` for the browser's. */
+    get timeZone(): string | null;
+    set timeZone(value: Bind<string | null>);
+    /** What changing or deleting an occurrence of a series reaches; `'ask'` asks the user. */
+    get seriesEdit(): SeriesEditMode;
+    set seriesEdit(value: Bind<SeriesEditMode>);
+    /** Marks on occurrences of a series and on ones changed apart. Default `true`. */
+    get recurrenceMarks(): boolean;
+    set recurrenceMarks(value: Bind<boolean>);
+    get appointmentTemplate(): ((context: AppointmentTemplateContext<T>) => ComponentBase) | null;
+    set appointmentTemplate(value: Bind<((context: AppointmentTemplateContext<T>) => ComponentBase) | null>);
+    get appointmentTooltipTemplate(): ((context: TooltipTemplateContext<T>) => ComponentBase) | null;
+    set appointmentTooltipTemplate(value: Bind<((context: TooltipTemplateContext<T>) => ComponentBase) | null>);
+    get dataCellTemplate(): ((context: CellTemplateContext) => ComponentBase) | null;
+    set dataCellTemplate(value: Bind<((context: CellTemplateContext) => ComponentBase) | null>);
+    get dateCellTemplate(): ((context: DateTemplateContext) => ComponentBase) | null;
+    set dateCellTemplate(value: Bind<((context: DateTemplateContext) => ComponentBase) | null>);
+    get timeCellTemplate(): ((context: TimeTemplateContext) => ComponentBase) | null;
+    set timeCellTemplate(value: Bind<((context: TimeTemplateContext) => ComponentBase) | null>);
+    get agendaRowTemplate(): ((context: AgendaRowContext<T>) => ComponentBase) | null;
+    set agendaRowTemplate(value: Bind<((context: AgendaRowContext<T>) => ComponentBase) | null>);
+    get moreListTemplate(): ((context: MoreListContext<T>) => ComponentBase) | null;
+    set moreListTemplate(value: Bind<((context: MoreListContext<T>) => ComponentBase) | null>);
+    get resources(): readonly SchedulerResource<any>[];
+    set resources(value: Bind<readonly SchedulerResource<any>[]>);
+    /** The resource fields the columns are grouped by, outer first. */
+    get groups(): readonly string[];
+    set groups(value: Bind<readonly string[]>);
+    get groupByDate(): boolean;
+    set groupByDate(value: Bind<boolean>);
+    get resourceHeaderTemplate(): ((context: ResourceHeaderContext) => ComponentBase) | null;
+    set resourceHeaderTemplate(value: Bind<((context: ResourceHeaderContext) => ComponentBase) | null>);
+    /** Times nothing may be put in. */
+    get blockedTimes(): readonly SchedulerBlockedTime[];
+    set blockedTimes(value: Bind<readonly SchedulerBlockedTime[]>);
+    /** Whether the user may make an appointment overlap another of its group; or a rule that decides whether a time is free. Default `true`. */
+    get allowOverlap(): boolean | ((check: SchedulerTimeCheck<T>) => boolean);
+    set allowOverlap(value: Bind<boolean | ((check: SchedulerTimeCheck<T>) => boolean)>);
+    /** Whether the user may put an appointment outside the work hours. Default `true`. */
+    get allowOffHours(): boolean;
+    set allowOffHours(value: Bind<boolean>);
+    get texts(): Partial<UiStrings>;
+    set texts(value: Bind<Partial<UiStrings>>);
+    get keys(): SchedulerKeys;
+    set keys(value: Bind<Partial<SchedulerKeys>>);
+    get announce(): boolean;
+    set announce(value: Bind<boolean>);
+    /** What the user may change; `false` changes nothing (read only), `true` everything. */
+    get editing(): SchedulerEditing<T>;
+    set editing(value: Bind<boolean | Partial<SchedulerEditing<T>>>);
+    /** The minutes a drag and the keys move by. Default: the view's cell. */
+    get snapMinutes(): number;
+    set snapMinutes(value: Bind<number>);
+    /** The shortest an appointment gets by resizing, in minutes. Default: `snapMinutes`. */
+    get minDuration(): number;
+    set minDuration(value: Bind<number>);
+    /** A click on an appointment shows its tooltip. Default `true`. */
+    get tooltip(): boolean;
+    set tooltip(value: Bind<boolean>);
+    /** How it shows itself: by its own width (`'auto'`), or always as on a desktop, a tablet or a phone. */
+    get presentation(): SchedulerPresentation;
+    set presentation(value: Bind<SchedulerPresentation>);
+    get tabletWidth(): number;
+    set tabletWidth(value: Bind<number>);
+    get phoneWidth(): number;
+    set phoneWidth(value: Bind<number>);
+    /** When `'auto'` shows it as on a tablet: on a touch screen under `tabletWidth`, or under it whatever the pointer. */
+    get tabletWhen(): SchedulerTabletWhen;
+    set tabletWhen(value: Bind<SchedulerTabletWhen>);
+    /** The view it shows as on a phone, by name or type (the agenda, else a day); `null` keeps the view. */
+    get phoneView(): string | null;
+    set phoneView(value: Bind<string | null>);
+    /** The view it shows as on a tablet, by name or type; `null` keeps the view. */
+    get tabletView(): string | null;
+    set tabletView(value: Bind<string | null>);
+    get swipeNavigation(): boolean;
+    set swipeNavigation(value: Bind<boolean>);
+    get pinchZoom(): boolean;
+    set pinchZoom(value: Bind<boolean>);
+    /** How far the time scale is zoomed, from 0.5 to 4. */
+    get timeZoom(): number;
+    set timeZoom(value: Bind<number>);
+    /** How it shows itself now: `presentation`, or by its width when that is `'auto'`. Reactive. */
+    get currentPresentation(): SchedulerPresentationKind;
+    /** The days on screen, `end` not included. Reactive. */
+    get visibleRange(): SchedulerRange;
+    /** The view on screen with every setting decided. Reactive. */
+    get resolvedView(): ResolvedView;
+    /** The selected cells as one time, or `null`. Reactive. */
+    get selectedCells(): SchedulerCell | null;
+    /** The appointments in the days shown, in time order. Reactive. */
+    get shownAppointments(): readonly T[];
+    /** Whether the data source is loading. Reactive. */
+    get loading(): boolean;
+    /** The data source's status: the content shows loading or a failure. */
+    private setStatus;
+    /** The appointment a finger selected ('' for none): its box shows its handles. */
+    private setTouchSelected;
+    /** A swipe between dates: the content follows the finger and the edge shows what comes. */
+    private drawSwipe;
+    get onViewChanging(): MotifEvent<ViewChangingEventArgs<T>>;
+    get onViewChanged(): MotifEvent<ViewChangedEventArgs<T>>;
+    get onDateChanging(): MotifEvent<DateChangingEventArgs<T>>;
+    get onDateChanged(): MotifEvent<DateChangedEventArgs<T>>;
+    get onCellClick(): MotifEvent<CellClickEventArgs<T>>;
+    get onCellDblClick(): MotifEvent<CellClickEventArgs<T>>;
+    get onAppointmentClick(): MotifEvent<AppointmentClickEventArgs<T>>;
+    get onAppointmentDblClick(): MotifEvent<AppointmentClickEventArgs<T>>;
+    get onSelectionChanged(): MotifEvent<SelectionChangedEventArgs<T>>;
+    get onContentReady(): MotifEvent<ContentReadyEventArgs<T>>;
+    get onMoreOpening(): MotifEvent<MoreOpeningEventArgs<T>>;
+    get onAppointmentAdding(): MotifEvent<AppointmentAddingEventArgs<T>>;
+    get onAppointmentAdded(): MotifEvent<AppointmentAddedEventArgs<T>>;
+    get onAppointmentUpdating(): MotifEvent<AppointmentUpdatingEventArgs<T>>;
+    get onAppointmentUpdated(): MotifEvent<AppointmentUpdatedEventArgs<T>>;
+    get onAppointmentDeleting(): MotifEvent<AppointmentDeletingEventArgs<T>>;
+    get onAppointmentDeleted(): MotifEvent<AppointmentDeletedEventArgs<T>>;
+    get onFormOpening(): MotifEvent<FormOpeningEventArgs<T>>;
+    get onDataError(): MotifEvent<DataErrorEventArgs<T>>;
+    get onMoveStart(): MotifEvent<DragEventArgs<T>>;
+    get onMoving(): MotifEvent<DragEventArgs<T>>;
+    get onMoveEnd(): MotifEvent<DragEventArgs<T>>;
+    get onResizeStart(): MotifEvent<DragEventArgs<T>>;
+    get onResizing(): MotifEvent<DragEventArgs<T>>;
+    get onResizeEnd(): MotifEvent<DragEventArgs<T>>;
+    get onSeriesAsking(): MotifEvent<SeriesAskingEventArgs<T>>;
+    get onSeriesAnswered(): MotifEvent<SeriesAnsweredEventArgs<T>>;
+    get onPresentationChanging(): MotifEvent<SchedulerPresentationChangingEventArgs<T>>;
+    get onPresentationChanged(): MotifEvent<SchedulerPresentationChangedEventArgs<T>>;
+    get onTimeZoomChanging(): MotifEvent<TimeZoomChangingEventArgs<T>>;
+    get onTimeZoomChanged(): MotifEvent<TimeZoomChangedEventArgs<T>>;
+    get onICalendarExporting(): MotifEvent<ICalendarExportingEventArgs<T>>;
+    get onICalendarExported(): MotifEvent<ICalendarExportedEventArgs<T>>;
+    get onICalendarImporting(): MotifEvent<ICalendarImportingEventArgs<T>>;
+    get onICalendarImported(): MotifEvent<ICalendarImportedEventArgs<T>>;
+    get onPrinting(): MotifEvent<PrintingEventArgs<T>>;
+    get onPrinted(): MotifEvent<PrintedEventArgs<T>>;
+    /** Shows today. */
+    goToday(): boolean;
+    /** Moves a step on: a day, a week or a month, times the view's interval. */
+    next(): boolean;
+    previous(): boolean;
+    /** Shows the view that has `date`. */
+    showDate(date: Date): boolean;
+    /** Shows another view, by name. */
+    showView(name: string): boolean;
+    /** Scrolls the hours to a time of day: the day columns down to it, a timeline along to it (on the date shown, else the first day). */
+    scrollToTime(hour: number, minute?: number): void;
+    /**
+     * Scrolls a time into view: in the day views to its hour and its day's column, in a timeline to
+     * its cell and the row of `resources` (the group's values). A time not shown changes nothing.
+     */
+    scrollTo(date: Date, resources?: Record<string, unknown> | null): void;
+    /** The appointments with any part between `start` and `end`. */
+    appointmentsIn(start: Date, end: Date): T[];
+    /** The appointment with this key (the `key` field), among the ones loaded. */
+    findAppointment(key: unknown): T | undefined;
+    /**
+     * Reads the appointments and the resources again: what was changed in them in place shows. The
+     * scheduler reads the data as it is, plain or reactive alike, so a change made outside it (not
+     * through its methods, its form or its data source) shows after this.
+     */
+    refresh(): void;
+    /** Reads one appointment again (for an occurrence: its series): what was changed in it in place shows. */
+    refreshAppointment(appointment: T): void;
+    /** Reads the resources again: their items, and what was changed in them in place. */
+    refreshResources(): void;
+    /** What the resource kinds' fields given as functions read now. */
+    private resourceFieldValues;
+    /** Selects cells from `start` to `end` (in the days shown), or none with `null`. */
+    selectCells(cell: SchedulerCell | null): boolean;
+    /** Adds an appointment where they come from (the array, or the data source), asking `onAppointmentAdding` first. */
+    addAppointment(values: Partial<T>): Promise<T | null>;
+    /**
+     * Changes an appointment's fields, asking `onAppointmentUpdating` first. For an occurrence of a
+     * series, `scope` says what the change reaches; default: `seriesEdit`'s, else the occurrence.
+     */
+    updateAppointment(appointment: T, changes: Partial<T>, scope?: SeriesScope | null): Promise<boolean>;
+    /** Deletes an appointment, asking `onAppointmentDeleting` first (not the user); `scope` as for `updateAppointment`. */
+    deleteAppointment(appointment: T, scope?: SeriesScope | null): Promise<boolean>;
+    /** The series of an occurrence (or of one changed apart from it), a series itself, or `null`. */
+    seriesOf(appointment: T): T | null;
+    /** Whether an appointment is an occurrence of a series (the scheduler made it from the series' rule). */
+    isOccurrence(appointment: T): boolean;
+    /** Whether an appointment is an occurrence changed apart from its series (it names the series by `recurrenceId`). */
+    isException(appointment: T): boolean;
+    /** The occurrences of a series that have any part between `start` and `end`. */
+    occurrencesOf(series: T, start: Date, end: Date): T[];
+    /** How a series (or the series of an occurrence) repeats, in plain words; empty for an appointment that happens once. */
+    recurrenceText(appointment: T): string;
+    /** Asks the user what a change (or a delete) of an occurrence reaches; `null` when the question is cancelled. */
+    askSeries(appointment: T, action?: SeriesAction): Promise<SeriesScope | null>;
+    /** Opens the appointment form: for an appointment, or for a new one at `cell` (the selection by default). */
+    showAppointmentForm(appointment?: T | null, cell?: SchedulerCell | null): Promise<void>;
+    /** Shows an appointment's tooltip next to `anchor` (its box by default). */
+    showTooltip(appointment: T, anchor?: HTMLElement): void;
+    hideTooltip(): void;
+    /**
+     * Whether an appointment may be at a time, and what is there: the appointments it would overlap
+     * in its groups, the blocked times, whether it is outside the work hours. With `resources`, the
+     * values its resource fields would have there.
+     */
+    checkTime(appointment: T, start: Date, end: Date, options?: {
+        allDay?: boolean;
+        resources?: Record<string, unknown> | null;
+    }): SchedulerTimeCheck<T> & {
+        free: boolean;
+    };
+    /** An appointment's resource items, by kind, in the order of `resources` (the kinds it has). */
+    resourcesOf(appointment: T): {
+        field: string;
+        label: string;
+        items: {
+            value: unknown;
+            text: string;
+            color: string;
+            item: unknown;
+        }[];
+    }[];
+    /**
+     * Writes the appointments as an iCalendar file (RFC 5545): those of the days shown, all the ones
+     * loaded, or those of a range; a series goes whole with its rule, the times left out and the
+     * occurrences changed apart, each zone used with its definition. Asks `onICalendarExporting`
+     * first; `null` when it said no.
+     */
+    exportICalendar(options?: ICalendarExportOptions<T>): string | null;
+    /**
+     * Reads an iCalendar file in: each event becomes an appointment added through the data layer (the
+     * array, or the data source's adapter) as any other is, with `onAppointmentAdding` first; an event
+     * whose UID is an appointment's key already changes that one. Asks `onICalendarImporting` first;
+     * `null` when it said no.
+     */
+    importICalendar(text: string): Promise<ICalendarImportResult<T> | null>;
+    /**
+     * Prints the scheduler alone: the days shown, every row and column built and nothing scrolled,
+     * the colours kept, the bar left out. Asks `onPrinting` first; `false` when it said no. (The
+     * browser's own print prints it the same way, beside the rest of the page.)
+     */
+    print(): Promise<boolean>;
+    /** The text for `key`: the scheduler's own `texts`, else `uiLocale`'s, filled in. */
+    textOf(key: keyof UiStrings, values?: Record<string, unknown>): string;
+    onConfigured(): void;
+    /** What the scheduler's own element says: its name, the view's type, how it shows, the zoom. */
+    private drawRoot;
+    /** What the model tells: the bar and the root after a layout, and what follows the content, the selection and the focus. */
+    private modelChanged;
+    onConfig(): void;
+    onMounted(): void;
+    /**
+     * The root's parts, made once (no binding in them): the bar and its buttons, the content with the view and its states,
+     * the text read out. What they show is drawn by hand (`drawAll`).
+     */
+    private makeRoot;
+    /** The view each view button stands for, as last drawn. */
+    private readonly viewOfButton;
+    /** All of the root, as the scheduler is now. */
+    private drawAll;
+    /** The bar: its name, its size, its buttons for the view and the presentation shown. */
+    private drawBar;
+    /** The view shown in the content: made again only when its kind changes. */
+    private drawContent;
+    /** Loading, a failure to load: shown over the content. */
+    private drawStates;
+    /** The swipe's edge: shown while a finger swipes between dates, on the side what comes is on. */
+    private drawSwipeEdge;
+    /** The text read out last. */
+    private drawLive;
+    /** Binds a prop; for the ones whose value is a function, a function with a parameter is the value itself, one without is a getter. */
+    private bindOwn;
+    private get parts();
+    /** The language or the locale changed: the weeks are laid out again from their first day, and everything drawn again. */
+    private languageChanged;
+    private drawAgain;
+    private createParts;
+    /** The calendar the date in the bar opens. */
+    private createPicker;
+    private createHost;
+    /** The appointments loaded: the data source's rows, else the array. Reactive: follows the prop, not what is in the list. */
+    private items;
+    private followSource;
+    /** With remote filtering, the data source is asked for the days shown only (and, grouped, for the resources shown). */
+    private filterSource;
+    /** The values shown of each field grouped by that holds one value (a list cannot be asked for); none without groups. */
+    private shownResources;
+    private bindKeys;
+    /** One step (a key, `selectCells`) may move the focus more than once: the selection it ends on is told, once. */
+    private selectionSoon;
+    private watchSelection;
+    /** Focus on a cell follows the model's focused cell (it keeps its date when the days change). */
+    private followFocus;
+    private watchContent;
+    /** When a view with hours shows (not on every date), it scrolls to `scrollHour`: the work start, or now on today. */
+    private scrollOnShow;
+    /** Shows it as `presentation` says, or by its width; asks `onPresentationChanging` first. */
+    private resolvePresentation;
+    /** The view a presentation shows: back to the one it had before, unless the user chose another; then the presentation's own. */
+    private showViewOf;
+    /** The view a presentation asks for, by name or type, among the views; a phone without it shows a day. */
+    private presentationView;
+    /** The views as the phone's bar lists them, the one shown checked. */
+    private viewMenu;
+    /** A screen that gets or loses its touch (a tablet with a keyboard and a mouse) may show it another way. */
+    private watchPointer;
+    private watchSize;
+    /** What the design language says in values the code reads: the size of the phone's bar. */
+    private readLook;
+    /** The browser's print (and `print()`) lays it out whole for paper. */
+    private watchPrint;
+    /** On paper a big view is built whole: the view is worked out again for it, and back after. */
+    private setPrinting;
+    private printDone;
+    private viewList;
+    /** The view on screen as it was given. */
+    private currentViewOf;
+    private resolveView;
+    /** A template of the view shown: its own (`null` there turns it off), else the scheduler's. */
+    private templateOf;
+    private viewText;
+    /** The days a view shows around `date`, as moments on the scheduler's clock. */
+    private rangeOf;
+    /** The title as on a phone: the month of the first day shown, with its year when that is not this year (as phone calendars write it). */
+    private phoneTitle;
+    private rangeText;
+    /** Today on the scheduler's clock, as a date of the browser's (what `currentDate` holds). */
+    private today;
+    private isRtl;
+    private step;
+    private changeDate;
+    private changeView;
+    private say;
+    private cellPointerDown;
+    private fireCell;
+    private fireAppointment;
+    /** A click on cells (not the end of a swipe): the event; a finger's second tap on the cell opens the form. */
+    private clickCell;
+    /** A click on an appointment (not the end of a drag or a swipe): the event, then its tooltip. */
+    private clickAppointment;
+    /** A double click (or Enter) on an appointment: the event, then its form. */
+    private openAppointment;
+    /** A double click (or Enter) on cells: the event, then the form for a new appointment there (the selection when the cell is in it). */
+    private openCell;
+    /** The keys of a focused appointment: moving and resizing by the keys, Delete, Enter and Space. */
+    private appointmentKey;
+    /** The box an appointment shows in (its first one). */
+    private boxOf;
+    private openMore;
+    private morePopup;
+    /**
+     * What the "+N more" popup shows: the template's content, made again each time it opens (it reads the day and the
+     * appointments as they are then), else the list, drawn again.
+     */
+    private drawMorePopup;
+    /** Arrows, Home, End, PageUp and PageDown move over the cells (Shift selects); Enter and Space are a double click and a click. */
+    private gridKey;
+    /** The agenda's keys: Up and Down (Home, End, PageUp, PageDown) move over its rows; Enter, Space and Delete are a double click, a click and Delete. */
+    private agendaKey;
+    /**
+     * A timeline's keys: Left and Right move along the time (mirrored right to left; past the first or
+     * the last cell the view moves on), Up and Down to the row above or below, Home and End to the
+     * row's first and last cell (with Ctrl, of the first and the last row), PageUp and PageDown by a
+     * screen of rows; Shift selects. Enter and Space are a double click and a click.
+     */
+    private lineKey;
+    /** The time rows on one screen. */
+    private pageRows;
+    /** Whether focus is in the view (not in the bar). */
+    private focusInView;
+    /** Moves DOM focus to the focused cell (after the view drew it; in a big view it is scrolled into view and built first). */
+    private focusCellElement;
+    /** In a big day view: scrolls a column into view (it is then built). */
+    private revealColumn;
+    /** A timeline's cell along the time at a time of a day (by the day's index), as a share of cells. */
+    private tickAt;
+    /** The cell a time is in, among the days shown: in the group of `resources` (the first one by default). */
+    private placeOf;
+}

package/dist/components/scheduler/agenda-row-context.d.ts

@@ -0,0 +1,15 @@
+/** What an agenda row template gets: the appointment on the row's day. */
+export interface AgendaRowContext<T> {
+    readonly appointment: T;
+    /** Its time on this day. */
+    readonly start: Date;
+    readonly end: Date;
+    /** The text and the time the scheduler would write ("All day" for one that takes the day). */
+    readonly text: string;
+    readonly time: string;
+    /** It takes the whole day. */
+    readonly allDay: boolean;
+    readonly date: Date;
+    /** The resource values of the group it is listed under; `null` without groups. */
+    readonly group: Record<string, unknown> | null;
+}

package/dist/components/scheduler/appointment-added-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { Scheduler } from './Scheduler';
+export interface AppointmentAddedEventArgs<T = unknown> {
+    /** The appointment as it was saved (the data source's row, or the object put in the array). */
+    appointment: T;
+    byUser: boolean;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/appointment-adding-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** A new appointment is about to be added. `cancel = true` drops it; `promise` may be set to wait (a server): it is added when it resolves to `true`. */
+export interface AppointmentAddingEventArgs<T = unknown> extends EventArgs {
+    /** Its values, by the field names; they may still be changed. */
+    appointment: Partial<T>;
+    byUser: boolean;
+    promise?: Promise<boolean>;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/appointment-click-event-args.d.ts

@@ -0,0 +1,13 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** An appointment was clicked (or double-clicked); `cancel = true` stops what the scheduler does with it. */
+export interface AppointmentClickEventArgs<T = unknown> extends EventArgs {
+    appointment: T;
+    /** Where it was clicked: the day of the piece of it shown there. */
+    start: Date;
+    end: Date;
+    /** The resource values of the group it was clicked in; `null` without groups. */
+    group: Record<string, unknown> | null;
+    event: MouseEvent | KeyboardEvent;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/appointment-deleted-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { SeriesScope } from './model/series-scope';
+import type { Scheduler } from './Scheduler';
+export interface AppointmentDeletedEventArgs<T = unknown> {
+    appointment: T;
+    byUser: boolean;
+    scope: SeriesScope | null;
+    series: T | null;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/appointment-deleting-event-args.d.ts

@@ -0,0 +1,13 @@
+import type { EventArgs } from '@motifx/core';
+import type { SeriesScope } from './model/series-scope';
+import type { Scheduler } from './Scheduler';
+/** An appointment is about to be deleted (after the question, when it asks). `cancel = true` keeps it; `promise` may be set to wait. */
+export interface AppointmentDeletingEventArgs<T = unknown> extends EventArgs {
+    appointment: T;
+    byUser: boolean;
+    /** For an occurrence of a series: what the delete reaches, and the series. `null` for any other appointment. */
+    scope: SeriesScope | null;
+    series: T | null;
+    promise?: Promise<boolean>;
+    source: Scheduler<T>;
+}