@elaraai/e3-ui 1.0.94 → 1.0.95

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

@@ -10,7 +10,7 @@
  *
  * @packageDocumentation
  */
-import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, SetType, 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).
@@ -89,11 +89,11 @@ export declare const ScheduleClockType: StructType<{
 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;
+    readonly minutes: FloatType;
+    readonly hours: FloatType;
+    readonly days: FloatType;
+    readonly weeks: FloatType;
+    readonly months: FloatType;
 }>;
 /** Type representing {@link ScheduleDurationType}. */
 export type ScheduleDurationType = typeof ScheduleDurationType;
@@ -122,6 +122,63 @@ export declare const ScheduleCandidateType: StructType<{
 }>;
 /** Type representing {@link ScheduleCandidateType}. */
 export type ScheduleCandidateType = typeof ScheduleCandidateType;
+/**
+ * Why something does not fit: the refusal a fit gives, and what a run of
+ * refusals of one group gathers into one label (`Over max · by 4–13 m³`).
+ *
+ * @property group - Its group, the run label's lead (`Over max`, `Busy`, `Gap too short`)
+ * @property reason - Its words (`over max by 4 m³`)
+ * @property measure - What the run's label gathers: nothing, an amount (`by` 4) or a day (`until` Fri 14)
+ */
+export declare const ScheduleRefusalType: StructType<{
+    readonly group: StringType;
+    readonly reason: StringType;
+    readonly measure: VariantType<{
+        readonly none: NullType;
+        readonly amount: StructType<{
+            readonly lead: StringType;
+            readonly value: FloatType;
+        }>;
+        readonly day: StructType<{
+            readonly lead: StringType;
+            readonly at: DateTimeType;
+        }>;
+    }>;
+}>;
+/** Type representing {@link ScheduleRefusalType}. */
+export type ScheduleRefusalType = typeof ScheduleRefusalType;
+/**
+ * One verdict of a fit: it fits, with its score, its reason and a warning,
+ * or it is refused. A builder ranks the fits by score and shows each reason
+ * as it is; it computes none of its own.
+ *
+ * @property fits - It fits: higher scores rank first; `why` its reason (`3 d spare to Wed 19 · leaves 31 m³ · takes 20–40`); `warn` a warning it still fits with (`under min`)
+ * @property refused - It does not fit, and why
+ */
+export declare const ScheduleFitType: VariantType<{
+    readonly fits: StructType<{
+        readonly score: FloatType;
+        readonly why: StringType;
+        readonly warn: OptionType<StringType>;
+    }>;
+    readonly refused: StructType<{
+        readonly group: StringType;
+        readonly reason: StringType;
+        readonly measure: VariantType<{
+            readonly none: NullType;
+            readonly amount: StructType<{
+                readonly lead: StringType;
+                readonly value: FloatType;
+            }>;
+            readonly day: StructType<{
+                readonly lead: StringType;
+                readonly at: DateTimeType;
+            }>;
+        }>;
+    }>;
+}>;
+/** Type representing {@link ScheduleFitType}. */
+export type ScheduleFitType = typeof ScheduleFitType;
 /**
  * One event, as every view draws it.
  *
@@ -265,11 +322,11 @@ export declare const ScheduleTemplateType: StructType<{
         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 minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
     }>;
     readonly values: BlobType;
 }>;
@@ -374,9 +431,12 @@ export declare const ScheduleRolesType: StructType<{
  * @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 templatesSource - The builder's Slice source whose shown keys filter its templates, the source its templates list names; none, every template shows (#1343)
  * @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 unscheduled - Its backlog: the rows with no time, the drafts in place. It takes the window `[from, to)`
+ *   the canvas reads: a kind narrowed by its builder's slice holds the events its narrowing holds there and in its
+ *   backlog alike, so a draft moves one between them by its times (#1343)
  * @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
@@ -412,14 +472,15 @@ export declare const ScheduleKindType: StructType<{
             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 minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
         }>;
         readonly values: BlobType;
     }>>;
+    readonly templatesSource: OptionType<StringType>;
     readonly fields: ArrayType<StructType<{
         readonly path: ArrayType<StringType>;
         readonly label: StringType;
@@ -474,9 +535,9 @@ export declare const ScheduleKindType: StructType<{
             }>;
             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 step: OptionType<FloatType>;
+                readonly min: OptionType<FloatType>;
+                readonly max: OptionType<FloatType>;
             }>;
             readonly checkbox: NullType;
             readonly datetime: StructType<{
@@ -527,7 +588,7 @@ export declare const ScheduleKindType: StructType<{
         readonly minutes: IntegerType;
         readonly due: OptionType<DateTimeType>;
     }>>>>;
-    readonly unscheduled: FunctionType<[DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+    readonly unscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
         readonly kind: StringType;
         readonly key: StringType;
         readonly title: StringType;
@@ -884,7 +945,7 @@ export declare const PlanEventItemType: StructType<{
         readonly rejected: NullType;
     }>;
     readonly quantity: OptionType<StructType<{
-        readonly value: import("@elaraai/east").FloatType;
+        readonly value: FloatType;
         readonly unit: OptionType<StringType>;
         readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
         readonly text: OptionType<StringType>;
@@ -936,7 +997,7 @@ export declare const PlanEventReadType: StructType<{
             readonly rejected: NullType;
         }>;
         readonly quantity: OptionType<StructType<{
-            readonly value: import("@elaraai/east").FloatType;
+            readonly value: FloatType;
             readonly unit: OptionType<StringType>;
             readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
             readonly text: OptionType<StringType>;
@@ -995,7 +1056,7 @@ export type PlanEventRolesType = typeof PlanEventRolesType;
  * @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 planUnscheduled - Its backlog as Plan draws it, the drafts in place, over the window `[from, to)` the canvas reads, as `unscheduled` takes it
  * @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
  */
