@elaraai/e3-ui 1.0.94 → 1.0.95

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

@@ -4,7 +4,7 @@
  */
 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 { RowSourceType, type RecordSlicesChromeOptions } 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";
@@ -54,6 +54,7 @@ export declare const CalendarLibraryTabType: VariantType<{
                 readonly value: import("@elaraai/east").BlobType;
             }>>;
         }>>;
+        readonly source: OptionType<StringType>;
     }>;
 }>;
 /** Initial view and working-time settings; every instant is shown in UTC. */
@@ -86,7 +87,13 @@ export declare const CalendarSettingsType: StructType<{
     readonly now: OptionType<DateTimeType>;
     readonly readOnly: BooleanType;
 }>;
-/** Calendar's closed interface to its React renderer. The frame is a renderer detail. */
+/**
+ * Calendar's closed interface to its React renderer. The frame is a renderer detail.
+ * @property slice - The narrowing's chrome: a Slice over the event kinds', the resource kinds' and the templates' records, one rail (#1343)
+ * @property narrowed - Each source's narrowed keys, paged through its own data, by the source's name — a resource
+ *   kind's narrow its columns, rows and Choosers, a templates list's and a tab's their cards; an event kind reads its
+ *   own narrowing through its part
+ */
 export declare const CalendarPayloadType: StructType<{
     readonly events: ArrayType<StructType<{
         readonly key: StringType;
@@ -125,6 +132,7 @@ export declare const CalendarPayloadType: StructType<{
             }>;
             readonly values: import("@elaraai/east").BlobType;
         }>>;
+        readonly templatesSource: OptionType<StringType>;
         readonly fields: ArrayType<StructType<{
             readonly path: ArrayType<StringType>;
             readonly label: StringType;
@@ -232,7 +240,7 @@ export declare const CalendarPayloadType: StructType<{
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly unscheduled: FunctionType<[DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly unscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly kind: StringType;
             readonly key: StringType;
             readonly title: StringType;
@@ -583,677 +591,273 @@ export declare const CalendarPayloadType: StructType<{
                     readonly value: import("@elaraai/east").BlobType;
                 }>>;
             }>>;
+            readonly source: OptionType<StringType>;
         }>;
     }>>;
     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 key: import("@elaraai/east").StringType;
+            readonly parts: ArrayType<StructType<{
+                readonly source: import("@elaraai/east").StringType;
+                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly icon: OptionType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly prefix: import("@elaraai/east").StringType;
+                    readonly label: OptionType<import("@elaraai/east").StringType>;
+                    readonly style: OptionType<StructType<{
+                        readonly size: OptionType<VariantType<{
+                            readonly xs: NullType;
+                            readonly sm: NullType;
+                            readonly md: NullType;
+                            readonly lg: NullType;
+                            readonly xl: NullType;
+                            readonly "2xl": NullType;
+                        }>>;
+                        readonly variant: OptionType<VariantType<{
+                            readonly solid: NullType;
+                        }>>;
+                        readonly color: OptionType<import("@elaraai/east").StringType>;
+                        readonly background: OptionType<import("@elaraai/east").StringType>;
+                        readonly colorPalette: OptionType<VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                        readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
+                        readonly overflow: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowX: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowY: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly width: OptionType<import("@elaraai/east").StringType>;
+                        readonly height: OptionType<import("@elaraai/east").StringType>;
+                        readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly padding: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
+                        readonly margin: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
                     }>>;
-                    readonly 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 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 boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
+                            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 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 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 boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
+                        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 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 prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+                    readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
                         }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: BooleanType;
-                    }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").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 presets: ArrayType<StructType<{
+                readonly id: import("@elaraai/east").StringType;
+                readonly name: import("@elaraai/east").StringType;
+            }>>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
         }>;
         readonly affordances: ArrayType<VariantType<{
-            readonly filter: NullType;
+            readonly fields: 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 brush: NullType;
             readonly summary: NullType;
         }>>;
+        readonly persist: OptionType<VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
     }>>;
