@elaraai/e3-ui 1.0.94 → 1.0.96

package/dist/src/allocation/index.d.ts

@@ -0,0 +1,2985 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `<Allocation>` (#1371, `Builder Interfaces Spec.md` §6, `Allocation Spec.md`):
+ * a day's arrivals booked into timed lane slots, and each bin allocated to
+ * resources with room and time for its hold, over the app's own records, in the
+ * renderer's BuilderFrame. It writes the app's bins through the bin kind's roles
+ * (`Schedule.events`), reads its lanes and its resources (`Schedule.resources`)
+ * and what it books from (`Allocation.arrivals`), and publishes the app's days
+ * (`Schedule.periods`). It stores nothing in a shape of its own.
+ *
+ * The tag validates, builds the lanes, the resources and the arrivals from
+ * their accessors, and assembles the closed payload; it composes no East UI
+ * component and emits no layout, session or gesture program. The app's bin row
+ * type `R` crosses the payload as beast2 bytes, as Schedule's kinds' rows do:
+ * the app's `check` over bytes at `CheckContext(R)`, its columns over bytes at
+ * `R`, and the fit's binding checked against `FitRequest(R)`. The renderer
+ * compiles the Allocation's functions over `R`, the bin kind's `rowType`, and
+ * calls the fit, the app's `e3.function`, by name: it computes no fit of its own.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BlobType, BooleanType, DateTimeType, FloatType, FunctionType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType, type SubtypeExprOrValue, type ValueTypeOf } from "@elaraai/east";
+import { StatusTokenType, TimeStepType, type UIElement } from "@elaraai/east-ui";
+import { RowSourceType, type RecordSlicesChromeOptions } from "@elaraai/east-ui/internal";
+import { type BoundFunc } from "../bind/func.js";
+import type { ScheduleEventKind } from "../schedule/events.js";
+import type { SchedulePeriods } from "../schedule/periods.js";
+import { type ScheduleResourceKind } from "../schedule/resources.js";
+import { allocationArrivals, type AllocationArrivals } from "./adapters.js";
+import { allocationAnswer, allocationCandidates, allocationCheck, allocationFit, allocationLoads, allocationLookahead, allocationSlots } from "./functions.js";
+import * as T from "./types.js";
+/**
+ * A declared library tab.
+ *
+ * @property arrivals - Arrivals: overdue, ready, removed from the plan, booked
+ * @property resources - Resources: free, loading and busy today
+ */
+export declare const AllocationLibraryTabType: VariantType<{
+    readonly arrivals: NullType;
+    readonly resources: NullType;
+}>;
+/** Type representing {@link AllocationLibraryTabType}. */
+export type AllocationLibraryTabType = typeof AllocationLibraryTabType;
+/**
+ * One of the app's bin fields shown as a Table column and an inspector row.
+ *
+ * @property key - Its key
+ * @property label - Its heading (`Spec`)
+ * @property text - Its text, from the bin's row as bytes at the row type
+ * @property tone - Its tone, from the row as bytes; `none` for plain text
+ * @property table - Whether the Table shows it; the inspector always does
+ */
+export declare const AllocationColumnType: StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly text: FunctionType<[BlobType], StringType>;
+    readonly tone: OptionType<FunctionType<[BlobType], OptionType<VariantType<{
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>>>>;
+    readonly table: BooleanType;
+}>;
+/** Type representing {@link AllocationColumnType}. */
+export type AllocationColumnType = typeof AllocationColumnType;
+/**
+ * One of the board's nouns, resolved: as a heading writes it, its plural, and its article.
+ *
+ * @property one - The singular, as a heading writes it (`Bay`)
+ * @property other - The plural (`Bays`)
+ * @property article - `a` or `an`, before the singular in running text
+ */
+export declare const AllocationNounType: StructType<{
+    readonly one: StringType;
+    readonly other: StringType;
+    readonly article: StringType;
+}>;
+/** Type representing {@link AllocationNounType}. */
+export type AllocationNounType = typeof AllocationNounType;
+/**
+ * The board's nouns, the app's, everywhere the board writes them (D12).
+ *
+ * @property lane - A lane (`Lane`)
+ * @property arrival - What the board books from (`Arrival`)
+ * @property resource - A resource (`Resource`)
+ * @property quantity - The quantity's heading word (`QTY`)
+ */
+export declare const AllocationLabelsType: StructType<{
+    readonly lane: StructType<{
+        readonly one: StringType;
+        readonly other: StringType;
+        readonly article: StringType;
+    }>;
+    readonly arrival: StructType<{
+        readonly one: StringType;
+        readonly other: StringType;
+        readonly article: StringType;
+    }>;
+    readonly resource: StructType<{
+        readonly one: StringType;
+        readonly other: StringType;
+        readonly article: StringType;
+    }>;
+    readonly quantity: StringType;
+}>;
+/** Type representing {@link AllocationLabelsType}. */
+export type AllocationLabelsType = typeof AllocationLabelsType;
+/**
+ * One of the Table's time bands: it runs from its hour to the next band's, the last to midnight.
+ *
+ * @property from - Its first hour of the day, `0 ≤ from < 24` (a fraction is minutes: `7.5` is 07:30)
+ * @property label - Its heading; `none`, its hours (`06:00–12:00`)
+ */
+export declare const AllocationBandType: StructType<{
+    readonly from: FloatType;
+    readonly label: OptionType<StringType>;
+}>;
+/** Type representing {@link AllocationBandType}. */
+export type AllocationBandType = typeof AllocationBandType;
+/**
+ * The Table's options.
+ *
+ * @property bands - Its time bands, the first from 00:00, each later than the one before
+ */
+export declare const AllocationTableOptionsType: StructType<{
+    readonly bands: ArrayType<StructType<{
+        readonly from: FloatType;
+        readonly label: OptionType<StringType>;
+    }>>;
+}>;
+/** Type representing {@link AllocationTableOptionsType}. */
+export type AllocationTableOptionsType = typeof AllocationTableOptionsType;
+/**
+ * The board's settings.
+ *
+ * @property layout - The first layout
+ * @property date - The first day; today when `none`
+ * @property horizon - The Timeline's resource axis around the day
+ * @property title - The summary's heading
+ * @property readOnly - No edits; a published day is always read-only
+ */
+export declare const AllocationSettingsType: StructType<{
+    readonly layout: VariantType<{
+        readonly timeline: NullType;
+        readonly table: NullType;
+    }>;
+    readonly date: OptionType<DateTimeType>;
+    readonly horizon: StructType<{
+        readonly before: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly after: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+    }>;
+    readonly title: StringType;
+    readonly readOnly: BooleanType;
+}>;
+/** Type representing {@link AllocationSettingsType}. */
+export type AllocationSettingsType = typeof AllocationSettingsType;
+/**
+ * The closed renderer payload (`Builder Interfaces Spec.md` §6). BuilderFrame
+ * is internal to the renderer.
+ *
+ * @property bin - The bin kind: the app's bins read and written through their roles, over bytes at the row type — its `unit` the quantity's, its `values` the fields no role maps
+ * @property lanes - Every lane, in order, from the lanes' resource kind's accessors
+ * @property every - The slot spacing
+ * @property resources - Every resource, from the resources' kind's accessors: the calculation scope, whatever the slice shows
+ * @property arrivals - Every arrival the day may book, from `Allocation.arrivals`' accessors
+ * @property initial - A booked bin's own fields, by its arrival's key, as bytes at the bin kind's `values`: what its `create` takes; `none`, their types' defaults
+ * @property periods - The app's days: their status, and Publish; `none`, no status chip and no Publish
+ * @property narrowed - Each narrowed source's keys, paged through its part of `slice`: the lanes, the resources and the arrivals that show
+ * @property fit - The app's fit, by its `e3.function`'s name
+ * @property check - The app's issues, from a `CheckContext(R)` as bytes
+ * @property columns - The app's bin fields as columns and inspector rows
+ * @property rules - The built-in rules
+ * @property library - The library's tabs, in order
+ * @property inspector - Whether the inspector pane shows: the bin kind's own `inspector`, or its form over `fields`, draws in it
+ * @property slice - The narrowing's chrome: a Slice over the bins', the lanes', the resources' and the arrivals' records, one rail
+ * @property settings - The board's settings
+ * @property id - Storage keys and drag-source ids
+ * @property labels - The board's nouns
+ * @property table - The Table's options
+ */
+export declare const AllocationPayloadType: StructType<{
+    readonly bin: 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: import("@elaraai/east").IntegerType;
+                    readonly minute: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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, import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly due: OptionType<DateTimeType>;
+            }>>>>;
+            readonly unscheduled: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                            readonly field: OptionType<StringType>;
+                            readonly message: StringType;
+                        }>>;
+                        readonly conflict: ArrayType<StructType<{
+                            readonly entry: StringType;
+                            readonly row: OptionType<import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                            readonly field: OptionType<StringType>;
+                            readonly message: StringType;
+                        }>>;
+                        readonly conflict: ArrayType<StructType<{
+                            readonly entry: StringType;
+                            readonly row: OptionType<import("@elaraai/east").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>;
+            }>>>>;
+            readonly event: FunctionType<[StringType, import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                    readonly due: OptionType<DateTimeType>;
+                }>;
+                readonly row: BlobType;
+            }>>>;
+            readonly schedule: StructType<{
+                readonly title: StringType;
+                readonly start: StringType;
+                readonly end: StringType;
+                readonly resource: OptionType<StringType>;
+                readonly status: OptionType<StringType>;
+            }>;
+            readonly overlaps: VariantType<{
+                readonly warn: NullType;
+                readonly allow: NullType;
+            }>;
+            readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+        }>;
+        readonly rows: FunctionType<[DateTimeType, DateTimeType], OptionType<import("@elaraai/east").DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly at: DateTimeType;
+                readonly lane: StringType;
+                readonly arrival: OptionType<StringType>;
+                readonly quantity: FloatType;
+                readonly parts: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").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 lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly offset: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+    }>>;
+    readonly every: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly resources: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly group: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly note: OptionType<StringType>;
+        readonly min: FloatType;
+        readonly max: FloatType;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly jobs: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+        }>>;
+    }>>;
+    readonly arrivals: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+        readonly due: OptionType<DateTimeType>;
+        readonly window: OptionType<StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>>;
+        readonly details: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: StringType;
+        }>>;
+    }>>;
+    readonly initial: FunctionType<[StringType], OptionType<BlobType>>;
+    readonly periods: OptionType<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: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<import("@elaraai/east").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<import("@elaraai/east").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], import("@elaraai/east").SetType<StringType>>;
+        readonly dismiss: FunctionType<[OptionType<BlobType>, import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").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 narrowed: StructType<{
+        readonly lanes: OptionType<RowSourceType<ArrayType<StringType>>>;
+        readonly resources: OptionType<RowSourceType<ArrayType<StringType>>>;
+        readonly arrivals: OptionType<RowSourceType<ArrayType<StringType>>>;
+    }>;
+    readonly fit: StructType<{
+        readonly name: StringType;
+    }>;
+    readonly check: OptionType<FunctionType<[BlobType], ArrayType<StructType<{
+        readonly kind: VariantType<{
+            readonly unlinked: NullType;
+            readonly unallocated: NullType;
+            readonly over: NullType;
+            readonly under: NullType;
+            readonly overlap: NullType;
+            readonly custom: StringType;
+        }>;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly title: StringType;
+        readonly detail: StringType;
+        readonly bin: OptionType<StringType>;
+        readonly resource: OptionType<StringType>;
+        readonly flag: OptionType<StringType>;
+        readonly fix: OptionType<VariantType<{
+            readonly choose: NullType;
+            readonly move: StringType;
+            readonly find: NullType;
+        }>>;
+    }>>>>;
+    readonly columns: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly text: FunctionType<[BlobType], StringType>;
+        readonly tone: OptionType<FunctionType<[BlobType], OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>>>;
+        readonly table: BooleanType;
+    }>>;
+    readonly rules: StructType<{
+        readonly under: BooleanType;
+    }>;
+    readonly library: ArrayType<VariantType<{
+        readonly arrivals: NullType;
+        readonly resources: NullType;
+    }>>;
+    readonly inspector: BooleanType;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: import("@elaraai/east").StringType;
+            readonly parts: ArrayType<StructType<{
+                readonly source: import("@elaraai/east").StringType;
+                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly icon: OptionType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly prefix: import("@elaraai/east").StringType;
+                    readonly label: OptionType<import("@elaraai/east").StringType>;
+                    readonly style: OptionType<StructType<{
+                        readonly size: OptionType<VariantType<{
+                            readonly xs: NullType;
+                            readonly sm: NullType;
+                            readonly md: NullType;
+                            readonly lg: NullType;
+                            readonly xl: NullType;
+                            readonly "2xl": NullType;
+                        }>>;
+                        readonly variant: OptionType<VariantType<{
+                            readonly solid: NullType;
+                        }>>;
+                        readonly color: OptionType<import("@elaraai/east").StringType>;
+                        readonly background: OptionType<import("@elaraai/east").StringType>;
+                        readonly colorPalette: OptionType<VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                        readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
+                        readonly overflow: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowX: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowY: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly width: OptionType<import("@elaraai/east").StringType>;
+                        readonly height: OptionType<import("@elaraai/east").StringType>;
+                        readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly padding: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
+                        readonly margin: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
+                    }>>;
+                }>>;
+                readonly slice: StructType<{
+                    readonly key: import("@elaraai/east").StringType;
+                    readonly config: StructType<{
+                        readonly fields: ArrayType<StructType<{
+                            readonly fieldId: import("@elaraai/east").StringType;
+                            readonly label: import("@elaraai/east").StringType;
+                            readonly kind: import("@elaraai/east").StringType;
+                            readonly optional: import("@elaraai/east").BooleanType;
+                            readonly multiple: import("@elaraai/east").BooleanType;
+                            readonly set: import("@elaraai/east").BooleanType;
+                            readonly values: ArrayType<StructType<{
+                                readonly value: import("@elaraai/east").StringType;
+                                readonly label: import("@elaraai/east").StringType;
+                            }>>;
+                            readonly format: OptionType<VariantType<{
+                                readonly number: NullType;
+                                readonly currency: StructType<{
+                                    readonly code: import("@elaraai/east").StringType;
+                                    readonly compact: import("@elaraai/east").BooleanType;
+                                }>;
+                                readonly percent: NullType;
+                                readonly compact: NullType;
+                                readonly date: import("@elaraai/east").StringType;
+                                readonly time: import("@elaraai/east").StringType;
+                                readonly datetime: import("@elaraai/east").StringType;
+                            }>>;
+                        }>>;
+                        readonly indexes: ArrayType<StructType<{
+                            readonly name: import("@elaraai/east").StringType;
+                            readonly fields: ArrayType<import("@elaraai/east").StringType>;
+                            readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                            readonly structured: import("@elaraai/east").BooleanType;
+                            readonly interval: OptionType<StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                            }>>;
+                        }>>;
+                        readonly range: OptionType<import("@elaraai/east").StringType>;
+                        readonly search: ArrayType<import("@elaraai/east").StringType>;
+                        readonly presets: ArrayType<StructType<{
+                            readonly id: import("@elaraai/east").StringType;
+                            readonly name: import("@elaraai/east").StringType;
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                readonly range: StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                }>;
+                                readonly prefix: import("@elaraai/east").StringType;
+                            }>>;
+                        }>>;
+                    }>;
+                    readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                        readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                            }>;
+                            readonly prefix: import("@elaraai/east").StringType;
+                        }>>;
+                        readonly preset: OptionType<import("@elaraai/east").StringType>;
+                        readonly resolution: OptionType<VariantType<{
+                            readonly auto: NullType;
+                            readonly hour: NullType;
+                            readonly day: NullType;
+                            readonly week: NullType;
+                            readonly month: NullType;
+                            readonly quarter: NullType;
+                            readonly year: NullType;
+                        }>>;
+                    }>>;
+                    readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                        readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                            }>;
+                            readonly prefix: import("@elaraai/east").StringType;
+                        }>>;
+                        readonly preset: OptionType<import("@elaraai/east").StringType>;
+                        readonly resolution: OptionType<VariantType<{
+                            readonly auto: NullType;
+                            readonly hour: NullType;
+                            readonly day: NullType;
+                            readonly week: NullType;
+                            readonly month: NullType;
+                            readonly quarter: NullType;
+                            readonly year: NullType;
+                        }>>;
+                    }>], NullType>;
+                    readonly choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
+                    readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+                    readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+                    readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+                    readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+                    readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+                    readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>], OptionType<import("@elaraai/east").IntegerType>>;
+                    readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+                    readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>>>;
+                    readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                        readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                        readonly selected: import("@elaraai/east").BooleanType;
+                        readonly error: OptionType<import("@elaraai/east").StringType>;
+                    }>>>;
+                    readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                        readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                        readonly selected: import("@elaraai/east").BooleanType;
+                        readonly error: OptionType<import("@elaraai/east").StringType>;
+                    }>>>>;
+                    readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
+                    readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+                    readonly setResolution: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                        readonly auto: NullType;
+                        readonly hour: NullType;
+                        readonly day: NullType;
+                        readonly week: NullType;
+                        readonly month: NullType;
+                        readonly quarter: NullType;
+                        readonly year: NullType;
+                    }>>], NullType>;
+                    readonly retry: import("@elaraai/east").FunctionType<[], NullType>;
+                    readonly sourceId: import("@elaraai/east").StringType;
+                    readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
+                    readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+                    readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").BooleanType>>;
+                }>;
+            }>>;
+            readonly presets: ArrayType<StructType<{
+                readonly id: import("@elaraai/east").StringType;
+                readonly name: import("@elaraai/east").StringType;
+            }>>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+        }>;
+        readonly affordances: ArrayType<VariantType<{
+            readonly fields: NullType;
+            readonly search: NullType;
+            readonly range: NullType;
+            readonly presets: NullType;
+            readonly resolution: NullType;
+            readonly brush: NullType;
+            readonly summary: NullType;
+        }>>;
+        readonly persist: OptionType<VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
+    }>>;
+    readonly settings: StructType<{
+        readonly layout: VariantType<{
+            readonly timeline: NullType;
+            readonly table: NullType;
+        }>;
+        readonly date: OptionType<DateTimeType>;
+        readonly horizon: StructType<{
+            readonly before: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly after: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+        }>;
+        readonly title: StringType;
+        readonly readOnly: BooleanType;
+    }>;
+    readonly id: OptionType<StringType>;
+    readonly labels: StructType<{
+        readonly lane: StructType<{
+            readonly one: StringType;
+            readonly other: StringType;
+            readonly article: StringType;
+        }>;
+        readonly arrival: StructType<{
+            readonly one: StringType;
+            readonly other: StringType;
+            readonly article: StringType;
+        }>;
+        readonly resource: StructType<{
+            readonly one: StringType;
+            readonly other: StringType;
+            readonly article: StringType;
+        }>;
+        readonly quantity: StringType;
+    }>;
+    readonly table: StructType<{
+        readonly bands: ArrayType<StructType<{
+            readonly from: FloatType;
+            readonly label: OptionType<StringType>;
+        }>>;
+    }>;
+}>;
+/** Type representing {@link AllocationPayloadType}. */
+export type AllocationPayloadType = typeof AllocationPayloadType;
+/** Carrier registered by e3-ui-components. */
+export declare const AllocationComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
+    readonly bin: 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: import("@elaraai/east").IntegerType;
+                    readonly minute: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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, import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly due: OptionType<DateTimeType>;
+            }>>>>;
+            readonly unscheduled: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                            readonly field: OptionType<StringType>;
+                            readonly message: StringType;
+                        }>>;
+                        readonly conflict: ArrayType<StructType<{
+                            readonly entry: StringType;
+                            readonly row: OptionType<import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                            readonly field: OptionType<StringType>;
+                            readonly message: StringType;
+                        }>>;
+                        readonly conflict: ArrayType<StructType<{
+                            readonly entry: StringType;
+                            readonly row: OptionType<import("@elaraai/east").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>;
+            }>>>>;
+            readonly event: FunctionType<[StringType, import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                    readonly due: OptionType<DateTimeType>;
+                }>;
+                readonly row: BlobType;
+            }>>>;
+            readonly schedule: StructType<{
+                readonly title: StringType;
+                readonly start: StringType;
+                readonly end: StringType;
+                readonly resource: OptionType<StringType>;
+                readonly status: OptionType<StringType>;
+            }>;
+            readonly overlaps: VariantType<{
+                readonly warn: NullType;
+                readonly allow: NullType;
+            }>;
+            readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+        }>;
+        readonly rows: FunctionType<[DateTimeType, DateTimeType], OptionType<import("@elaraai/east").DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly at: DateTimeType;
+                readonly lane: StringType;
+                readonly arrival: OptionType<StringType>;
+                readonly quantity: FloatType;
+                readonly parts: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").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 lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly offset: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+    }>>;
+    readonly every: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly resources: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly group: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly note: OptionType<StringType>;
+        readonly min: FloatType;
+        readonly max: FloatType;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly jobs: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+        }>>;
+    }>>;
+    readonly arrivals: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly hold: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+        readonly due: OptionType<DateTimeType>;
+        readonly window: OptionType<StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>>;
+        readonly details: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: StringType;
+        }>>;
+    }>>;
+    readonly initial: FunctionType<[StringType], OptionType<BlobType>>;
+    readonly periods: OptionType<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: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<import("@elaraai/east").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<import("@elaraai/east").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], import("@elaraai/east").SetType<StringType>>;
+        readonly dismiss: FunctionType<[OptionType<BlobType>, import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").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 narrowed: StructType<{
+        readonly lanes: OptionType<RowSourceType<ArrayType<StringType>>>;
+        readonly resources: OptionType<RowSourceType<ArrayType<StringType>>>;
+        readonly arrivals: OptionType<RowSourceType<ArrayType<StringType>>>;
+    }>;
+    readonly fit: StructType<{
+        readonly name: StringType;
+    }>;
+    readonly check: OptionType<FunctionType<[BlobType], ArrayType<StructType<{
+        readonly kind: VariantType<{
+            readonly unlinked: NullType;
+            readonly unallocated: NullType;
+            readonly over: NullType;
+            readonly under: NullType;
+            readonly overlap: NullType;
+            readonly custom: StringType;
+        }>;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly title: StringType;
+        readonly detail: StringType;
+        readonly bin: OptionType<StringType>;
+        readonly resource: OptionType<StringType>;
+        readonly flag: OptionType<StringType>;
+        readonly fix: OptionType<VariantType<{
+            readonly choose: NullType;
+            readonly move: StringType;
+            readonly find: NullType;
+        }>>;
+    }>>>>;
+    readonly columns: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly text: FunctionType<[BlobType], StringType>;
+        readonly tone: OptionType<FunctionType<[BlobType], OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>>>;
+        readonly table: BooleanType;
+    }>>;
+    readonly rules: StructType<{
+        readonly under: BooleanType;
+    }>;
+    readonly library: ArrayType<VariantType<{
+        readonly arrivals: NullType;
+        readonly resources: NullType;
+    }>>;
+    readonly inspector: BooleanType;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: import("@elaraai/east").StringType;
+            readonly parts: ArrayType<StructType<{
+                readonly source: import("@elaraai/east").StringType;
+                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly icon: OptionType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly prefix: import("@elaraai/east").StringType;
+                    readonly label: OptionType<import("@elaraai/east").StringType>;
+                    readonly style: OptionType<StructType<{
+                        readonly size: OptionType<VariantType<{
+                            readonly xs: NullType;
+                            readonly sm: NullType;
+                            readonly md: NullType;
+                            readonly lg: NullType;
+                            readonly xl: NullType;
+                            readonly "2xl": NullType;
+                        }>>;
+                        readonly variant: OptionType<VariantType<{
+                            readonly solid: NullType;
+                        }>>;
+                        readonly color: OptionType<import("@elaraai/east").StringType>;
+                        readonly background: OptionType<import("@elaraai/east").StringType>;
+                        readonly colorPalette: OptionType<VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                        readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
+                        readonly overflow: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowX: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowY: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly width: OptionType<import("@elaraai/east").StringType>;
+                        readonly height: OptionType<import("@elaraai/east").StringType>;
+                        readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly padding: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
+                        readonly margin: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
+                    }>>;
+                }>>;
+                readonly slice: StructType<{
+                    readonly key: import("@elaraai/east").StringType;
+                    readonly config: StructType<{
+                        readonly fields: ArrayType<StructType<{
+                            readonly fieldId: import("@elaraai/east").StringType;
+                            readonly label: import("@elaraai/east").StringType;
+                            readonly kind: import("@elaraai/east").StringType;
+                            readonly optional: import("@elaraai/east").BooleanType;
+                            readonly multiple: import("@elaraai/east").BooleanType;
+                            readonly set: import("@elaraai/east").BooleanType;
+                            readonly values: ArrayType<StructType<{
+                                readonly value: import("@elaraai/east").StringType;
+                                readonly label: import("@elaraai/east").StringType;
+                            }>>;
+                            readonly format: OptionType<VariantType<{
+                                readonly number: NullType;
+                                readonly currency: StructType<{
+                                    readonly code: import("@elaraai/east").StringType;
+                                    readonly compact: import("@elaraai/east").BooleanType;
+                                }>;
+                                readonly percent: NullType;
+                                readonly compact: NullType;
+                                readonly date: import("@elaraai/east").StringType;
+                                readonly time: import("@elaraai/east").StringType;
+                                readonly datetime: import("@elaraai/east").StringType;
+                            }>>;
+                        }>>;
+                        readonly indexes: ArrayType<StructType<{
+                            readonly name: import("@elaraai/east").StringType;
+                            readonly fields: ArrayType<import("@elaraai/east").StringType>;
+                            readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                            readonly structured: import("@elaraai/east").BooleanType;
+                            readonly interval: OptionType<StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                            }>>;
+                        }>>;
+                        readonly range: OptionType<import("@elaraai/east").StringType>;
+                        readonly search: ArrayType<import("@elaraai/east").StringType>;
+                        readonly presets: ArrayType<StructType<{
+                            readonly id: import("@elaraai/east").StringType;
+                            readonly name: import("@elaraai/east").StringType;
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                                readonly range: StructType<{
+                                    readonly from: import("@elaraai/east").StringType;
+                                    readonly to: import("@elaraai/east").StringType;
+                                }>;
+                                readonly prefix: import("@elaraai/east").StringType;
+                            }>>;
+                        }>>;
+                    }>;
+                    readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                        readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                            }>;
+                            readonly prefix: import("@elaraai/east").StringType;
+                        }>>;
+                        readonly preset: OptionType<import("@elaraai/east").StringType>;
+                        readonly resolution: OptionType<VariantType<{
+                            readonly auto: NullType;
+                            readonly hour: NullType;
+                            readonly day: NullType;
+                            readonly week: NullType;
+                            readonly month: NullType;
+                            readonly quarter: NullType;
+                            readonly year: NullType;
+                        }>>;
+                    }>>;
+                    readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                        readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
+                            }>;
+                            readonly prefix: import("@elaraai/east").StringType;
+                        }>>;
+                        readonly preset: OptionType<import("@elaraai/east").StringType>;
+                        readonly resolution: OptionType<VariantType<{
+                            readonly auto: NullType;
+                            readonly hour: NullType;
+                            readonly day: NullType;
+                            readonly week: NullType;
+                            readonly month: NullType;
+                            readonly quarter: NullType;
+                            readonly year: NullType;
+                        }>>;
+                    }>], NullType>;
+                    readonly choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
+                    readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+                    readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+                    readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+                    readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+                    readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+                    readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>], OptionType<import("@elaraai/east").IntegerType>>;
+                    readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+                    readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>>>;
+                    readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                        readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                        readonly selected: import("@elaraai/east").BooleanType;
+                        readonly error: OptionType<import("@elaraai/east").StringType>;
+                    }>>>;
+                    readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                        readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                        readonly selected: import("@elaraai/east").BooleanType;
+                        readonly error: OptionType<import("@elaraai/east").StringType>;
+                    }>>>>;
+                    readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
+                    readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+                    readonly setResolution: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                        readonly auto: NullType;
+                        readonly hour: NullType;
+                        readonly day: NullType;
+                        readonly week: NullType;
+                        readonly month: NullType;
+                        readonly quarter: NullType;
+                        readonly year: NullType;
+                    }>>], NullType>;
+                    readonly retry: import("@elaraai/east").FunctionType<[], NullType>;
+                    readonly sourceId: import("@elaraai/east").StringType;
+                    readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
+                    readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+                    readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").BooleanType>>;
+                }>;
+            }>>;
+            readonly presets: ArrayType<StructType<{
+                readonly id: import("@elaraai/east").StringType;
+                readonly name: import("@elaraai/east").StringType;
+            }>>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+        }>;
+        readonly affordances: ArrayType<VariantType<{
+            readonly fields: NullType;
+            readonly search: NullType;
+            readonly range: NullType;
+            readonly presets: NullType;
+            readonly resolution: NullType;
+            readonly brush: NullType;
+            readonly summary: NullType;
+        }>>;
+        readonly persist: OptionType<VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
+    }>>;
+    readonly settings: StructType<{
+        readonly layout: VariantType<{
+            readonly timeline: NullType;
+            readonly table: NullType;
+        }>;
+        readonly date: OptionType<DateTimeType>;
+        readonly horizon: StructType<{
+            readonly before: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+            readonly after: VariantType<{
+                readonly minutes: FloatType;
+                readonly hours: FloatType;
+                readonly days: FloatType;
+                readonly weeks: FloatType;
+                readonly months: FloatType;
+            }>;
+        }>;
+        readonly title: StringType;
+        readonly readOnly: BooleanType;
+    }>;
+    readonly id: OptionType<StringType>;
+    readonly labels: StructType<{
+        readonly lane: StructType<{
+            readonly one: StringType;
+            readonly other: StringType;
+            readonly article: StringType;
+        }>;
+        readonly arrival: StructType<{
+            readonly one: StringType;
+            readonly other: StringType;
+            readonly article: StringType;
+        }>;
+        readonly resource: StructType<{
+            readonly one: StringType;
+            readonly other: StringType;
+            readonly article: StringType;
+        }>;
+        readonly quantity: StringType;
+    }>;
+    readonly table: StructType<{
+        readonly bands: ArrayType<StructType<{
+            readonly from: FloatType;
+            readonly label: OptionType<StringType>;
+        }>>;
+    }>;
+}>>;
+/**
+ * One of the board's nouns: the singular as a heading writes it (`Bay`), or with
+ * its plural and article when they aren't regular. The plural defaults to the
+ * singular and `s`; the article to `an` before a vowel letter, else `a`.
+ */
+export type AllocationNoun = string | {
+    one: string;
+    other?: string;
+    article?: "a" | "an";
+};
+/** A library tab declaration. Omit the library to omit its pane. */
+export type AllocationLibraryDeclaration = {
+    readonly kind: "arrivals" | "resources";
+};
+/**
+ * One of the app's bin fields shown as a column.
+ *
+ * @typeParam R - The app's bin row type
+ */
+export interface AllocationColumn<R extends EastType> {
+    /** Its key, unique among the columns. */
+    key: string;
+    /** Its heading. */
+    label: string;
+    /** Its text from the bin's row. */
+    text: (row: ExprType<R>) => SubtypeExprOrValue<StringType>;
+    /** Its tone from the row: `some(variant("warning", null))` draws it in warning text. */
+    tone?: (row: ExprType<R>) => SubtypeExprOrValue<OptionType<typeof StatusTokenType>>;
+    /** Whether the Table shows it; `false` shows it in the inspector only. True by default. */
+    table?: boolean;
+}
+/**
+ * The `<Allocation>` props (§6.1).
+ *
+ * @typeParam R - The app's bin row type: the bin kind's row
+ */
+export interface AllocationProps<R extends EastType = EastType> {
+    /**
+     * Exactly one event kind, the bins, an instant kind keyed by String: `{ bin: Schedule.events(Record.bind(bins, [binsPatch]),
+     * { at, resource, arrival, quantity, parts, hold, kind? }) }`.
+     */
+    events: Readonly<Record<string, ScheduleEventKind<EastType, R>>>;
+    /**
+     * The lanes' kind, under the slot the bin kind's `resource.of` names, and the resources' kind, under the slot its `parts.of`
+     * names — `{ bays: Schedule.resources(rows, { name, icon, label, offset? }), kilns: Schedule.resources(rows, { name, icon,
+     * label, min, max, … }) }` — each read whole and keyed by String. Fits, checks and totals read every one.
+     */
+    resources: Readonly<Record<string, ScheduleResourceKind<EastType, EastType>>>;
+    /** Every arrival the day may book: `Allocation.arrivals(rows, { label, quantity, hold, … })` over the app's rows. */
+    arrivals: AllocationArrivals;
+    /** What the board publishes, the app's days: `Schedule.periods(Record.bind(days, [daysPatch]), { every: "day", status })`. Omitted, no Publish. */
+    periods?: SchedulePeriods;
+    /** The fit: `Func.bind` of the app's `e3.function` from `Allocation.Types.FitRequest(R)` to `Allocation.Types.FitResult`. The board has no fit of its own. */
+    fit: BoundFunc<[T.AllocationFitRequestType<R>], T.AllocationFitResultType>;
+    /** The app's issues, after the built-in ones wherever issues show: an East function from `Allocation.Types.CheckContext(R)` to `Array<Allocation.Types.Issue>`. */
+    check?: SubtypeExprOrValue<FunctionType<[T.AllocationCheckContextType<R>], ArrayType<T.AllocationIssueType>>>;
+    /** The app's bin fields as Table columns (after Quantity) and inspector rows, over the bin's row. */
+    columns?: readonly AllocationColumn<R>[];
+    /** The slot spacing for every lane; an hour by default. */
+    every?: SubtypeExprOrValue<TimeStepType>;
+    /**
+     * The narrowing: one `Slice.bindRecords`, a source per record it narrows — the bin kind's slot (its interval index from `at`
+     * to `at`, its `range` `"at"`, which the board's navigation writes; the kind given `entries`), the lanes' slot, the resources'
+     * slot and `arrivals` — one rail in both layouts. Each source narrows every place its rows appear, the Library's tabs
+     * included. Fits, checks and totals still read every lane, resource and arrival, and every bin of the day.
+     */
+    slice?: RecordSlicesChromeOptions;
+    /** The built-in rules: whether `Allocation.fit` and `Allocation.check` warn under min (true). */
+    rules?: {
+        under?: SubtypeExprOrValue<BooleanType>;
+    };
+    /** The library's tabs, in order: `Allocation.library.arrivals()`, `Allocation.library.resources()`. Omitted, no start pane. */
+    library?: readonly AllocationLibraryDeclaration[];
+    /** Shows the inspector pane: the bin kind's own `inspector`, or its form over `fields`, draws in it. */
+    inspector?: boolean;
+    /** The first view, then persisted under `id`. Today's date by default. */
+    view?: {
+        layout?: "timeline" | "table";
+        date?: SubtypeExprOrValue<DateTimeType>;
+    };
+    /** The Timeline's resource axis around the day; 3 days before and 10 after by default. */
+    horizon?: {
+        before?: SubtypeExprOrValue<TimeStepType>;
+        after?: SubtypeExprOrValue<TimeStepType>;
+    };
+    /** The summary's heading; `Allocation` by default. */
+    title?: string;
+    /** No edits; a published day is always read-only. */
+    readOnly?: SubtypeExprOrValue<BooleanType>;
+    /** Storage keys and drag-source ids, when a surface holds two boards. */
+    id?: string;
+    /**
+     * The board's nouns, everywhere it writes them: `{ lane: "Bay", arrival: "Load", resource: "Kiln" }`. Lane, Arrival and
+     * Resource by default; `quantity` is the quantity's heading word, `QTY` by default. Running text writes a noun in lower
+     * case unless it is written in capitals.
+     */
+    labels?: {
+        lane?: AllocationNoun;
+        arrival?: AllocationNoun;
+        resource?: AllocationNoun;
+        quantity?: string;
+    };
+    /**
+     * The Table's time bands: each runs from its hour to the next band's, the last to midnight — `[{ from: 0, label: "Night" },
+     * { from: 6, label: "Day" }, { from: 18 }]`. The first is from 0; each later than the one before; a band's heading is its
+     * hours unless labelled. Four by default: 00–06 · 06–12 · 12–18 · 18–24.
+     */
+    table?: {
+        bands?: readonly {
+            from: number;
+            label?: string;
+        }[];
+    };
+}
+/**
+ * The board's nouns, resolved (D12): each the app's, or Lane, Arrival and
+ * Resource, with its plural and article; the quantity's heading `QTY`.
+ *
+ * @param labels - The `labels` prop, if given
+ * @returns The nouns, as the payload carries them
+ * @throws {Error} For `labels.event`, which is gone, naming `labels.arrival`; and for a noun that is empty
+ * @internal
+ */
+export declare function allocationLabels(labels: AllocationProps["labels"]): ValueTypeOf<typeof AllocationLabelsType>;
+/**
+ * The Table's bands, checked: from 00:00, increasing, inside the day; four by
+ * default.
+ *
+ * @param bands - `table.bands`, if given
+ * @returns The bands, as the payload carries them
+ * @throws {Error} When there is none, the first is not from 0, one does not start after the one before, or one starts outside the day
+ * @internal
+ */
+export declare function allocationBands(bands: readonly {
+    from: number;
+    label?: string;
+}[] | undefined): ValueTypeOf<typeof AllocationBandType>[];
+/**
+ * Validates the declarations and assembles the Allocation's interface. View
+ * and interaction behaviour belong to the renderer, not this factory.
+ *
+ * @typeParam R - The app's bin row type
+ * @param props - The board's props
+ * @returns The closed payload
+ * @throws {Error} Naming the change to make (B4): a removed prop — `days`, `window`, `lanes`, `publish`, `quantity`,
+ *   `resources` as values, `inspector={{ bin }}` or `labels.event`; `events` holding other than one kind; a bin kind with
+ *   no lane (`resource`) or no `parts`, or whose slot, lanes' slot or resources' slot names a source of the slice twice;
+ *   `resources` holding other than the lanes' kind and the resources' kind, one read a window at a time, resources keyed
+ *   by anything but String, or a resources kind with no `min` or `max`; `arrivals` that is not `Allocation.arrivals`, and
+ *   its `values` returning another struct than the bin kind's own fields; `periods` that is not `Schedule.periods`; a
+ *   `fit` that is not `Func.bind` of a function from `FitRequest(R)` to `FitResult`, one over another row type naming
+ *   both; a `check` of another type; a library tab or a column key listed twice; a label that is empty; the Table's
+ *   bands not starting at 0 and rising within the day; and as `Schedule`'s checks, the bin kind's build
+ *   (`buildAllocation`) and the slice's (`recordSources`) do
+ * @internal
+ */
+export declare function createAllocationPayload<R extends EastType>(props: AllocationProps<R>): ExprType<typeof AllocationPayloadType>;
+/** Declares the Arrivals tab. */
+declare function allocationArrivalsTab(): AllocationLibraryDeclaration;
+/** Declares the Resources tab. */
+declare function allocationResourcesTab(): AllocationLibraryDeclaration;
+/** The tag, its declaration of the arrivals, its pure functions over the bin row type, and its types. */
+export interface AllocationNamespace {
+    /** Renders a board over the app's own records. */
+    <R extends EastType>(props: AllocationProps<R>): UIElement;
+    /** Declares what the board books from, the arrivals, from the app's keyed rows. */
+    arrivals: typeof allocationArrivals;
+    /** The built-in rules, one verdict per candidate. */
+    fit: typeof allocationFit;
+    /** `loads(R)`: every resource's load on the plan day. */
+    loads: typeof allocationLoads;
+    /** `candidates(R)`: a fit's candidates. */
+    candidates: typeof allocationCandidates;
+    /** `answer(R)`: a fit's answer from a fit per candidate. */
+    answer: typeof allocationAnswer;
+    /** `lookahead(R)`: a greedy look-ahead over a fit. */
+    lookahead: typeof allocationLookahead;
+    /** `check(R)`: the built-in checks. */
+    check: typeof allocationCheck;
+    /** `slots(R)`: the day's lane slots. */
+    slots: typeof allocationSlots;
+    /** Declares the library's tabs. */
+    library: {
+        arrivals: typeof allocationArrivalsTab;
+        resources: typeof allocationResourcesTab;
+        /** @deprecated Removed (#1371): the Arrivals tab is `Allocation.library.arrivals()`. */
+        events: (...args: never[]) => never;
+    };
+    /** @deprecated Removed (#1371): what the board books from is `arrivals={Allocation.arrivals(rows, { label, quantity, hold, … })}`. */
+    events: (...args: never[]) => never;
+    /** @deprecated Removed (#1371): the lanes are a `Schedule.resources` kind under the slot the bin kind's `resource` names. */
+    lanes: (...args: never[]) => never;
+    /** @deprecated Removed (#1371): the resources are a `Schedule.resources` kind under the slot the bin kind's `parts` name. */
+    resources: (...args: never[]) => never;
+    /** The Allocation's East types; those over a day are constructors of the app's bin row type. */
+    Types: {
+        Lane: typeof T.AllocationLaneType;
+        Status: typeof T.AllocationStatusType;
+        Bin: typeof T.AllocationBinTypeFor;
+        Day: typeof T.AllocationDayTypeFor;
+        Interval: typeof T.AllocationIntervalType;
+        Job: typeof T.AllocationJobType;
+        Detail: typeof T.AllocationDetailType;
+        Arrival: typeof T.AllocationArrivalType;
+        Resource: typeof T.AllocationResourceType;
+        Rules: typeof T.AllocationRulesType;
+        Context: typeof T.AllocationContextType;
+        LoadState: typeof T.AllocationLoadStateType;
+        Load: typeof T.AllocationLoadType;
+        Candidate: typeof T.AllocationCandidateType;
+        Refusal: typeof T.AllocationRefusalType;
+        Fit: typeof T.AllocationFitType;
+        FitAsk: typeof T.AllocationFitAskType;
+        FitRequest: typeof T.AllocationFitRequestTypeFor;
+        FitResult: typeof T.AllocationFitResultType;
+        Fix: typeof T.AllocationFixType;
+        IssueKind: typeof T.AllocationIssueKindType;
+        Issue: typeof T.AllocationIssueType;
+        CheckContext: typeof T.AllocationCheckContextTypeFor;
+        SlotStatus: typeof T.AllocationSlotStatusType;
+        Slot: typeof T.AllocationSlotType;
+        Layout: typeof T.AllocationLayoutType;
+    };
+}
+/**
+ * Books a day's arrivals into timed lane slots and allocates each bin to
+ * resources, over the app's own records, in an internal BuilderFrame.
+ *
+ * @param props - The bins, the lanes and resources, the arrivals and the fit, and the optional days, check, library, inspector and narrowing
+ * @returns The Allocation extension
+ * @remarks Every gesture is one undo step; Save sends each record's changes as its own request, and Publish saves, then the day's status. Issues never block either. Below 480px of main the same commands are explicit card actions.
+ */
+export declare const Allocation: AllocationNamespace;
+export {};
+//# sourceMappingURL=index.d.ts.map