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

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

@@ -0,0 +1,26 @@
+import type { Bind } from '@motifx/core';
+import type { FieldLabelMode } from '../../parts/field/field-label-mode';
+import type { FormBind } from './form-bind';
+import type { SchedulerFormItem } from './scheduler-form-item';
+/**
+ * The appointment form, set up without events. `items` says what it holds, in order: a built-in
+ * item by its field (`text`, `start`, `end`, `allDay`, `startTimeZone`, `separateEndZone`,
+ * `endTimeZone`, or `timeZone` for those three, `recurrenceRule`, `description`), a resource by
+ * its field (`roomId`), or an item of your own. An item whose `field` is a built-in's or a
+ * resource's changes that one (its label, place, rules added, shown or locked); groups, tabs,
+ * buttons and templates are the form's own.
+ */
+export interface SchedulerForm<T = unknown> {
+    /** Default: the built-in items, the resources after the all-day switch. */
+    items?: readonly (string | SchedulerFormItem<T>)[];
+    /** Default `2`. */
+    columns?: number;
+    /** With it, as many columns as fit, each at least this wide (a CSS length); `columns` is the most. */
+    minColumnWidth?: string;
+    /** Where the labels go. Default: the design language's. */
+    labelMode?: Bind<FieldLabelMode>;
+    /** The form's title. Default "New appointment" / "Edit appointment". */
+    title?: FormBind<string, T>;
+    /** The form's width (a CSS length). Default: the design language's. */
+    width?: string;
+}

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

@@ -0,0 +1,22 @@
+/** The scheduler's keys while focus is inside it (outside text fields). Each is a list of chords; an empty list turns it off. */
+export interface SchedulerKeys {
+    /** Default `T`. */
+    today: string[];
+    /** Default `N`, `J`. */
+    next: string[];
+    /** Default `P`, `K`. */
+    previous: string[];
+    /** Default `D`, `W`, `X`, `M`, `A`: the views by type (the first view of the type). */
+    dayView: string[];
+    weekView: string[];
+    workWeekView: string[];
+    monthView: string[];
+    agendaView: string[];
+    /**
+     * On a focused appointment while the columns are grouped: moves it to the group before or after
+     * (Enter saves, Escape takes it back). Default `Alt+Shift+ArrowLeft` and `Alt+Shift+ArrowRight`,
+     * mirrored right to left.
+     */
+    previousGroup: string[];
+    nextGroup: string[];
+}

package/dist/components/scheduler/scheduler-presentation-kind.d.ts

@@ -0,0 +1,2 @@
+/** How a scheduler shows itself now. */
+export type SchedulerPresentationKind = 'desktop' | 'tablet' | 'phone';

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

@@ -0,0 +1,2 @@
+/** How a scheduler shows itself: `'auto'` by its own width (`tabletWidth`, `phoneWidth`), or always as on a desktop, a tablet or a phone. */
+export type SchedulerPresentation = 'auto' | 'desktop' | 'tablet' | 'phone';

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