+    readonly narrowed: DictType<StringType, RowSourceType<ArrayType<StringType>>>;
     readonly canDrop: OptionType<FunctionType<[StructType<{
         readonly kind: StringType;
         readonly from: VariantType<{
@@ -1273,171 +877,6 @@ export declare const CalendarPayloadType: StructType<{
         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<{
@@ -1478,6 +917,7 @@ export declare const CalendarComponent: import("@elaraai/east-ui").UIComponentDe
             }>;
             readonly values: import("@elaraai/east").BlobType;
         }>>;
+        readonly templatesSource: OptionType<StringType>;
         readonly fields: ArrayType<StructType<{
             readonly path: ArrayType<StringType>;
             readonly label: StringType;
@@ -1585,7 +1025,7 @@ export declare const CalendarComponent: import("@elaraai/east-ui").UIComponentDe
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly unscheduled: FunctionType<[DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly unscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly kind: StringType;
             readonly key: StringType;
             readonly title: StringType;
@@ -1936,677 +1376,273 @@ export declare const CalendarComponent: import("@elaraai/east-ui").UIComponentDe
                     readonly value: import("@elaraai/east").BlobType;
                 }>>;
             }>>;
+            readonly source: OptionType<StringType>;
         }>;
     }>>;
     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 key: import("@elaraai/east").StringType;
+            readonly parts: ArrayType<StructType<{
+                readonly source: import("@elaraai/east").StringType;
+                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly icon: OptionType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly prefix: import("@elaraai/east").StringType;
+                    readonly label: OptionType<import("@elaraai/east").StringType>;
+                    readonly style: OptionType<StructType<{
+                        readonly size: OptionType<VariantType<{
+                            readonly xs: NullType;
+                            readonly sm: NullType;
+                            readonly md: NullType;
+                            readonly lg: NullType;
+                            readonly xl: NullType;
+                            readonly "2xl": NullType;
+                        }>>;
+                        readonly variant: OptionType<VariantType<{
+                            readonly solid: NullType;
+                        }>>;
+                        readonly color: OptionType<import("@elaraai/east").StringType>;
+                        readonly background: OptionType<import("@elaraai/east").StringType>;
+                        readonly colorPalette: OptionType<VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>>;
+                        readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                        readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
+                        readonly overflow: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowX: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly overflowY: OptionType<VariantType<{
+                            readonly visible: NullType;
+                            readonly hidden: NullType;
+                            readonly scroll: NullType;
+                            readonly auto: NullType;
+                        }>>;
+                        readonly width: OptionType<import("@elaraai/east").StringType>;
+                        readonly height: OptionType<import("@elaraai/east").StringType>;
+                        readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                        readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                        readonly padding: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
+                        readonly margin: OptionType<StructType<{
+                            readonly top: OptionType<import("@elaraai/east").StringType>;
+                            readonly right: OptionType<import("@elaraai/east").StringType>;
+                            readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                            readonly left: OptionType<import("@elaraai/east").StringType>;
+                        }>>;
                     }>>;
-                    readonly 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 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 boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
+                            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 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 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 boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
+                        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 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 prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+                    readonly containsRow: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
                         }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: BooleanType;
-                    }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>, import("@elaraai/east").StringType, import("@elaraai/east").BlobType], OptionType<import("@elaraai/east").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 presets: ArrayType<StructType<{
+                readonly id: import("@elaraai/east").StringType;
+                readonly name: import("@elaraai/east").StringType;
+            }>>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
         }>;
         readonly affordances: ArrayType<VariantType<{
-            readonly filter: NullType;
+            readonly fields: 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 brush: NullType;
             readonly summary: NullType;
         }>>;
+        readonly persist: OptionType<VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
     }>>;
+    readonly narrowed: DictType<StringType, RowSourceType<ArrayType<StringType>>>;
     readonly canDrop: OptionType<FunctionType<[StructType<{
         readonly kind: StringType;
         readonly from: VariantType<{
@@ -2626,171 +1662,6 @@ export declare const CalendarComponent: import("@elaraai/east-ui").UIComponentDe
         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 = {
@@ -2814,17 +1685,14 @@ export interface CalendarProps {
     /** 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.
+     * The narrowing: `Slice.bindRecords(key, { … })`, one rail, a source per record it narrows (#1343). A source named
+     * after an event kind's slot (`job`) narrows that kind's events in every layout, its backlog and its choices,
+     * through its interval index — its `range` the kind's start field, which the Calendar's navigation writes in
+     * every event source at once — and the kind gives `entries` beside it. A source named after a resource kind's slot
+     * (`machines`) narrows its columns, rows and choices. A source a templates list or a tab names narrows its cards.
+     * Overlaps and checks read every event. 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;
+    slice?: RecordSlicesChromeOptions;
     /** The library's tabs, in order; omitted or empty, no start pane. */
     library?: readonly CalendarLibraryTab[];
     /** Shows the inspector pane. */
@@ -2863,7 +1731,10 @@ export interface CalendarProps {
  * 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
+ * @throws {Error} When kinds or library tabs are invalid, a kind has no `title` (#1367), working hours are outside the
+ *   day, `slice` is not `Slice.bindRecords` or names a source no kind, templates list or tab names, a templates list is
+ *   written in the code or names no source of the slice (templates are records, #1340), or a tab names a source the
+ *   slice lacks
  * @internal
  */
 export declare function createCalendarPayload(props: CalendarProps): ExprType<typeof CalendarPayloadType>;