@elaraai/e3-ui 1.0.86 → 1.0.87

package/dist/src/schedule/types.d.ts

@@ -0,0 +1,1677 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Schedule`'s East types (#1218): what an author meets (`Calendar Spec.md`
+ * §5.1), and the kinds' wire (§5.2) that a builder's payload holds — the
+ * Calendar's, and Plan's builder's (#1190, `Plan Builder Spec.md` §5.2): the
+ * same kinds with Plan's options resolved beside them.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
+/**
+ * A resource: its kind's slot name, and its key's text (a String key as it
+ * is, any other key as East prints it).
+ *
+ * @property kind - The resource kind's slot name (`people`)
+ * @property key - The resource's key, as text
+ */
+export declare const ScheduleResourceRefType: StructType<{
+    readonly kind: StringType;
+    readonly key: StringType;
+}>;
+/** Type representing {@link ScheduleResourceRefType}. */
+export type ScheduleResourceRefType = typeof ScheduleResourceRefType;
+/**
+ * An event: its kind's slot name, and its record key's text.
+ *
+ * @property kind - The event kind's slot name (`shift`)
+ * @property key - The event's record key, as text
+ */
+export declare const ScheduleEventRefType: StructType<{
+    readonly kind: StringType;
+    readonly key: StringType;
+}>;
+/** Type representing {@link ScheduleEventRefType}. */
+export type ScheduleEventRefType = typeof ScheduleEventRefType;
+/**
+ * How one case of an event's status shows.
+ *
+ * @property label - Its words
+ * @property tone - Its tone: success, warning, danger, info or neutral
+ * @property ring - Whether it draws as an open ring, as a tentative status does
+ */
+export declare const ScheduleStatusType: StructType<{
+    readonly label: StringType;
+    readonly tone: VariantType<{
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>;
+    readonly ring: BooleanType;
+}>;
+/** Type representing {@link ScheduleStatusType}. */
+export type ScheduleStatusType = typeof ScheduleStatusType;
+/**
+ * One {@link ScheduleStatusType} per case of a status variant: the `cases` a
+ * kind's `status` takes.
+ *
+ * @typeParam C - The variant's cases
+ */
+export type ScheduleStatusCasesType<C extends Record<string, unknown>> = StructType<{
+    [K in keyof C]: ScheduleStatusType;
+}>;
+/**
+ * Constructs the status table of a status variant: one
+ * {@link ScheduleStatusType} per case.
+ *
+ * @typeParam V - The status variant
+ * @param statusType - The status variant
+ * @returns A struct with a field per case
+ * @throws {Error} When the type is not a variant
+ */
+export declare function ScheduleStatusCasesFor<V extends VariantType>(statusType: V): ScheduleStatusCasesType<V["cases"]>;
+/**
+ * A time of day: what a template starts at when it is dropped on a whole day.
+ *
+ * @property hour - The hour, 0–23
+ * @property minute - The minute, 0–59
+ */
+export declare const ScheduleClockType: StructType<{
+    readonly hour: IntegerType;
+    readonly minute: IntegerType;
+}>;
+/** Type representing {@link ScheduleClockType}. */
+export type ScheduleClockType = typeof ScheduleClockType;
+/** How long something takes: the time contract's minutes, hours, days, weeks or months, as a Float. */
+export declare const ScheduleDurationType: VariantType<{
+    readonly minutes: import("@elaraai/east").FloatType;
+    readonly hours: import("@elaraai/east").FloatType;
+    readonly days: import("@elaraai/east").FloatType;
+    readonly weeks: import("@elaraai/east").FloatType;
+    readonly months: import("@elaraai/east").FloatType;
+}>;
+/** Type representing {@link ScheduleDurationType}. */
+export type ScheduleDurationType = typeof ScheduleDurationType;
+/**
+ * Where a drop would put an event: what a builder's `canDrop` is asked.
+ *
+ * @property kind - The event kind's slot name
+ * @property from - What is dropped: a template's key, a backlog row's key, or an event's key
+ * @property start - Where it would start
+ * @property end - Where it would end
+ * @property resource - The resource it would be on, if any
+ */
+export declare const ScheduleCandidateType: StructType<{
+    readonly kind: StringType;
+    readonly from: VariantType<{
+        readonly template: StringType;
+        readonly backlog: StringType;
+        readonly event: StringType;
+    }>;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly resource: OptionType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+    }>>;
+}>;
+/** Type representing {@link ScheduleCandidateType}. */
+export type ScheduleCandidateType = typeof ScheduleCandidateType;
+/**
+ * One event, as every view draws it.
+ *
+ * @property kind - Its kind's slot name
+ * @property key - Its record key's text
+ * @property title - Its title
+ * @property start - When it starts; `none` in the backlog
+ * @property end - When it ends; `none` in the backlog
+ * @property resource - The resource it is on, if any
+ * @property status - Its status, as its kind's `status` shows it
+ * @property minutes - Its length in minutes, or a backlog row's duration (a month counts 30 days)
+ * @property due - When it is due, for a backlog row
+ */
+export declare const ScheduleItemType: StructType<{
+    readonly kind: StringType;
+    readonly key: StringType;
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly resource: OptionType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+    }>>;
+    readonly status: OptionType<StructType<{
+        readonly label: StringType;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly ring: BooleanType;
+    }>>;
+    readonly minutes: IntegerType;
+    readonly due: OptionType<DateTimeType>;
+}>;
+/** Type representing {@link ScheduleItemType}. */
+export type ScheduleItemType = typeof ScheduleItemType;
+/**
+ * One field written into an event: its path, and its new value as bytes at
+ * the field's type — what an inspector edit writes, and each field a library
+ * card's drop sets (#1195).
+ *
+ * @property path - The field's path, a step per struct
+ * @property value - Its new value, as bytes at the field's type
+ */
+export declare const ScheduleFieldWriteType: StructType<{
+    readonly path: ArrayType<StringType>;
+    readonly value: BlobType;
+}>;
+/** Type representing {@link ScheduleFieldWriteType}. */
+export type ScheduleFieldWriteType = typeof ScheduleFieldWriteType;
+/**
+ * One gesture, as `write` takes it.
+ *
+ * @property place - A move, a resize or a schedule: the start, the end and the resource
+ * @property unplace - Back to the backlog: no start and no end
+ * @property field - An inspector edit: the field's path and its new value, as bytes at the field's type
+ * @property create - A template dropped: its key, and where the new event goes
+ */
+export declare const ScheduleGestureType: VariantType<{
+    readonly place: StructType<{
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+    }>;
+    readonly unplace: NullType;
+    readonly field: StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly value: BlobType;
+    }>;
+    readonly create: StructType<{
+        readonly template: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+    }>;
+}>;
+/** Type representing {@link ScheduleGestureType}. */
+export type ScheduleGestureType = typeof ScheduleGestureType;
+/**
+ * One gesture, written into one entry through the kind's field names.
+ *
+ * @property id - The entry's id: its key's text
+ * @property entry - The entry as the gesture finds it, as bytes at the record's entry type; empty for a `create`
+ * @property gesture - The gesture
+ */
+export declare const ScheduleWriteType: StructType<{
+    readonly id: StringType;
+    readonly entry: BlobType;
+    readonly gesture: VariantType<{
+        readonly place: StructType<{
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+        }>;
+        readonly unplace: NullType;
+        readonly field: StructType<{
+            readonly path: ArrayType<StringType>;
+            readonly value: BlobType;
+        }>;
+        readonly create: StructType<{
+            readonly template: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+        }>;
+    }>;
+}>;
+/** Type representing {@link ScheduleWriteType}. */
+export type ScheduleWriteType = typeof ScheduleWriteType;
+/**
+ * One template, as the library lists it and a drop creates from it.
+ *
+ * @property key - Unique within its kind
+ * @property name - The card's name
+ * @property group - The library's group for it
+ * @property at - When it starts if dropped on a whole day
+ * @property duration - How long it runs
+ * @property values - A value for every field but the start, the end and the resource, as bytes
+ */
+export declare const ScheduleTemplateType: StructType<{
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly group: OptionType<StringType>;
+    readonly at: OptionType<StructType<{
+        readonly hour: IntegerType;
+        readonly minute: IntegerType;
+    }>>;
+    readonly duration: VariantType<{
+        readonly minutes: import("@elaraai/east").FloatType;
+        readonly hours: import("@elaraai/east").FloatType;
+        readonly days: import("@elaraai/east").FloatType;
+        readonly weeks: import("@elaraai/east").FloatType;
+        readonly months: import("@elaraai/east").FloatType;
+    }>;
+    readonly values: BlobType;
+}>;
+/** Type representing {@link ScheduleTemplateType}. */
+export type ScheduleTemplateType = typeof ScheduleTemplateType;
+/**
+ * The drafts a seam reads, by entry id: each the entry's draft, as bytes at
+ * the kind's draft type (`Editing.Types.DraftField(R)`) — `value` the entry
+ * as drafted, `missing` an entry deleted.
+ */
+export declare const ScheduleDraftsType: DictType<StringType, BlobType>;
+/** Type representing {@link ScheduleDraftsType}. */
+export type ScheduleDraftsType = typeof ScheduleDraftsType;
+/**
+ * One drafted entry, as a kind's `ready` reads it.
+ *
+ * @property id - The entry's id: its key's text
+ * @property entry - The drafted entry, as bytes at the record's entry type
+ */
+export declare const ScheduleReadyEntryType: StructType<{
+    readonly id: StringType;
+    readonly entry: BlobType;
+}>;
+/** Type representing {@link ScheduleReadyEntryType}. */
+export type ScheduleReadyEntryType = typeof ScheduleReadyEntryType;
+/**
+ * A kind's record read by key, for a kind read a window at a time (#1199):
+ * what its editing session's base is — the record's revision — and how one
+ * event is read without the record whole.
+ *
+ * @property revision - The record's revision, `none` while it resolves: the snapshot every read of the record is at
+ * @property refresh - Moves every read of the record to a revision, or to the one it holds now
+ * @property entry - One event by its key's text: `none` while its read is in flight, `some(none)` for a key the record does not hold, else its row as bytes at the record's entry type
+ * @property last - The record's largest key's text — how a new Integer key is made past every key it holds: `none` while its read is in flight, `some(none)` for an empty record
+ */
+export declare const ScheduleEntriesType: StructType<{
+    readonly revision: FunctionType<[], OptionType<StringType>>;
+    readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+    readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+    readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+}>;
+/** Type representing {@link ScheduleEntriesType}. */
+export type ScheduleEntriesType = typeof ScheduleEntriesType;
+/**
+ * Whether two events of a kind on one resource at once are a conflict.
+ *
+ * @property warn - They are: both wear a warn ring, and the overlaps count them (the default)
+ * @property allow - They are not: the kind's events run in parallel
+ */
+export declare const ScheduleOverlapsType: VariantType<{
+    readonly warn: NullType;
+    readonly allow: NullType;
+}>;
+/** Type representing {@link ScheduleOverlapsType}. */
+export type ScheduleOverlapsType = typeof ScheduleOverlapsType;
+/** One event and its full record row, read with the current drafts in place. */
+export declare const ScheduleReadType: StructType<{
+    readonly item: StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>;
+    readonly row: BlobType;
+}>;
+/** Type representing ScheduleReadType. */
+export type ScheduleReadType = typeof ScheduleReadType;
+/** The fields whose edits are owned by the schedule section of an inspector. */
+export declare const ScheduleRolesType: StructType<{
+    readonly title: StringType;
+    readonly start: StringType;
+    readonly end: StringType;
+    readonly resource: OptionType<StringType>;
+    readonly status: OptionType<StringType>;
+}>;
+/**
+ * One event kind, closed: every row crosses as bytes at the record's own entry
+ * type, so a builder's payload is one type whatever the records hold.
+ *
+ * @property key - The kind's slot name
+ * @property name - Its name
+ * @property icon - Its Font Awesome icon
+ * @property takes - The resource kinds its events may be on
+ * @property status - How each case of its status shows
+ * @property backlog - Whether its rows with no time are its backlog
+ * @property templates - Its templates, for the library
+ * @property fields - The inspector's form over its other fields (`Fields`)
+ * @property items - Its events overlapping `[from, to)`, the drafts in place; `none` while a read is in flight
+ * @property unscheduled - Its backlog: the rows with no time, the drafts in place
+ * @property write - Each gesture into its entry's new bytes; `none` for a gesture the kind refuses
+ * @property ready - The author's check over drafted entries, one result each
+ * @property editing - The shared session over the record: its entry and key types, and its patch door — its base the record's snapshot, or for a kind read a window at a time (#1199) its revision
+ * @property entries - The record read by key, for a kind read a window at a time (#1199); `none` for a kind read whole
+ * @property history - The record's commits, newest first
+ */
+export declare const ScheduleKindType: StructType<{
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly takes: ArrayType<StringType>;
+    readonly status: ArrayType<StructType<{
+        readonly case: StringType;
+        readonly status: StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>;
+    }>>;
+    readonly backlog: BooleanType;
+    readonly templates: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly at: OptionType<StructType<{
+            readonly hour: IntegerType;
+            readonly minute: IntegerType;
+        }>>;
+        readonly duration: VariantType<{
+            readonly minutes: import("@elaraai/east").FloatType;
+            readonly hours: import("@elaraai/east").FloatType;
+            readonly days: import("@elaraai/east").FloatType;
+            readonly weeks: import("@elaraai/east").FloatType;
+            readonly months: import("@elaraai/east").FloatType;
+        }>;
+        readonly values: BlobType;
+    }>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: BooleanType;
+        readonly editor: VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<import("@elaraai/east").FloatType>;
+                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                readonly max: OptionType<import("@elaraai/east").FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly items: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>>>>;
+    readonly unscheduled: FunctionType<[DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>>>>;
+    readonly write: FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+        readonly gesture: VariantType<{
+            readonly place: StructType<{
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly resource: OptionType<StructType<{
+                    readonly kind: StringType;
+                    readonly key: StringType;
+                }>>;
+            }>;
+            readonly unplace: NullType;
+            readonly field: StructType<{
+                readonly path: ArrayType<StringType>;
+                readonly value: BlobType;
+            }>;
+            readonly create: StructType<{
+                readonly template: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly resource: OptionType<StructType<{
+                    readonly kind: StringType;
+                    readonly key: StringType;
+                }>>;
+            }>;
+        }>;
+    }>>], ArrayType<OptionType<BlobType>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly editing: StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>;
+    /** One event and its row, read from the window or by key, with drafts applied. */
+    readonly event: FunctionType<[StringType, DictType<StringType, BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly item: StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        readonly row: BlobType;
+    }>>>;
+    /** The inspector's schedule fields. */
+    readonly schedule: StructType<{
+        readonly title: StringType;
+        readonly start: StringType;
+        readonly end: StringType;
+        readonly resource: OptionType<StringType>;
+        readonly status: OptionType<StringType>;
+    }>;
+    /** Whether this kind participates in overlap warnings. */
+    readonly overlaps: VariantType<{
+        readonly warn: NullType;
+        readonly allow: NullType;
+    }>;
+    /** The author's form in place of the default fields. */
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+}>;
+/** Type representing {@link ScheduleKindType}. */
+export type ScheduleKindType = typeof ScheduleKindType;
+/**
+ * One resource, resolved.
+ *
+ * @property key - Its key's text
+ * @property label - Its name
+ * @property meta - Its second line
+ */
+export declare const ScheduleResourceRowType: StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly meta: OptionType<StringType>;
+}>;
+/** Type representing {@link ScheduleResourceRowType}. */
+export type ScheduleResourceRowType = typeof ScheduleResourceRowType;
+/**
+ * One resource kind, its rows resolved.
+ *
+ * @property key - The kind's slot name
+ * @property name - Its name
+ * @property icon - Its Font Awesome icon
+ * @property rows - Its resources, in key order
+ */
+export declare const ScheduleResourcesType: StructType<{
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly rows: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+    }>>;
+}>;
+/** Type representing {@link ScheduleResourcesType}. */
+export type ScheduleResourcesType = typeof ScheduleResourcesType;
+/**
+ * One event as Plan draws it: what every view draws ({@link ScheduleItemType}),
+ * with its lifecycle, its quantity and its lane.
+ *
+ * @property state - The lifecycle it wears, from its kind's `state` field; confirmed when the kind has none
+ * @property quantity - Its kind's `quantity` field, with the kind's unit and format: what a bar prints and a parent's rollup sums
+ * @property lane - The lane its tile sits in, from its kind's `lane` field
+ */
+export declare const PlanEventItemType: StructType<{
+    readonly state: VariantType<{
+        readonly estimated: NullType;
+        readonly proposed: VariantType<{
+            readonly added: NullType;
+            readonly recommended: NullType;
+            readonly removed: NullType;
+        }>;
+        readonly confirmed: NullType;
+        readonly "in-progress": NullType;
+        readonly actual: NullType;
+        readonly rejected: NullType;
+    }>;
+    readonly quantity: OptionType<StructType<{
+        readonly value: import("@elaraai/east").FloatType;
+        readonly unit: OptionType<StringType>;
+        readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+        readonly text: OptionType<StringType>;
+    }>>;
+    readonly lane: OptionType<StringType>;
+    readonly kind: StringType;
+    readonly key: StringType;
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly resource: OptionType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+    }>>;
+    readonly status: OptionType<StructType<{
+        readonly label: StringType;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly ring: BooleanType;
+    }>>;
+    readonly minutes: IntegerType;
+    readonly due: OptionType<DateTimeType>;
+}>;
+/** Type representing {@link PlanEventItemType}. */
+export type PlanEventItemType = typeof PlanEventItemType;
+/**
+ * One event read by its key, as a Plan's inspector shows it (#1197).
+ *
+ * @property item - The event as Plan draws it
+ * @property row - Its row, as bytes at the record's entry type: what the kind's form and its own inspector read
+ */
+export declare const PlanEventReadType: StructType<{
+    readonly item: StructType<{
+        readonly state: VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+        readonly quantity: OptionType<StructType<{
+            readonly value: import("@elaraai/east").FloatType;
+            readonly unit: OptionType<StringType>;
+            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+            readonly text: OptionType<StringType>;
+        }>>;
+        readonly lane: OptionType<StringType>;
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>;
+    readonly row: BlobType;
+}>;
+/** Type representing {@link PlanEventReadType}. */
+export type PlanEventReadType = typeof PlanEventReadType;
+/**
+ * The fields an event kind's roles read on a Plan, by name: what a gesture
+ * writes to change one (a `field` gesture's path), and what the inspector
+ * draws in its own sections rather than in the kind's form.
+ *
+ * @property state - The `EventStateType` field
+ * @property quantity - The `Float` quantity field
+ * @property lane - The `String` lane field
+ */
+export declare const PlanEventRolesType: StructType<{
+    readonly state: OptionType<StringType>;
+    readonly quantity: OptionType<StringType>;
+    readonly lane: OptionType<StringType>;
+}>;
+/** Type representing {@link PlanEventRolesType}. */
+export type PlanEventRolesType = typeof PlanEventRolesType;
+/**
+ * One event kind as Plan's builder takes it: the Calendar's closed kind
+ * ({@link ScheduleKindType}), field for field, with how the kind draws and its
+ * roles, its events as Plan draws them, and its own inspector.
+ *
+ * @property draw - How it draws: bars, tiles, chips or marks
+ * @property instant - Whether each of its events is one instant (`at`), its start and its end the same
+ * @property overlaps - Whether two of its events on one resource at once are a conflict
+ * @property roles - The fields its roles read
+ * @property planItems - Its events overlapping `[from, to)` as Plan draws them, the drafts in place; `none` while a read is in flight
+ * @property planUnscheduled - Its backlog as Plan draws it, the drafts in place
+ * @property planEvent - One event by its key's text, the drafts in place (#1197): as Plan draws it, and its row; `none` when there is no such event. A kind read a window at a time (#1199) looks for it first among the rows its windows hold over `[from, to)` — the range the canvas reads, where a gesture's event is drawn — and its backlog's, then reads it by its key, `none` while that read is in flight; a kind read whole takes no notice of the range
+ * @property inspector - Its own inspector for one event (PB60, #1197): the event's row and a writer of the edited row, as bytes, to what the inspector shows in place of the kind's form; `none`, the form
+ */
+export declare const PlanEventKindType: StructType<{
+    readonly draw: VariantType<{
+        readonly span: NullType;
+        readonly buckets: NullType;
+        readonly cards: NullType;
+        readonly marks: NullType;
+    }>;
+    readonly instant: BooleanType;
+    readonly overlaps: VariantType<{
+        readonly warn: NullType;
+        readonly allow: NullType;
+    }>;
+    readonly roles: StructType<{
+        readonly state: OptionType<StringType>;
+        readonly quantity: OptionType<StringType>;
+        readonly lane: OptionType<StringType>;
+    }>;
+    readonly planItems: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+        readonly state: VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+        readonly quantity: OptionType<StructType<{
+            readonly value: import("@elaraai/east").FloatType;
+            readonly unit: OptionType<StringType>;
+            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+            readonly text: OptionType<StringType>;
+        }>>;
+        readonly lane: OptionType<StringType>;
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>>>>;
+    readonly planUnscheduled: FunctionType<[DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+        readonly state: VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
+        }>;
+        readonly quantity: OptionType<StructType<{
+            readonly value: import("@elaraai/east").FloatType;
+            readonly unit: OptionType<StringType>;
+            readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+            readonly text: OptionType<StringType>;
+        }>>;
+        readonly lane: OptionType<StringType>;
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>>>>;
+    readonly planEvent: FunctionType<[StringType, DictType<StringType, BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly item: StructType<{
+            readonly state: VariantType<{
+                readonly estimated: NullType;
+                readonly proposed: VariantType<{
+                    readonly added: NullType;
+                    readonly recommended: NullType;
+                    readonly removed: NullType;
+                }>;
+                readonly confirmed: NullType;
+                readonly "in-progress": NullType;
+                readonly actual: NullType;
+                readonly rejected: NullType;
+            }>;
+            readonly quantity: OptionType<StructType<{
+                readonly value: import("@elaraai/east").FloatType;
+                readonly unit: OptionType<StringType>;
+                readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
+                readonly text: OptionType<StringType>;
+            }>>;
+            readonly lane: OptionType<StringType>;
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        readonly row: BlobType;
+    }>>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly takes: ArrayType<StringType>;
+    readonly status: ArrayType<StructType<{
+        readonly case: StringType;
+        readonly status: StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>;
+    }>>;
+    readonly backlog: BooleanType;
+    readonly templates: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly at: OptionType<StructType<{
+            readonly hour: IntegerType;
+            readonly minute: IntegerType;
+        }>>;
+        readonly duration: VariantType<{
+            readonly minutes: import("@elaraai/east").FloatType;
+            readonly hours: import("@elaraai/east").FloatType;
+            readonly days: import("@elaraai/east").FloatType;
+            readonly weeks: import("@elaraai/east").FloatType;
+            readonly months: import("@elaraai/east").FloatType;
+        }>;
+        readonly values: BlobType;
+    }>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: BooleanType;
+        readonly editor: VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<import("@elaraai/east").FloatType>;
+                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                readonly max: OptionType<import("@elaraai/east").FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly items: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>>>>;
+    readonly unscheduled: FunctionType<[DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly minutes: IntegerType;
+        readonly due: OptionType<DateTimeType>;
+    }>>>>;
+    readonly write: FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+        readonly gesture: VariantType<{
+            readonly place: StructType<{
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly resource: OptionType<StructType<{
+                    readonly kind: StringType;
+                    readonly key: StringType;
+                }>>;
+            }>;
+            readonly unplace: NullType;
+            readonly field: StructType<{
+                readonly path: ArrayType<StringType>;
+                readonly value: BlobType;
+            }>;
+            readonly create: StructType<{
+                readonly template: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly resource: OptionType<StructType<{
+                    readonly kind: StringType;
+                    readonly key: StringType;
+                }>>;
+            }>;
+        }>;
+    }>>], ArrayType<OptionType<BlobType>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly editing: StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>;
+    /** One event and its row, read from the window or by key, with drafts applied. */
+    readonly event: FunctionType<[StringType, DictType<StringType, BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly item: StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>;
+        readonly row: BlobType;
+    }>>>;
+    /** The inspector's schedule fields. */
+    readonly schedule: StructType<{
+        readonly title: StringType;
+        readonly start: StringType;
+        readonly end: StringType;
+        readonly resource: OptionType<StringType>;
+        readonly status: OptionType<StringType>;
+    }>;
+}>;
+/** Type representing {@link PlanEventKindType}. */
+export type PlanEventKindType = typeof PlanEventKindType;
+/**
+ * One resource as Plan's builder takes it: what every view draws
+ * ({@link ScheduleResourceRowType}), with where it sits and its gutter.
+ *
+ * @property group - The group strip it sits under (a hall); `none` when the kind has no `group`
+ * @property parent - The key's text of the resource of its kind it nests under
+ * @property sub - The gutter's sub line
+ * @property value - The gutter's value slot
+ * @property status - The gutter's status dot
+ * @property collapsed - Whether it starts folded, when it has resources under it
+ */
+export declare const PlanResourceRowType: StructType<{
+    readonly group: OptionType<StringType>;
+    readonly parent: OptionType<StringType>;
+    readonly sub: OptionType<StringType>;
+    readonly value: OptionType<StringType>;
+    readonly status: OptionType<VariantType<{
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>>;
+    readonly collapsed: BooleanType;
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly meta: OptionType<StringType>;
+}>;
+/** Type representing {@link PlanResourceRowType}. */
+export type PlanResourceRowType = typeof PlanResourceRowType;
+/**
+ * One resource kind as Plan's builder takes it, its rows resolved.
+ *
+ * @property key - The kind's slot name
+ * @property name - Its name
+ * @property icon - Its Font Awesome icon
+ * @property rollup - How a parent's bands roll its children's events up
+ * @property measures - Its measures' keys, in order: the rows under each of its resources, each at its resource's path (#1197)
+ * @property rows - Its resources, in key order — none for a kind paged a window at a time (#1199)
+ * @property byKey - A paged kind's resource by its key's text (#1199): its window's key search for the key, then a one-row page, as Plan's builder takes it — `none` while either is in flight, `some(none)` for a key the kind does not have; `none` for a kind whose rows are listed
+ */
+export declare const PlanResourcesType: StructType<{
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly rollup: VariantType<{
+        readonly union: NullType;
+        readonly byStatus: NullType;
+        readonly sum: NullType;
+    }>;
+    readonly measures: ArrayType<StringType>;
+    readonly rows: ArrayType<StructType<{
+        readonly group: OptionType<StringType>;
+        readonly parent: OptionType<StringType>;
+        readonly sub: OptionType<StringType>;
+        readonly value: OptionType<StringType>;
+        readonly status: OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+        readonly collapsed: BooleanType;
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+    }>>;
+    readonly byKey: OptionType<FunctionType<[StringType], OptionType<OptionType<StructType<{
+        readonly group: OptionType<StringType>;
+        readonly parent: OptionType<StringType>;
+        readonly sub: OptionType<StringType>;
+        readonly value: OptionType<StringType>;
+        readonly status: OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+        readonly collapsed: BooleanType;
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+    }>>>>>;
+}>;
+/** Type representing {@link PlanResourcesType}. */
+export type PlanResourcesType = typeof PlanResourcesType;
+//# sourceMappingURL=types.d.ts.map