@@ -1030,7 +1091,7 @@ export declare const PlanEventKindType: StructType<{
             readonly rejected: NullType;
         }>;
         readonly quantity: OptionType<StructType<{
-            readonly value: import("@elaraai/east").FloatType;
+            readonly value: FloatType;
             readonly unit: OptionType<StringType>;
             readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
             readonly text: OptionType<StringType>;
@@ -1059,7 +1120,7 @@ export declare const PlanEventKindType: StructType<{
         readonly minutes: IntegerType;
         readonly due: OptionType<DateTimeType>;
     }>>>>;
-    readonly planUnscheduled: FunctionType<[DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+    readonly planUnscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
         readonly state: VariantType<{
             readonly estimated: NullType;
             readonly proposed: VariantType<{
@@ -1073,7 +1134,7 @@ export declare const PlanEventKindType: StructType<{
             readonly rejected: NullType;
         }>;
         readonly quantity: OptionType<StructType<{
-            readonly value: import("@elaraai/east").FloatType;
+            readonly value: FloatType;
             readonly unit: OptionType<StringType>;
             readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
             readonly text: OptionType<StringType>;
@@ -1117,7 +1178,7 @@ export declare const PlanEventKindType: StructType<{
                 readonly rejected: NullType;
             }>;
             readonly quantity: OptionType<StructType<{
-                readonly value: import("@elaraai/east").FloatType;
+                readonly value: FloatType;
                 readonly unit: OptionType<StringType>;
                 readonly format: OptionType<import("@elaraai/east-ui/internal").TickFormatType>;
                 readonly text: OptionType<StringType>;
@@ -1177,14 +1238,15 @@ export declare const PlanEventKindType: StructType<{
             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 minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
         }>;
         readonly values: BlobType;
     }>>;
+    readonly templatesSource: OptionType<StringType>;
     readonly fields: ArrayType<StructType<{
         readonly path: ArrayType<StringType>;
         readonly label: StringType;
@@ -1239,9 +1301,9 @@ export declare const PlanEventKindType: StructType<{
             }>;
             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 step: OptionType<FloatType>;
+                readonly min: OptionType<FloatType>;
+                readonly max: OptionType<FloatType>;
             }>;
             readonly checkbox: NullType;
             readonly datetime: StructType<{
@@ -1292,7 +1354,7 @@ export declare const PlanEventKindType: StructType<{
         readonly minutes: IntegerType;
         readonly due: OptionType<DateTimeType>;
     }>>>>;
-    readonly unscheduled: FunctionType<[DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
+    readonly unscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, BlobType>], OptionType<ArrayType<StructType<{
         readonly kind: StringType;
         readonly key: StringType;
         readonly title: StringType;
@@ -1674,4 +1736,1576 @@ export declare const PlanResourcesType: StructType<{
 }>;
 /** Type representing {@link PlanResourcesType}. */
 export type PlanResourcesType = typeof PlanResourcesType;
+/**
+ * A duty's roles, as the Roster reads them from the app's row
+ * (`Builder Interfaces Spec.md` §4.1, §5.2): what its kind's fields hold,
+ * whatever the row calls them.
+ *
+ * @property start - When it starts
+ * @property end - When it ends
+ * @property resource - Who: a person, or an agency asked to send someone, by the resource kind its field's case names
+ * @property shift - Its shift's key
+ * @property group - The group it is rostered in
+ * @property position - The position held; `none` for a kind with no `position` role
+ * @property activity - Its activity; `none` when it has none, or the kind has no `activity` role
+ * @property hours - The hours it counts: its kind's `hours` accessor's, or its length
+ */
+export declare const ScheduleRosterRolesType: StructType<{
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly resource: OptionType<StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+    }>>;
+    readonly shift: StringType;
+    readonly group: StringType;
+    readonly position: OptionType<StringType>;
+    readonly activity: OptionType<StringType>;
+    readonly hours: FloatType;
+}>;
+/** Type representing {@link ScheduleRosterRolesType}. */
+export type ScheduleRosterRolesType = typeof ScheduleRosterRolesType;
+/**
+ * One stored duty, as a Roster kind's `rows` gives it: its roles, read in the
+ * same pass that reads the row, and the row as bytes at the row type — what a
+ * write and the session take, and what a request's assignment carries.
+ *
+ * @property roles - Its roles
+ * @property row - Its row, as bytes at the row type
+ */
+export declare const ScheduleRosterEntryType: StructType<{
+    readonly roles: StructType<{
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly shift: StringType;
+        readonly group: StringType;
+        readonly position: OptionType<StringType>;
+        readonly activity: OptionType<StringType>;
+        readonly hours: FloatType;
+    }>;
+    readonly row: BlobType;
+}>;
+/** Type representing {@link ScheduleRosterEntryType}. */
+export type ScheduleRosterEntryType = typeof ScheduleRosterEntryType;
+/**
+ * One event kind as the Roster takes it (#1367): the Calendar's closed kind
+ * — its session over the record, its reads, its form — with its rows, and its
+ * roles read from a row and written into one.
+ *
+ * @property kind - The Calendar's closed kind: its `editing`, `entries`, `history`, `ready`, `fields` and `inspector`
+ * @property rows - Its stored duties overlapping `[from, to)`, by key, each its roles and its row; `none` while a read is in flight
+ * @property read - A drafted row's roles, from its bytes and its key: what `rows` gives a stored one
+ * @property write - The row with every mapped field written from the roles and every other field as it was; `none` for a resource of a kind it does not take
+ * @property create - A new row from the roles, every other field its type's default; `none` as `write` refuses
+ * @property roles - Which of the optional roles the kind maps
+ * @property rowType - The row type
+ */
+export declare const ScheduleRosterKindType: StructType<{
+    readonly kind: 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: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly values: BlobType;
+        }>>;
+        readonly templatesSource: OptionType<StringType>;
+        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<FloatType>;
+                    readonly min: OptionType<FloatType>;
+                    readonly max: OptionType<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<[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 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>>>;
+    }>;
+    readonly rows: FunctionType<[DateTimeType, DateTimeType], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly shift: StringType;
+            readonly group: StringType;
+            readonly position: OptionType<StringType>;
+            readonly activity: OptionType<StringType>;
+            readonly hours: FloatType;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType, StringType], StructType<{
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly shift: StringType;
+        readonly group: StringType;
+        readonly position: OptionType<StringType>;
+        readonly activity: OptionType<StringType>;
+        readonly hours: FloatType;
+    }>>;
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly shift: StringType;
+        readonly group: StringType;
+        readonly position: OptionType<StringType>;
+        readonly activity: OptionType<StringType>;
+        readonly hours: FloatType;
+    }>], OptionType<BlobType>>;
+    readonly create: FunctionType<[StructType<{
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly shift: StringType;
+        readonly group: StringType;
+        readonly position: OptionType<StringType>;
+        readonly activity: OptionType<StringType>;
+        readonly hours: FloatType;
+    }>], OptionType<BlobType>>;
+    readonly roles: StructType<{
+        readonly position: BooleanType;
+        readonly activity: BooleanType;
+    }>;
+    readonly rowType: 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;
+    }>>;
+}>;
+/** Type representing {@link ScheduleRosterKindType}. */
+export type ScheduleRosterKindType = typeof ScheduleRosterKindType;
+/**
+ * A bin's roles, as the Allocation reads them from the app's row
+ * (`Builder Interfaces Spec.md` §4.1, §6.2).
+ *
+ * @property at - Its time
+ * @property lane - Its lane's key
+ * @property arrival - The arrival it books; `none` for a reservation
+ * @property quantity - Its quantity
+ * @property parts - The quantity on each resource, by key
+ * @property hold - How long a resource holds it
+ * @property kind - What it goes with; `none` when it has none, or the kind has no `kind` role
+ */
+export declare const ScheduleAllocationRolesType: StructType<{
+    readonly at: DateTimeType;
+    readonly lane: StringType;
+    readonly arrival: OptionType<StringType>;
+    readonly quantity: FloatType;
+    readonly parts: DictType<StringType, FloatType>;
+    readonly hold: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly kind: OptionType<StringType>;
+}>;
+/** Type representing {@link ScheduleAllocationRolesType}. */
+export type ScheduleAllocationRolesType = typeof ScheduleAllocationRolesType;
+/**
+ * One stored bin, as an Allocation kind's `rows` gives it: its roles, read in
+ * the same pass that reads the row, and the row as bytes at the row type.
+ *
+ * @property roles - Its roles
+ * @property row - Its row, as bytes at the row type
+ */
+export declare const ScheduleAllocationEntryType: StructType<{
+    readonly roles: StructType<{
+        readonly at: DateTimeType;
+        readonly lane: StringType;
+        readonly arrival: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly parts: DictType<StringType, FloatType>;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+    }>;
+    readonly row: BlobType;
+}>;
+/** Type representing {@link ScheduleAllocationEntryType}. */
+export type ScheduleAllocationEntryType = typeof ScheduleAllocationEntryType;
+/**
+ * One event kind as the Allocation takes it (#1367): the Calendar's closed
+ * kind, with its rows, and its roles read from a row and written into one.
+ *
+ * @property kind - The Calendar's closed kind: its `editing`, `entries`, `history`, `ready`, `fields` and `inspector`
+ * @property rows - Its stored bins of `[from, to)`, by key, each its roles and its row; `none` while a read is in flight
+ * @property read - A drafted row's roles, from its bytes: what `rows` gives a stored one
+ * @property write - The row with every mapped field written from the roles and every other field as it was
+ * @property create - A new row from the roles, and an arrival's values — the fields no role maps, as bytes at `values` — or, with none, every such field its type's default
+ * @property lanes - The resource slot its lanes are: what its `resource.of` names
+ * @property parts - The resource slot its parts are on: what its `parts.of` names
+ * @property kinded - Whether it maps a `kind`
+ * @property unit - Its quantity's unit (`m³`), shown everywhere a quantity is: its `quantity.unit`
+ * @property values - The fields no role maps, a struct: what an arrival's values give a booked bin
+ * @property rowType - The row type
+ */
+export declare const ScheduleAllocationKindType: StructType<{
+    readonly kind: 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: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly values: BlobType;
+        }>>;
+        readonly templatesSource: OptionType<StringType>;
+        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<FloatType>;
+                    readonly min: OptionType<FloatType>;
+                    readonly max: OptionType<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<[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 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>>>;
+    }>;
+    readonly rows: FunctionType<[DateTimeType, DateTimeType], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly at: DateTimeType;
+            readonly lane: StringType;
+            readonly arrival: OptionType<StringType>;
+            readonly quantity: FloatType;
+            readonly parts: DictType<StringType, FloatType>;
+            readonly hold: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly kind: OptionType<StringType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType], StructType<{
+        readonly at: DateTimeType;
+        readonly lane: StringType;
+        readonly arrival: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly parts: DictType<StringType, FloatType>;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+    }>>;
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly at: DateTimeType;
+        readonly lane: StringType;
+        readonly arrival: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly parts: DictType<StringType, FloatType>;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+    }>], BlobType>;
+    readonly create: FunctionType<[StructType<{
+        readonly at: DateTimeType;
+        readonly lane: StringType;
+        readonly arrival: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly parts: DictType<StringType, FloatType>;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+    }>, OptionType<BlobType>], BlobType>;
+    readonly lanes: StringType;
+    readonly parts: StringType;
+    readonly kinded: BooleanType;
+    readonly unit: OptionType<StringType>;
+    readonly values: 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 rowType: 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;
+    }>>;
+}>;
+/** Type representing {@link ScheduleAllocationKindType}. */
+export type ScheduleAllocationKindType = typeof ScheduleAllocationKindType;
+/**
+ * A period's status, as a builder reads it from the app's status field
+ * (`Builder Interfaces Spec.md` §4.3).
+ *
+ * @property draft - The draft case: editable
+ * @property published - The published case, and when, when the case holds a time; read-only
+ * @property other - Any other case of the app's status, by its name; read-only
+ */
+export declare const SchedulePeriodStatusType: VariantType<{
+    readonly draft: NullType;
+    readonly published: StructType<{
+        readonly at: OptionType<DateTimeType>;
+    }>;
+    readonly other: StringType;
+}>;
+/** Type representing {@link SchedulePeriodStatusType}. */
+export type SchedulePeriodStatusType = typeof SchedulePeriodStatusType;
+/**
+ * What a builder publishes, closed (`Schedule.periods`, #1367): the app's
+ * record of periods, a row each, keyed by its start.
+ *
+ * @property every - What a period is: a week from the builder's week start, or a UTC day
+ * @property editing - The shared session over the record: whole rows by their start, its patch door
+ * @property entries - The record read by key, when it is given `entries`; `none` for a record read whole
+ * @property rows - The periods starting in `[from, to)`, by their start, as bytes at the row type; `none` while a read is in flight
+ * @property status - A row's status
+ * @property publish - The row, or a new one, with its status the published case at the time given
+ * @property dismissible - Whether the builder maps `dismissed`
+ * @property dismissed - The proposals a row dismissed; empty when the builder maps none
+ * @property dismiss - The row, or a new one, with its dismissed proposals the set given
+ * @property history - The record's commits, newest first
+ * @property rowType - The row type
+ */
+export declare const SchedulePeriodsKindType: StructType<{
+    readonly every: VariantType<{
+        readonly week: NullType;
+        readonly day: NullType;
+    }>;
+    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 rows: FunctionType<[DateTimeType, DateTimeType], OptionType<DictType<DateTimeType, BlobType>>>;
+    readonly status: FunctionType<[BlobType], VariantType<{
+        readonly draft: NullType;
+        readonly published: StructType<{
+            readonly at: OptionType<DateTimeType>;
+        }>;
+        readonly other: StringType;
+    }>>;
+    readonly publish: FunctionType<[OptionType<BlobType>, DateTimeType], BlobType>;
+    readonly dismissible: BooleanType;
+    readonly dismissed: FunctionType<[BlobType], SetType<StringType>>;
+    readonly dismiss: FunctionType<[OptionType<BlobType>, SetType<StringType>], BlobType>;
+    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>;
+    }>>>>;
+    readonly rowType: 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;
+    }>>;
+}>;
+/** Type representing {@link SchedulePeriodsKindType}. */
+export type SchedulePeriodsKindType = typeof SchedulePeriodsKindType;
 //# sourceMappingURL=types.d.ts.map