@@ -0,0 +1,210 @@
+import type { Bind } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import type { ControlProps } from '../../core/control';
+import type { AppointmentAddedEventArgs } from './appointment-added-event-args';
+import type { AppointmentAddingEventArgs } from './appointment-adding-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 { UiStrings } from '../../core/ui-strings';
+import type { AppointmentClickEventArgs } from './appointment-click-event-args';
+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 { MoreOpeningEventArgs } from './more-opening-event-args';
+import type { SchedulerFields } from './scheduler-fields';
+import type { SchedulerKeys } from './scheduler-keys';
+import type { SchedulerView } from './scheduler-view';
+import type { SchedulerViewType } from './scheduler-view-type';
+import type { SchedulerBlockedTime } from './scheduler-blocked-time';
+import type { SchedulerResource } from './scheduler-resource';
+import type { SchedulerTemplates } from './scheduler-templates';
+import type { ScrollingMode } from './model/scrolling-mode';
+import type { SchedulerTimeCheck } from './scheduler-time-check';
+import type { SelectionChangedEventArgs } from './selection-changed-event-args';
+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 { 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 { 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 { PrintingEventArgs } from './printing-event-args';
+import type { PrintedEventArgs } from './printed-event-args';
+/** Props of `Scheduler`: the shared `ControlProps` plus its own. Each one is also a settable property: setting it updates the scheduler. */
+export interface SchedulerProps<T> extends ControlProps, SchedulerTemplates<T> {
+    /** Names the scheduler for screen readers. The same property as `text`. */
+    label?: Bind<string>;
+    /** The appointments, in memory: plain or reactive, read as they are. After changing them in place, call `refresh()`. */
+    appointments?: Bind<readonly T[]>;
+    /**
+     * The appointments from a data source of `@motifx-community/data`, in place of `appointments`. Make it
+     * with `loadMode: 'all'`: a view needs every appointment of its days (`remoteFiltering` asks for those only).
+     */
+    dataSource?: Bind<data.DataSource<T, unknown> | null>;
+    /** Asks the data source only for the days shown (a filter on the start and end fields). Default `true`. */
+    remoteFiltering?: Bind<boolean>;
+    /** Which fields of an appointment hold what; see `SchedulerFields` for the defaults. */
+    fields?: Bind<Partial<SchedulerFields>>;
+    /** The views it offers, by type or with settings and templates of their own. Default: day, week, work week and month. */
+    views?: Bind<readonly (SchedulerViewType | SchedulerView<T>)[]>;
+    /** The view on screen, by name. Default: the second view (the week). The user changes it too. */
+    currentView?: Bind<string>;
+    /** The date the view shows. Default today. The user changes it too. */
+    currentDate?: Bind<Date>;
+    /** 0 Sunday … 6 Saturday; by default the locale's. */
+    firstDayOfWeek?: Bind<number | null>;
+    /** Default Monday to Friday. */
+    workDays?: Bind<readonly number[]>;
+    /** The work hours, shaded apart from the rest. Default 9 to 17. */
+    workStartHour?: Bind<number>;
+    workEndHour?: Bind<number>;
+    /** The hours the day columns show. Default 0 to 24. */
+    startDayHour?: Bind<number>;
+    endDayHour?: Bind<number>;
+    /** Minutes in a cell. Default 30. */
+    cellDuration?: Bind<number>;
+    /** The all-day panel above the day columns. Default `true`. */
+    allDayPanel?: Bind<boolean>;
+    /** Lines the all-day panel grows to before "+N more". Default 3. */
+    allDayLines?: Bind<number>;
+    /** Appointments in a month cell (a timeline row) before "+N more"; `'auto'`: as many as fit (a timeline row grows). Default `'auto'`. */
+    maxAppointmentsPerCell?: Bind<number | 'auto'>;
+    /** The days the agenda shows, from the date shown. Default 7. */
+    agendaDuration?: Bind<number>;
+    /**
+     * Whether a view builds every cell and row (`'standard'`) or only what is in view and a little on
+     * each side (`'virtual'`). Default `'auto'`: virtual once its cells are more than a few thousand
+     * (many resources in a timeline, many groups in a day or a week).
+     */
+    scrolling?: Bind<ScrollingMode>;
+    /** Default `'columns'`. */
+    overlapMode?: Bind<OverlapMode>;
+    /** Days marked as holidays. */
+    isHoliday?: Bind<((date: Date) => boolean) | null>;
+    /** The line at the current time, moving on. Default `true`. */
+    showCurrentTime?: Bind<boolean>;
+    /** Appointments that have ended look quieter. Default `false`. */
+    dimPast?: Bind<boolean>;
+    /** The hour the day columns scroll to when they show. Default: the work start, or now when it is later on today. */
+    scrollHour?: Bind<number | null>;
+    /** The bar with today, previous, next, the date and the views. Default `true`. */
+    toolbar?: Bind<boolean>;
+    /** Default: the page's language. */
+    locale?: Bind<string>;
+    /**
+     * The clock the days and hours are on: an IANA time zone (`'Europe/Istanbul'`). Default `null`, the
+     * browser's. An appointment's own zone (`fields.startTimeZone`) is the one its series repeats in.
+     */
+    timeZone?: Bind<string | null>;
+    /** What changing or deleting an occurrence of a series reaches: `'ask'` (default) asks the user; from code it is the occurrence. */
+    seriesEdit?: Bind<SeriesEditMode>;
+    /** Occurrences of a series, and ones changed apart from it, carry a mark where the design language draws one. Default `true`. */
+    recurrenceMarks?: Bind<boolean>;
+    /**
+     * The kinds of resources the appointments use (rooms, people): they colour the appointments,
+     * group the columns (`groups`) and each gets a picker in the form.
+     */
+    resources?: Bind<readonly SchedulerResource<any>[]>;
+    /** The resource fields the columns are grouped by, outer first (`['roomId', 'ownerIds']`). A view's own win. */
+    groups?: Bind<readonly string[]>;
+    /** The groups stand under each date, not the dates under each group. Default `false`. */
+    groupByDate?: Bind<boolean>;
+    /** Times nothing may be put in, shaded on the days shown (for every resource, or the ones named). */
+    blockedTimes?: Bind<readonly SchedulerBlockedTime[]>;
+    /**
+     * Whether an appointment the user moves, resizes or saves may overlap another one of its group
+     * (of the scheduler, without groups). Default `true`. A function decides the whole check (blocked
+     * times and work hours too): `true` when the time is free for it.
+     */
+    allowOverlap?: Bind<boolean | ((check: SchedulerTimeCheck<T>) => boolean)>;
+    /** Whether the user may put an appointment outside the work hours (of its resources, else the scheduler's). Default `true`. */
+    allowOffHours?: Bind<boolean>;
+    /** Changes the texts it writes; the rest come from `uiLocale`. */
+    texts?: Bind<Partial<UiStrings>>;
+    keys?: Bind<Partial<SchedulerKeys>>;
+    /** Says the date and the view to screen readers when they change. Default `true`. */
+    announce?: Bind<boolean>;
+    /** What the user may change: `false` nothing, `true` (default) everything, or each switch of `SchedulerEditing`. An appointment's own `allowDrag`, `allowResize`, `allowEdit`, `allowDelete` win. */
+    editing?: Bind<boolean | Partial<SchedulerEditing<T>>>;
+    /** The minutes a drag and the keys move by. Default: the view's cell. */
+    snapMinutes?: Bind<number>;
+    /** The shortest an appointment gets by resizing, in minutes. Default: `snapMinutes`. */
+    minDuration?: Bind<number>;
+    /** A click on an appointment shows its tooltip (text, time, Edit, Delete). Default `true`. */
+    tooltip?: Bind<boolean>;
+    /**
+     * How it shows itself: `'auto'` by its own width (under `phoneWidth` as on a phone, under
+     * `tabletWidth` as on a tablet, else as on a desktop), or always one way. The appointments, the
+     * views and the date stay the same.
+     */
+    presentation?: Bind<SchedulerPresentation>;
+    /** Under this width, in pixels of the scheduler, `'auto'` shows it as on a tablet (on a touch screen, see `tabletWhen`). Default 1024. */
+    tabletWidth?: Bind<number>;
+    /** Under this width, in pixels of the scheduler, `'auto'` shows it as on a phone, whatever the pointer. Default 560. */
+    phoneWidth?: Bind<number>;
+    /** When `'auto'` shows it as on a tablet: `'touch'`, under `tabletWidth` on a screen whose pointer is a finger; `'width'`, under `tabletWidth` whatever the pointer. Default `'touch'`. */
+    tabletWhen?: Bind<SchedulerTabletWhen>;
+    /** The view (by name or type) it shows when it turns into a phone, if it has one: the agenda, else a day. `null` keeps the view. Default `'agenda'`. */
+    phoneView?: Bind<string | null>;
+    /** The view (by name or type) it shows when it turns into a tablet, if it has one. `null` (default) keeps the view. */
+    tabletView?: Bind<string | null>;
+    /** A finger swiping sideways over the view goes to the next or the previous days. Default `true`. */
+    swipeNavigation?: Bind<boolean>;
+    /** Two fingers zoom the time scale: the hours of the day views, the cells of a timeline. Default `true`. */
+    pinchZoom?: Bind<boolean>;
+    /** How far the time scale is zoomed: 1 as the design language sizes it, from 0.5 to 4. Two fingers change it. Default 1. */
+    timeZoom?: Bind<number>;
+    onViewChanging?: (e: ViewChangingEventArgs<T>) => void;
+    onViewChanged?: (e: ViewChangedEventArgs<T>) => void;
+    onDateChanging?: (e: DateChangingEventArgs<T>) => void;
+    onDateChanged?: (e: DateChangedEventArgs<T>) => void;
+    onCellClick?: (e: CellClickEventArgs<T>) => void;
+    onCellDblClick?: (e: CellClickEventArgs<T>) => void;
+    onAppointmentClick?: (e: AppointmentClickEventArgs<T>) => void;
+    onAppointmentDblClick?: (e: AppointmentClickEventArgs<T>) => void;
+    onSelectionChanged?: (e: SelectionChangedEventArgs<T>) => void;
+    onContentReady?: (e: ContentReadyEventArgs<T>) => void;
+    onMoreOpening?: (e: MoreOpeningEventArgs<T>) => void;
+    onAppointmentAdding?: (e: AppointmentAddingEventArgs<T>) => void;
+    onAppointmentAdded?: (e: AppointmentAddedEventArgs<T>) => void;
+    onAppointmentUpdating?: (e: AppointmentUpdatingEventArgs<T>) => void;
+    onAppointmentUpdated?: (e: AppointmentUpdatedEventArgs<T>) => void;
+    onAppointmentDeleting?: (e: AppointmentDeletingEventArgs<T>) => void;
+    onAppointmentDeleted?: (e: AppointmentDeletedEventArgs<T>) => void;
+    onFormOpening?: (e: FormOpeningEventArgs<T>) => void;
+    onDataError?: (e: DataErrorEventArgs<T>) => void;
+    onMoveStart?: (e: DragEventArgs<T>) => void;
+    onMoving?: (e: DragEventArgs<T>) => void;
+    onMoveEnd?: (e: DragEventArgs<T>) => void;
+    onResizeStart?: (e: DragEventArgs<T>) => void;
+    onResizing?: (e: DragEventArgs<T>) => void;
+    onResizeEnd?: (e: DragEventArgs<T>) => void;
+    onSeriesAsking?: (e: SeriesAskingEventArgs<T>) => void;
+    onSeriesAnswered?: (e: SeriesAnsweredEventArgs<T>) => void;
+    onPresentationChanging?: (e: SchedulerPresentationChangingEventArgs<T>) => void;
+    onPresentationChanged?: (e: SchedulerPresentationChangedEventArgs<T>) => void;
+    onTimeZoomChanging?: (e: TimeZoomChangingEventArgs<T>) => void;
+    onTimeZoomChanged?: (e: TimeZoomChangedEventArgs<T>) => void;
+    onICalendarExporting?: (e: ICalendarExportingEventArgs<T>) => void;
+    onICalendarExported?: (e: ICalendarExportedEventArgs<T>) => void;
+    onICalendarImporting?: (e: ICalendarImportingEventArgs<T>) => void;
+    onICalendarImported?: (e: ICalendarImportedEventArgs<T>) => void;
+    onPrinting?: (e: PrintingEventArgs<T>) => void;
+    onPrinted?: (e: PrintedEventArgs<T>) => void;
+}

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

@@ -0,0 +1,5 @@
+/** The days a view shows: from `start` to `end` (not included). */
+export interface SchedulerRange {
+    start: Date;
+    end: Date;
+}

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

@@ -0,0 +1,33 @@
+import type { Bind } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+/**
+ * A kind of resource the appointments use (rooms, people…): the appointment field that holds it
+ * and the items it can be. Its items colour the appointments, make the groups of the columns
+ * (`groups`) and the picker of the form; an item's own work hours and days win over the
+ * scheduler's, and so do its own `allowDrag`, `allowResize`, `allowEdit` and `allowDelete` (the
+ * names of `fields`) for its appointments: `false` on any of an appointment's items keeps it so.
+ */
+export interface SchedulerResource<R = Record<string, unknown>> {
+    /** The appointment field that holds the item's value (`roomId`), or a list of them with `allowMultiple` (`ownerIds`). */
+    field: string;
+    /** What it is called: the form's label, and how the cells and the tooltip name it. Default: the field. */
+    label?: Bind<string>;
+    /** The items, in memory or from a data source (loaded once, then followed); plain or reactive, read as they are: after changing them in place, call the scheduler's `refreshResources()`. */
+    items?: Bind<readonly R[] | data.DataSource<R, unknown> | null>;
+    /** The item field of its value. Default `'id'`. */
+    valueExpr?: string;
+    /** The item field of its name. Default `'text'`. */
+    displayExpr?: string;
+    /** The item field of its colour (a CSS colour). Default `'color'`. */
+    colorExpr?: string;
+    /** An appointment may have several of them: the field holds a list. Default `false`. */
+    allowMultiple?: Bind<boolean>;
+    /** Appointments take the colour of this kind (else of the first kind whose item has one). Default `false`. */
+    useColorAsDefault?: Bind<boolean>;
+    /** The item field naming its item of the kind above it in `groups` (a person's room): nested, a group shows only its own. */
+    parentExpr?: string;
+    /** The item fields of its own work hours and work days (0 Sunday … 6 Saturday). Default the scheduler's option names. */
+    workStartHourExpr?: string;
+    workEndHourExpr?: string;
+    workDaysExpr?: string;
+}

package/dist/components/scheduler/scheduler-tablet-when.d.ts

@@ -0,0 +1,2 @@
+/** When `presentation: 'auto'` shows a scheduler as on a tablet: under `tabletWidth` on a touch screen (`'touch'`), or under it whatever the pointer (`'width'`). */
+export type SchedulerTabletWhen = 'touch' | 'width';

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

@@ -0,0 +1,34 @@
+import type { Bind, ComponentBase } from '@motifx/core';
+import type { AgendaRowContext } from './agenda-row-context';
+import type { AppointmentTemplateContext } from './appointment-template-context';
+import type { CellTemplateContext } from './cell-template-context';
+import type { DateTemplateContext } from './date-template-context';
+import type { MoreListContext } from './more-list-context';
+import type { ResourceHeaderContext } from './resource-header-context';
+import type { TimeTemplateContext } from './time-template-context';
+import type { TooltipTemplateContext } from './tooltip-template-context';
+/** A template: a function that makes a MotifJS component from what it gets. */
+type Template<C> = Bind<((context: C) => ComponentBase) | null>;
+/**
+ * The templates a scheduler draws with, component-wide or for one view (a view's own wins). Each
+ * is made once for the element it draws and gets a context whose fields follow the element.
+ */
+export interface SchedulerTemplates<T> {
+    /** An appointment's content, in place of its text and time. */
+    appointmentTemplate?: Template<AppointmentTemplateContext<T>>;
+    /** The tooltip's content, in place of its title, times, resources and buttons. */
+    appointmentTooltipTemplate?: Template<TooltipTemplateContext<T>>;
+    /** A cell's content (a time cell, a whole day's cell); the cell keeps its own look, keys and name. */
+    dataCellTemplate?: Template<CellTemplateContext>;
+    /** A day's head: the dates of the day views, the weekdays of the month, a timeline's days. */
+    dateCellTemplate?: Template<DateTemplateContext>;
+    /** An hour of the time ruler, and of a timeline's scale. */
+    timeCellTemplate?: Template<TimeTemplateContext>;
+    /** A group's head (a resource item). */
+    resourceHeaderTemplate?: Template<ResourceHeaderContext>;
+    /** An agenda row's content, in place of its time, colour and text. */
+    agendaRowTemplate?: Template<AgendaRowContext<T>>;
+    /** The list "+N more" opens. */
+    moreListTemplate?: Template<MoreListContext<T>>;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import type { SchedulerBlockedTime } from './scheduler-blocked-time';
+/**
+ * What `allowOverlap`, given as a function, decides on: an appointment would be at this time with
+ * these resources. Return `true` when it may.
+ */
+export interface SchedulerTimeCheck<T = unknown> {
+    appointment: T;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    /** The values of its resource fields there (`{ roomId: 2, ownerIds: [1, 3] }`). */
+    resources: Record<string, unknown>;
+    /** The appointments it would overlap in its groups (every one, without groups). */
+    overlapping: T[];
+    /** The blocked times it would touch. */
+    blocked: SchedulerBlockedTime[];
+    /** Part of it is outside the work hours (of its resources, else the scheduler's). */
+    offHours: boolean;
+}

package/dist/components/scheduler/scheduler-view-type.d.ts

@@ -0,0 +1,6 @@
+/**
+ * How a view lays out its days: a column per day with the hours down (`day`, `week`, `workWeek`), a
+ * month of weeks, a row per resource with the time running along it (`timeline…`), or a list of the
+ * coming days (`agenda`).
+ */
+export type SchedulerViewType = 'day' | 'week' | 'workWeek' | 'month' | 'timelineDay' | 'timelineWeek' | 'timelineWorkWeek' | 'timelineMonth' | 'agenda';

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

@@ -0,0 +1,33 @@
+import type { Bind } from '@motifx/core';
+import type { ScrollingMode } from './model/scrolling-mode';
+import type { SchedulerTemplates } from './scheduler-templates';
+import type { SchedulerViewType } from './scheduler-view-type';
+/**
+ * One view the scheduler offers. Its own settings and templates win over the scheduler's; every one
+ * is a value or a function that is followed.
+ */
+export interface SchedulerView<T = any> extends SchedulerTemplates<T> {
+    type: SchedulerViewType;
+    /** What `currentView` and the view switcher call it; the type by default. Two views of one type need names. */
+    name?: string;
+    /** The caption in the view switcher; the type's text by default. */
+    text?: Bind<string>;
+    /** How many days (`day`, `timelineDay`), weeks (`week`, `workWeek`, `timelineWeek`, `timelineWorkWeek`) or months (`month`, `timelineMonth`) it shows. Default 1. */
+    intervalCount?: Bind<number>;
+    /** With `intervalCount` over 1 (and for the agenda): the date the intervals are counted from, so they stay where they are when the date moves. */
+    startDate?: Bind<Date | null>;
+    startDayHour?: Bind<number>;
+    endDayHour?: Bind<number>;
+    /** Minutes in a cell. */
+    cellDuration?: Bind<number>;
+    allDayPanel?: Bind<boolean>;
+    /** Appointments shown in a month cell (or the all-day panel, or a timeline row) before "+N more"; `'auto'`: as many as fit (a timeline row grows). */
+    maxAppointmentsPerCell?: Bind<number | 'auto'>;
+    /** The resource fields its columns (a timeline's rows) are grouped by; `[]` for none. */
+    groups?: Bind<readonly string[]>;
+    groupByDate?: Bind<boolean>;
+    /** The days the agenda shows. Default 7. */
+    agendaDuration?: Bind<number>;
+    /** Whether it builds every cell and row or only what is in view; `'auto'` (default): only what is in view once the cells are many. */
+    scrolling?: Bind<ScrollingMode>;
+}

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

@@ -0,0 +1,7 @@
+import type { Scheduler } from './Scheduler';
+import type { SchedulerCell } from './scheduler-cell';
+export interface SelectionChangedEventArgs<T = unknown> {
+    /** The cells selected now, as one time; `null` when none is. */
+    selection: SchedulerCell | null;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/series-action.d.ts

@@ -0,0 +1,2 @@
+/** What is done to an occurrence of a series: it is changed, or deleted. */
+export type SeriesAction = 'update' | 'delete';

package/dist/components/scheduler/series-answered-event-args.d.ts

@@ -0,0 +1,12 @@
+import type { SeriesScope } from './model/series-scope';
+import type { Scheduler } from './Scheduler';
+import type { SeriesAction } from './series-action';
+/** What a change (or a delete) of an occurrence reaches was answered; `scope` is `null` when the question was cancelled. */
+export interface SeriesAnsweredEventArgs<T = unknown> {
+    appointment: T;
+    series: T;
+    action: SeriesAction;
+    scope: SeriesScope | null;
+    byUser: boolean;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/series-asking-event-args.d.ts

@@ -0,0 +1,18 @@
+import type { EventArgs } from '@motifx/core';
+import type { SeriesScope } from './model/series-scope';
+import type { Scheduler } from './Scheduler';
+import type { SeriesAction } from './series-action';
+/**
+ * The user is about to be asked what a change (or a delete) of an occurrence reaches. Set `scope`
+ * to answer without the question, narrow `scopes` to offer fewer, or `cancel = true` to drop the change.
+ */
+export interface SeriesAskingEventArgs<T = unknown> extends EventArgs {
+    /** The occurrence. */
+    appointment: T;
+    series: T;
+    action: SeriesAction;
+    /** The answers offered, in order. */
+    scopes: SeriesScope[];
+    scope: SeriesScope | null;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/series-edit-mode.d.ts

@@ -0,0 +1,3 @@
+import type { SeriesScope } from './model/series-scope';
+/** What a change to an occurrence of a series reaches: the user is asked (`'ask'`), or always the same. */
+export type SeriesEditMode = 'ask' | SeriesScope;

package/dist/components/scheduler/time-template-context.d.ts

@@ -0,0 +1,11 @@
+import type { SchedulerViewType } from './scheduler-view-type';
+/** What a time template gets: an hour of the time ruler (or of a timeline's scale), and the text the scheduler would write. */
+export interface TimeTemplateContext {
+    /** The hour on the day it stands for (the first day shown, in a day view). */
+    readonly date: Date;
+    /** Minutes after the day's start. */
+    readonly minutes: number;
+    /** "09:00" or "9 AM", by the locale. */
+    readonly text: string;
+    readonly view: SchedulerViewType;
+}

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

@@ -0,0 +1,7 @@
+import type { Scheduler } from './Scheduler';
+/** Two fingers zoomed the time scale (sent when they let go). */
+export interface TimeZoomChangedEventArgs<T = unknown> {
+    from: number;
+    to: number;
+    source: Scheduler<T>;
+}

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

@@ -0,0 +1,8 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** Two fingers are about to zoom the time scale; `cancel = true` keeps it as it is. */
+export interface TimeZoomChangingEventArgs<T = unknown> extends EventArgs {
+    from: number;
+    to: number;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/tooltip-template-context.d.ts

@@ -0,0 +1,14 @@
+/** What a tooltip template gets: the appointment shown, and the tooltip's actions. */
+export interface TooltipTemplateContext<T> {
+    readonly appointment: T | null;
+    /** Its text and time as the scheduler writes them. */
+    readonly text: string;
+    readonly time: string;
+    readonly canEdit: boolean;
+    readonly canDelete: boolean;
+    /** Opens its form. */
+    edit(): void;
+    /** Deletes it (asking first, as `editing.confirmDelete` says). */
+    remove(): void;
+    close(): void;
+}

package/dist/components/scheduler/view/AgendaView.d.ts

@@ -0,0 +1,50 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+    /** The row with the keyboard's focus (the selected one), by its piece's id. */
+    focus: {
+        id: string;
+        drawn: () => void;
+    };
+}
+/**
+ * The agenda: the coming days (in each group, with groups) with their appointments in time order, a day with none
+ * left out. It is a list: the arrows move over its rows (the focused one is the selected one), Space shows the tooltip,
+ * Enter opens the form, as a click and a double click do.
+ *
+ * It follows nothing: whatever the model tells, and when the focus moves, it draws itself again (each part only what
+ * it shows), as it does on `reState()` and when an option or a text it shows changes.
+ */
+export declare class AgendaView<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private list;
+    private empty;
+    private days;
+    private readonly dayDrawn;
+    private readonly rowDrawn;
+    constructor(props: Props<T>);
+    private get host();
+    onConfigured(): void;
+    onMounted(): void;
+    onDisposing(): void;
+    /** All of the list, as the model has it now. */
+    draw(): void;
+    /** The row the keys are on (selected once one is chosen); before that the first takes the focus. */
+    private focused;
+    private choose;
+    private makeDay;
+    private drawDay;
+    private makeRow;
+    /** A row's content: the template's, else the time, the dot, the text and the mark; what is read after them. */
+    private fillRow;
+    private drawRow;
+    private time;
+    private text;
+    /** Read after what the row writes: whether it goes on, how it repeats. */
+    private details;
+    /** What an agenda template is given: each read reads the row as it is now. */
+    private rowContext;
+}
+export {};

package/dist/components/scheduler/view/AppointmentBox.d.ts

@@ -0,0 +1,58 @@
+import { Component } from '@motifx/core';
+import type { LinePiece } from '../model/line-piece';
+import type { StripPiece } from '../model/strip-piece';
+import type { TimedPiece } from '../model/timed-piece';
+import type { SchedulerHost } from './scheduler-host';
+type Piece<T> = TimedPiece<T> | StripPiece<T> | LinePiece<T>;
+interface Props<T> {
+    host: SchedulerHost<T>;
+    piece: Piece<T>;
+}
+/**
+ * One appointment, or the part of it on one day, one week or one row of a timeline: placed by its piece's fields,
+ * coloured by the appointment's own colour (else its resources'), its content the template's or its text and time.
+ * An occurrence of a series carries the series mark, one changed apart the exception mark, and a box that may not
+ * go where it is being moved the drop mark, where the design language draws them.
+ *
+ * It follows nothing: it draws itself when it is made, when its view hands it a piece again (`show`), on
+ * `reState()` and when an option or a text it shows changes.
+ */
+export declare class AppointmentBox<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private piece;
+    private content;
+    /** The template the content was filled with: another one (another view, another prop) fills it again. */
+    private template;
+    /** The piece's version a template drew: when its appointment is read again (a refresh, an edit) the template draws again. */
+    private filledVersion;
+    /** The style properties the box's place was last written with. */
+    private placed;
+    /** The appointment the box drew last. */
+    private drawnItem;
+    /** Being taken away (from `onDisposing`, before it leaves the page). */
+    private leaving;
+    private readonly parts;
+    constructor(props: Props<T>);
+    private get host();
+    /** The piece again, after the layout: the same appointment's box is drawn where it is now. */
+    show(piece: Piece<T>): void;
+    onDisposing(): void;
+    onConfigured(): void;
+    /** The content: the template's, else the time and the text, and what is read after them. */
+    private fill;
+    /** Everything the box shows of its piece, drawn by hand. */
+    draw(): void;
+    /** Its appointment: read again when the piece's version moves on (a refresh, an edit). */
+    private item;
+    private allDay;
+    private time;
+    /** Read after the text: the day (and the whole time of a part), which the box itself does not write. */
+    private details;
+    private place;
+    private resizable;
+    private press;
+    /** What a template is given: each read reads the piece as it is now. */
+    private templateContext;
+}
+export {};