@elaraai/e3-ui 1.0.86 → 1.0.87

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

@@ -0,0 +1,2923 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, BooleanType, DateTimeType, DictType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
+import { type UIElement } from "@elaraai/east-ui";
+import { SliceBindType, type RecordSliceChromeOptions, type SliceAffordanceLiteral } from "@elaraai/east-ui/internal";
+import { type ScheduleNamespace } from "../schedule/index.js";
+import type { ScheduleEventKind } from "../schedule/events.js";
+import type { ScheduleResourceKind } from "../schedule/resources.js";
+import { type ScheduleTabDeclaration, type ScheduleLibraryTabConfig } from "../schedule/library.js";
+import { ScheduleCandidateType, ScheduleEventRefType } from "../schedule/types.js";
+/** Calendar's layout: a time grid, resource columns or a horizontal timeline. */
+export declare const CalendarLayoutType: VariantType<{
+    readonly calendar: NullType;
+    readonly resources: NullType;
+    readonly timeline: NullType;
+}>;
+/** The stretch shown: a day, week or month. */
+export declare const CalendarPeriodType: VariantType<{
+    readonly day: NullType;
+    readonly week: NullType;
+    readonly month: NullType;
+}>;
+/** A viewer's layout, period and reference date. */
+export declare const CalendarViewType: StructType<{
+    readonly layout: VariantType<{
+        readonly calendar: NullType;
+        readonly resources: NullType;
+        readonly timeline: NullType;
+    }>;
+    readonly period: VariantType<{
+        readonly day: NullType;
+        readonly week: NullType;
+        readonly month: NullType;
+    }>;
+    readonly date: DateTimeType;
+}>;
+/** One library tab: templates, unscheduled events or author-defined cards. */
+export declare const CalendarLibraryTabType: VariantType<{
+    readonly templates: NullType;
+    readonly backlog: NullType;
+    readonly tab: StructType<{
+        readonly name: StringType;
+        readonly icon: OptionType<StringType>;
+        readonly drop: OptionType<StringType>;
+        readonly cards: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+            readonly group: OptionType<StringType>;
+            readonly sets: ArrayType<StructType<{
+                readonly path: ArrayType<StringType>;
+                readonly value: import("@elaraai/east").BlobType;
+            }>>;
+        }>>;
+    }>;
+}>;
+/** Initial view and working-time settings; every instant is shown in UTC. */
+export declare const CalendarSettingsType: StructType<{
+    readonly layout: VariantType<{
+        readonly calendar: NullType;
+        readonly resources: NullType;
+        readonly timeline: NullType;
+    }>;
+    readonly period: VariantType<{
+        readonly day: NullType;
+        readonly week: NullType;
+        readonly month: NullType;
+    }>;
+    readonly date: OptionType<DateTimeType>;
+    readonly hours: StructType<{
+        readonly from: IntegerType;
+        readonly to: IntegerType;
+    }>;
+    readonly weekStart: VariantType<{
+        readonly monday: NullType;
+        readonly sunday: NullType;
+    }>;
+    readonly weekends: BooleanType;
+    readonly density: VariantType<{
+        readonly compact: NullType;
+        readonly comfortable: NullType;
+        readonly spacious: NullType;
+    }>;
+    readonly now: OptionType<DateTimeType>;
+    readonly readOnly: BooleanType;
+}>;
+/** Calendar's closed interface to its React renderer. The frame is a renderer detail. */
+export declare const CalendarPayloadType: StructType<{
+    readonly events: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly icon: StringType;
+        readonly takes: ArrayType<StringType>;
+        readonly status: ArrayType<StructType<{
+            readonly case: StringType;
+            readonly status: StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>;
+        }>>;
+        readonly backlog: BooleanType;
+        readonly templates: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: OptionType<StringType>;
+            readonly at: OptionType<StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>>;
+            readonly duration: VariantType<{
+                readonly minutes: import("@elaraai/east").FloatType;
+                readonly hours: import("@elaraai/east").FloatType;
+                readonly days: import("@elaraai/east").FloatType;
+                readonly weeks: import("@elaraai/east").FloatType;
+                readonly months: import("@elaraai/east").FloatType;
+            }>;
+            readonly values: import("@elaraai/east").BlobType;
+        }>>;
+        readonly fields: ArrayType<StructType<{
+            readonly path: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly help: OptionType<StringType>;
+            readonly group: OptionType<StringType>;
+            readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly optional: BooleanType;
+            readonly editor: VariantType<{
+                readonly text: StructType<{
+                    readonly placeholder: OptionType<StringType>;
+                }>;
+                readonly number: StructType<{
+                    readonly unit: OptionType<StringType>;
+                    readonly step: OptionType<import("@elaraai/east").FloatType>;
+                    readonly min: OptionType<import("@elaraai/east").FloatType>;
+                    readonly max: OptionType<import("@elaraai/east").FloatType>;
+                }>;
+                readonly checkbox: NullType;
+                readonly datetime: StructType<{
+                    readonly precision: OptionType<VariantType<{
+                        readonly date: NullType;
+                        readonly time: NullType;
+                        readonly datetime: NullType;
+                    }>>;
+                }>;
+                readonly select: ArrayType<StructType<{
+                    readonly case: StringType;
+                    readonly label: StringType;
+                }>>;
+                readonly tags: StructType<{
+                    readonly options: ArrayType<StringType>;
+                }>;
+                readonly checklist: StructType<{
+                    readonly text: StringType;
+                    readonly done: StringType;
+                }>;
+                readonly reference: StructType<{
+                    readonly of: StringType;
+                }>;
+                readonly readonly: NullType;
+            }>;
+        }>>;
+        readonly items: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>>>>;
+        readonly unscheduled: FunctionType<[DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>>>>;
+        readonly write: FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly entry: import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").BlobType>>>;
+        readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly entry: import("@elaraai/east").BlobType;
+        }>>], ArrayType<VariantType<{
+            readonly ready: NullType;
+            readonly incomplete: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+            readonly invalid: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+        }>>>>;
+        readonly editing: StructType<{
+            sourceId: StringType;
+            entryType: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            idField: OptionType<StringType>;
+            draftType: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            children: OptionType<StringType>;
+            keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>>;
+            snapshot: OptionType<import("@elaraai/east").BlobType>;
+            readEntry: FunctionType<[StringType, IntegerType], OptionType<import("@elaraai/east").BlobType>>;
+            onPatch: OptionType<FunctionType<[import("@elaraai/east").BlobType], NullType>>;
+            onApply: OptionType<VariantType<{
+                readonly sync: FunctionType<[import("@elaraai/east").BlobType], VariantType<{
+                    readonly applied: StructType<{
+                        readonly revision: OptionType<StringType>;
+                    }>;
+                    readonly rejected: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                }>>;
+                readonly async: import("@elaraai/east").AsyncFunctionType<[import("@elaraai/east").BlobType], VariantType<{
+                    readonly applied: StructType<{
+                        readonly revision: OptionType<StringType>;
+                    }>;
+                    readonly rejected: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                }>>;
+            }>>;
+            mode: VariantType<{
+                readonly batch: NullType;
+                readonly auto: NullType;
+            }>;
+        }>;
+        readonly entries: OptionType<StructType<{
+            readonly revision: FunctionType<[], OptionType<StringType>>;
+            readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+            readonly entry: FunctionType<[StringType], OptionType<OptionType<import("@elaraai/east").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, DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+            readonly item: StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly resource: OptionType<StructType<{
+                    readonly kind: StringType;
+                    readonly key: StringType;
+                }>>;
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly minutes: IntegerType;
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            readonly row: import("@elaraai/east").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<[import("@elaraai/east").BlobType, FunctionType<[import("@elaraai/east").BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    }>>;
+    readonly resources: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly icon: StringType;
+        readonly rows: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly settings: StructType<{
+        readonly layout: VariantType<{
+            readonly calendar: NullType;
+            readonly resources: NullType;
+            readonly timeline: NullType;
+        }>;
+        readonly period: VariantType<{
+            readonly day: NullType;
+            readonly week: NullType;
+            readonly month: NullType;
+        }>;
+        readonly date: OptionType<DateTimeType>;
+        readonly hours: StructType<{
+            readonly from: IntegerType;
+            readonly to: IntegerType;
+        }>;
+        readonly weekStart: VariantType<{
+            readonly monday: NullType;
+            readonly sunday: NullType;
+        }>;
+        readonly weekends: BooleanType;
+        readonly density: VariantType<{
+            readonly compact: NullType;
+            readonly comfortable: NullType;
+            readonly spacious: NullType;
+        }>;
+        readonly now: OptionType<DateTimeType>;
+        readonly readOnly: BooleanType;
+    }>;
+    readonly library: ArrayType<VariantType<{
+        readonly templates: NullType;
+        readonly backlog: NullType;
+        readonly tab: StructType<{
+            readonly name: StringType;
+            readonly icon: OptionType<StringType>;
+            readonly drop: OptionType<StringType>;
+            readonly cards: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+                readonly group: OptionType<StringType>;
+                readonly sets: ArrayType<StructType<{
+                    readonly path: ArrayType<StringType>;
+                    readonly value: import("@elaraai/east").BlobType;
+                }>>;
+            }>>;
+        }>;
+    }>>;
+    readonly inspector: BooleanType;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: StringType;
+            readonly read: FunctionType<[], StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: import("@elaraai/east").FloatType;
+                        readonly to: import("@elaraai/east").FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: import("@elaraai/east").FloatType;
+                                readonly lte: import("@elaraai/east").FloatType;
+                                readonly gt: import("@elaraai/east").FloatType;
+                                readonly gte: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<IntegerType>;
+                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: FunctionType<[StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: import("@elaraai/east").FloatType;
+                        readonly to: import("@elaraai/east").FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: import("@elaraai/east").FloatType;
+                                readonly lte: import("@elaraai/east").FloatType;
+                                readonly gt: import("@elaraai/east").FloatType;
+                                readonly gte: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<IntegerType>;
+                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 setRange: FunctionType<[OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+                readonly datetimePreset: VariantType<{
+                    readonly today: NullType;
+                    readonly last7d: NullType;
+                    readonly last30d: NullType;
+                    readonly last90d: NullType;
+                    readonly ytd: NullType;
+                }>;
+                readonly integer: StructType<{
+                    readonly from: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>], NullType>;
+            readonly setCompare: FunctionType<[OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>], NullType>;
+            readonly addFilter: FunctionType<[VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly removeFilter: FunctionType<[IntegerType], NullType>;
+            readonly clearFilters: FunctionType<[], NullType>;
+            readonly defineCohort: FunctionType<[StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly updateCohort: FunctionType<[StringType, StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly removeCohort: FunctionType<[StringType], NullType>;
+            readonly toggleCohort: FunctionType<[StringType], NullType>;
+            readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>], NullType>;
+            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+            readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+            readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+            readonly isActive: FunctionType<[], BooleanType>;
+            readonly activeCount: FunctionType<[], IntegerType>;
+            readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+            }>>>;
+            readonly fields: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+                readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
+                readonly format: OptionType<VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+            }>>>;
+            readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+            readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+            readonly totalCount: FunctionType<[], IntegerType>;
+            readonly resultCount: FunctionType<[], IntegerType>;
+            readonly groups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<StructType<{
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: import("@elaraai/east").FloatType;
+                    readonly size: OptionType<import("@elaraai/east").FloatType>;
+                    readonly color: OptionType<StringType>;
+                }>>;
+            }>>>;
+            readonly matches: FunctionType<[], ArrayType<StructType<{
+                readonly id: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+            }>>>;
+            readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+            readonly toggleFilter: FunctionType<[VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly setResolution: 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 affordances: ArrayType<VariantType<{
+            readonly filter: NullType;
+            readonly search: NullType;
+            readonly breakdown: NullType;
+            readonly range: NullType;
+            readonly cohort: NullType;
+            readonly brush: NullType;
+            readonly presets: NullType;
+            readonly legend: NullType;
+            readonly resolution: NullType;
+            readonly summary: NullType;
+        }>>;
+    }>>;
+    readonly canDrop: OptionType<FunctionType<[StructType<{
+        readonly kind: StringType;
+        readonly from: VariantType<{
+            readonly template: StringType;
+            readonly backlog: StringType;
+            readonly event: StringType;
+        }>;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+    }>], OptionType<StringType>>>;
+    readonly onSelect: OptionType<FunctionType<[StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+    }>], NullType>>;
+    readonly id: OptionType<StringType>;
+    readonly recordSlice: OptionType<StructType<{
+        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 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;
+        }>>;
+    }>>;
+}>;
+/** The extension carrier registered by e3-ui-components. */
+export declare const CalendarComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
+    readonly events: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly icon: StringType;
+        readonly takes: ArrayType<StringType>;
+        readonly status: ArrayType<StructType<{
+            readonly case: StringType;
+            readonly status: StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>;
+        }>>;
+        readonly backlog: BooleanType;
+        readonly templates: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly name: StringType;
+            readonly group: OptionType<StringType>;
+            readonly at: OptionType<StructType<{
+                readonly hour: IntegerType;
+                readonly minute: IntegerType;
+            }>>;
+            readonly duration: VariantType<{
+                readonly minutes: import("@elaraai/east").FloatType;
+                readonly hours: import("@elaraai/east").FloatType;
+                readonly days: import("@elaraai/east").FloatType;
+                readonly weeks: import("@elaraai/east").FloatType;
+                readonly months: import("@elaraai/east").FloatType;
+            }>;
+            readonly values: import("@elaraai/east").BlobType;
+        }>>;
+        readonly fields: ArrayType<StructType<{
+            readonly path: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly help: OptionType<StringType>;
+            readonly group: OptionType<StringType>;
+            readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly optional: BooleanType;
+            readonly editor: VariantType<{
+                readonly text: StructType<{
+                    readonly placeholder: OptionType<StringType>;
+                }>;
+                readonly number: StructType<{
+                    readonly unit: OptionType<StringType>;
+                    readonly step: OptionType<import("@elaraai/east").FloatType>;
+                    readonly min: OptionType<import("@elaraai/east").FloatType>;
+                    readonly max: OptionType<import("@elaraai/east").FloatType>;
+                }>;
+                readonly checkbox: NullType;
+                readonly datetime: StructType<{
+                    readonly precision: OptionType<VariantType<{
+                        readonly date: NullType;
+                        readonly time: NullType;
+                        readonly datetime: NullType;
+                    }>>;
+                }>;
+                readonly select: ArrayType<StructType<{
+                    readonly case: StringType;
+                    readonly label: StringType;
+                }>>;
+                readonly tags: StructType<{
+                    readonly options: ArrayType<StringType>;
+                }>;
+                readonly checklist: StructType<{
+                    readonly text: StringType;
+                    readonly done: StringType;
+                }>;
+                readonly reference: StructType<{
+                    readonly of: StringType;
+                }>;
+                readonly readonly: NullType;
+            }>;
+        }>>;
+        readonly items: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>>>>;
+        readonly unscheduled: FunctionType<[DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+            readonly resource: OptionType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly minutes: IntegerType;
+            readonly due: OptionType<DateTimeType>;
+        }>>>>;
+        readonly write: FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly entry: import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").BlobType>>>;
+        readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly entry: import("@elaraai/east").BlobType;
+        }>>], ArrayType<VariantType<{
+            readonly ready: NullType;
+            readonly incomplete: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+            readonly invalid: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+        }>>>>;
+        readonly editing: StructType<{
+            sourceId: StringType;
+            entryType: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            idField: OptionType<StringType>;
+            draftType: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            children: OptionType<StringType>;
+            keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>>;
+            snapshot: OptionType<import("@elaraai/east").BlobType>;
+            readEntry: FunctionType<[StringType, IntegerType], OptionType<import("@elaraai/east").BlobType>>;
+            onPatch: OptionType<FunctionType<[import("@elaraai/east").BlobType], NullType>>;
+            onApply: OptionType<VariantType<{
+                readonly sync: FunctionType<[import("@elaraai/east").BlobType], VariantType<{
+                    readonly applied: StructType<{
+                        readonly revision: OptionType<StringType>;
+                    }>;
+                    readonly rejected: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                }>>;
+                readonly async: import("@elaraai/east").AsyncFunctionType<[import("@elaraai/east").BlobType], VariantType<{
+                    readonly applied: StructType<{
+                        readonly revision: OptionType<StringType>;
+                    }>;
+                    readonly rejected: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                    readonly conflict: ArrayType<StructType<{
+                        readonly entry: StringType;
+                        readonly row: OptionType<IntegerType>;
+                        readonly field: OptionType<StringType>;
+                        readonly message: StringType;
+                    }>>;
+                }>>;
+            }>>;
+            mode: VariantType<{
+                readonly batch: NullType;
+                readonly auto: NullType;
+            }>;
+        }>;
+        readonly entries: OptionType<StructType<{
+            readonly revision: FunctionType<[], OptionType<StringType>>;
+            readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+            readonly entry: FunctionType<[StringType], OptionType<OptionType<import("@elaraai/east").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, DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+            readonly item: StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly resource: OptionType<StructType<{
+                    readonly kind: StringType;
+                    readonly key: StringType;
+                }>>;
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly minutes: IntegerType;
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            readonly row: import("@elaraai/east").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<[import("@elaraai/east").BlobType, FunctionType<[import("@elaraai/east").BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    }>>;
+    readonly resources: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly icon: StringType;
+        readonly rows: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly settings: StructType<{
+        readonly layout: VariantType<{
+            readonly calendar: NullType;
+            readonly resources: NullType;
+            readonly timeline: NullType;
+        }>;
+        readonly period: VariantType<{
+            readonly day: NullType;
+            readonly week: NullType;
+            readonly month: NullType;
+        }>;
+        readonly date: OptionType<DateTimeType>;
+        readonly hours: StructType<{
+            readonly from: IntegerType;
+            readonly to: IntegerType;
+        }>;
+        readonly weekStart: VariantType<{
+            readonly monday: NullType;
+            readonly sunday: NullType;
+        }>;
+        readonly weekends: BooleanType;
+        readonly density: VariantType<{
+            readonly compact: NullType;
+            readonly comfortable: NullType;
+            readonly spacious: NullType;
+        }>;
+        readonly now: OptionType<DateTimeType>;
+        readonly readOnly: BooleanType;
+    }>;
+    readonly library: ArrayType<VariantType<{
+        readonly templates: NullType;
+        readonly backlog: NullType;
+        readonly tab: StructType<{
+            readonly name: StringType;
+            readonly icon: OptionType<StringType>;
+            readonly drop: OptionType<StringType>;
+            readonly cards: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+                readonly group: OptionType<StringType>;
+                readonly sets: ArrayType<StructType<{
+                    readonly path: ArrayType<StringType>;
+                    readonly value: import("@elaraai/east").BlobType;
+                }>>;
+            }>>;
+        }>;
+    }>>;
+    readonly inspector: BooleanType;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: StringType;
+            readonly read: FunctionType<[], StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: import("@elaraai/east").FloatType;
+                        readonly to: import("@elaraai/east").FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: import("@elaraai/east").FloatType;
+                                readonly lte: import("@elaraai/east").FloatType;
+                                readonly gt: import("@elaraai/east").FloatType;
+                                readonly gte: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<IntegerType>;
+                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: FunctionType<[StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: import("@elaraai/east").FloatType;
+                        readonly to: import("@elaraai/east").FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: import("@elaraai/east").FloatType;
+                                readonly lte: import("@elaraai/east").FloatType;
+                                readonly gt: import("@elaraai/east").FloatType;
+                                readonly gte: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<IntegerType>;
+                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 setRange: FunctionType<[OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+                readonly datetimePreset: VariantType<{
+                    readonly today: NullType;
+                    readonly last7d: NullType;
+                    readonly last30d: NullType;
+                    readonly last90d: NullType;
+                    readonly ytd: NullType;
+                }>;
+                readonly integer: StructType<{
+                    readonly from: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>], NullType>;
+            readonly setCompare: FunctionType<[OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>], NullType>;
+            readonly addFilter: FunctionType<[VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly removeFilter: FunctionType<[IntegerType], NullType>;
+            readonly clearFilters: FunctionType<[], NullType>;
+            readonly defineCohort: FunctionType<[StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly updateCohort: FunctionType<[StringType, StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly removeCohort: FunctionType<[StringType], NullType>;
+            readonly toggleCohort: FunctionType<[StringType], NullType>;
+            readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>], NullType>;
+            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+            readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+            readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+            readonly isActive: FunctionType<[], BooleanType>;
+            readonly activeCount: FunctionType<[], IntegerType>;
+            readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+            }>>>;
+            readonly fields: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+                readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
+                readonly format: OptionType<VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+            }>>>;
+            readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+            readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+            readonly totalCount: FunctionType<[], IntegerType>;
+            readonly resultCount: FunctionType<[], IntegerType>;
+            readonly groups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<StructType<{
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: import("@elaraai/east").FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: import("@elaraai/east").FloatType;
+                    readonly size: OptionType<import("@elaraai/east").FloatType>;
+                    readonly color: OptionType<StringType>;
+                }>>;
+            }>>>;
+            readonly matches: FunctionType<[], ArrayType<StructType<{
+                readonly id: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+            }>>>;
+            readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+            readonly toggleFilter: FunctionType<[VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly setResolution: 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 affordances: ArrayType<VariantType<{
+            readonly filter: NullType;
+            readonly search: NullType;
+            readonly breakdown: NullType;
+            readonly range: NullType;
+            readonly cohort: NullType;
+            readonly brush: NullType;
+            readonly presets: NullType;
+            readonly legend: NullType;
+            readonly resolution: NullType;
+            readonly summary: NullType;
+        }>>;
+    }>>;
+    readonly canDrop: OptionType<FunctionType<[StructType<{
+        readonly kind: StringType;
+        readonly from: VariantType<{
+            readonly template: StringType;
+            readonly backlog: StringType;
+            readonly event: StringType;
+        }>;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+        readonly resource: OptionType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+    }>], OptionType<StringType>>>;
+    readonly onSelect: OptionType<FunctionType<[StructType<{
+        readonly kind: StringType;
+        readonly key: StringType;
+    }>], NullType>>;
+    readonly id: OptionType<StringType>;
+    readonly recordSlice: OptionType<StructType<{
+        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 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;
+        }>>;
+    }>>;
+}>>;
+/** One declared library tab. Omit the library to omit its pane. */
+export type CalendarLibraryTab = {
+    readonly kind: "templates" | "backlog";
+} | ScheduleTabDeclaration;
+/** Reads every kind's templates, including templates from bound records. */
+declare function templatesTab(): CalendarLibraryTab;
+/** Reads each kind's unscheduled rows from its bound event record. */
+declare function backlogTab(): CalendarLibraryTab;
+/**
+ * Declares an author's library tab over keyed data.
+ * @param rows - The card rows, usually a bound record's read()
+ * @param config - The card's name, accessors and optional field patch
+ * @returns The declared tab
+ */
+declare function authorTab<K extends EastType, R extends EastType, P extends EastType = EastType>(rows: SubtypeExprOrValue<DictType<K, R>>, config: ScheduleLibraryTabConfig<K, R, P>): CalendarLibraryTab;
+/** Calendar's author-facing props; no frame or layout plumbing is required. */
+export interface CalendarProps {
+    /** Event kinds, each bound to its own record and patch mutation. */
+    events: Readonly<Record<string, ScheduleEventKind<EastType, EastType>>>;
+    /** Resource kinds read from keyed data, commonly bound records. */
+    resources?: Readonly<Record<string, ScheduleResourceKind<EastType, EastType>>>;
+    /**
+     * Author-bound Slice, as in Plan. Its datetime range and navigation share
+     * one state. With Slice.bindRecord, pass the same handle to each relevant
+     * event kind's slice option; interval indexes preserve overlapping events.
+     * Local slices use the kind's filter accessor. Omitted, no Slice controls.
+     */
+    slice?: {
+        /** The handle declared with Slice.bind in the authoring Reactive block. */
+        slice: SubtypeExprOrValue<SliceBindType>;
+        /** Shared controls to mount, in order; defaults to filter and search. */
+        affordances?: SliceAffordanceLiteral[];
+    } | RecordSliceChromeOptions;
+    /** The library's tabs, in order; omitted or empty, no start pane. */
+    library?: readonly CalendarLibraryTab[];
+    /** Shows the inspector pane. */
+    inspector?: boolean;
+    /** Disables every edit, write and drag while retaining navigation and selection. */
+    readOnly?: SubtypeExprOrValue<BooleanType>;
+    /** Initial layout, period and date. Viewer changes persist under id. */
+    view?: {
+        layout?: "calendar" | "resources" | "timeline";
+        period?: "day" | "week" | "month";
+        date?: SubtypeExprOrValue<DateTimeType>;
+    };
+    /** Working hours, shaded outside this interval; defaults to 06–22 UTC. */
+    hours?: {
+        from: bigint;
+        to: bigint;
+    };
+    /** Initial week start and visibility of weekends. */
+    week?: {
+        start?: "monday" | "sunday";
+        weekends?: boolean;
+    };
+    /** Time-grid and timeline spacing. */
+    density?: "compact" | "comfortable" | "spacious";
+    /** Pins the now line for a reproducible view; otherwise it follows the clock. */
+    now?: SubtypeExprOrValue<DateTimeType>;
+    /** Refuses a candidate placement with a message; none permits it. */
+    canDrop?: SubtypeExprOrValue<FunctionType<[typeof ScheduleCandidateType], OptionType<StringType>>>;
+    /** Observes each selected event's kind and record key. */
+    onSelect?: SubtypeExprOrValue<FunctionType<[typeof ScheduleEventRefType], NullType>>;
+    /** Keeps this calendar's view, library, panes and editing history distinct. */
+    id?: string;
+}
+/**
+ * Validates the declarations and assembles Calendar's interface. View and
+ * interaction behavior belongs to the renderer, not this factory.
+ * @param props - Calendar's props
+ * @returns The closed payload
+ * @throws {Error} When kinds or library tabs are invalid, or working hours are outside the day
+ * @internal
+ */
+export declare function createCalendarPayload(props: CalendarProps): ExprType<typeof CalendarPayloadType>;
+/** The tag and the shared Schedule authoring helpers. */
+export interface CalendarNamespace extends Omit<ScheduleNamespace, "Types"> {
+    /** Renders a record-backed calendar. */
+    (props: CalendarProps): UIElement;
+    /** Declares the library's tabs. */
+    library: {
+        templates: typeof templatesTab;
+        backlog: typeof backlogTab;
+        tab: typeof authorTab;
+    };
+    /** Shared schedule types and Calendar's view state. */
+    Types: ScheduleNamespace["Types"] & {
+        Layout: typeof CalendarLayoutType;
+        Period: typeof CalendarPeriodType;
+        View: typeof CalendarViewType;
+    };
+}
+/**
+ * Schedules typed records in calendar, resource and timeline views. Optional
+ * library and inspector panes share the builders' responsive frame; gestures
+ * are drafts in the shared editing history, committed with Save. A readOnly
+ * calendar keeps navigation, selection and overlap warnings.
+ *
+ * @param props - Event and resource kinds, library, inspector and initial view
+ * @returns The Calendar extension
+ * @remarks Carries Schedule's events, resources, templates, field, patch,
+ * days and unscheduled helpers, its Types, and Calendar.library.
+ *
+ * @example
+ * ```tsx
+ * // .tsx file with the `@jsxImportSource @elaraai/e3-ui` pragma
+ * import { DateTimeType, DictType, East, StringType, StructType } from "@elaraai/east";
+ * import { Box, Reactive, UIComponentType } from "@elaraai/east-ui";
+ * import { Calendar, Record } from "@elaraai/e3-ui";
+ * import e3 from "@elaraai/e3";
+ *
+ * export const CalendarAppointment = StructType({ title: StringType, start: DateTimeType, end: DateTimeType });
+ * export const calendarAppointments = e3.record("calendar_appointments", DictType(StringType, CalendarAppointment), new Map([
+ *     ["check", { title: "Safety check", start: new Date("2026-10-01T09:00:00Z"), end: new Date("2026-10-01T10:00:00Z") }],
+ *     ["review", { title: "Production review", start: new Date("2026-10-01T11:00:00Z"), end: new Date("2026-10-01T12:00:00Z") }],
+ * ]));
+ * export const calendarAppointmentsPatch = e3.mutation.patch(calendarAppointments);
+ *
+ * const appointmentsCalendar = East.function([], UIComponentType, _$ => <Reactive>{$ => {
+ *     const appointments = $.let(Record.bind(calendarAppointments, [calendarAppointmentsPatch]));
+ *     return <Box height="640px"><Calendar inspector view={{ period: "day", date: new Date("2026-10-01T00:00:00Z") }}
+ *         events={{ appointment: Calendar.events(appointments, { name: "Appointment", icon: "calendar", title: "title", start: "start", end: "end" }) }} />
+ *     </Box>;
+ * }}</Reactive>);
+ * ```
+ */
+export declare const Calendar: CalendarNamespace;
+export {};
+//# sourceMappingURL=index.d.ts.map