@elaraai/e3-ui 1.0.94 → 1.0.96

package/dist/src/plan/plan.d.ts

@@ -20,25 +20,35 @@
  * Pinned rows of any source sit under the ruler. An event is scheduled in
  * time, so event kinds need a time axis.
  *
+ * Its narrowing is one `Slice.bindRecords`, one rail on its toolbar (#1344):
+ * its `rows` source gives the canvas its rows, paged from it; a source named
+ * after an event kind narrows that kind's events and its backlog through its
+ * interval index; one named after a resource kind narrows its rows; and one a
+ * templates list or a tab names narrows its cards. Every source holding a
+ * `range` holds the window with the others. Templates are records, each list
+ * its own source (#1340).
+ *
  * The Plan is an interface. Its payload holds the canvas whole
- * ({@link PlanRootType}) beside the event kinds and resources as Plan takes
- * them (`PlanEventKindType`, `PlanResourcesType`, #1190), the resources' rows
- * over a window (`blocks`, #1192) and a paged resource kind's a window of its
- * resources at a time (`paged`, #1199), the event kinds' drop veto, the settings,
- * the library's tabs and whether it has an inspector. The `Plan` renderer in
- * `@elaraai/e3-ui-components` draws it.
+ * ({@link PlanRootType}, its narrowing's chrome among it) beside the event
+ * kinds and resources as Plan takes them (`PlanEventKindType`,
+ * `PlanResourcesType`, #1190), the resources' rows over a window (`blocks`,
+ * #1192) and a paged resource kind's a window of its resources at a time
+ * (`paged`, #1199), the event kinds' drop veto, the settings, the library's
+ * tabs, whether it has an inspector, and each source's narrowed keys. The
+ * `Plan` renderer in `@elaraai/e3-ui-components` draws it.
  *
  * @packageDocumentation
  */
-import { ArrayType, BooleanType, DateTimeType, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, VariantType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
-import { type UIElement } from "@elaraai/east-ui";
+import { ArrayType, BooleanType, DateTimeType, DictType, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, VariantType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
+import { RowSourceType, type UIElement } from "@elaraai/east-ui";
+import { type RecordSlicesChromeOptions } from "@elaraai/east-ui/internal";
 import type { ScheduleEventKind } from "../schedule/events.js";
 import type { ScheduleResourceKind } from "../schedule/resources.js";
 import { type PlanAxisKindLiteral, type PlanRowsValue } from "./types.js";
 import { type PlanConfig } from "./root.js";
 import { type PlanOverRows } from "./over.js";
 import { type PlanLibraryTab } from "./library.js";
-export { PlanEventBlocksType, PlanEventDraftsType, PlanEventPagedType, PlanEventPlacedType } from "./event-rows.js";
+export { PlanEventBlocksType, PlanEventDraftsType, PlanEventPagedType, PlanEventPlacedType, PlanEventShownType } from "./event-rows.js";
 /**
  * The names a Plan keeps its viewer's state under, by its `id`: its frame's
  * panes (their open tab and collapsed state), the series this viewer hides,
@@ -105,10 +115,13 @@ export type PlanSettingsType = typeof PlanSettingsType;
  * @property settings - When the event kinds' drafts go, and the date brought into view first
  * @property library - The library pane's tabs, in the order `library` lists them; empty, no pane (#1195)
  * @property inspector - Whether the Plan has an inspector pane, showing what is selected (#1197)
+ * @property narrowed - Each source of the slice's narrowed keys, paged through its own data, by the source's name
+ *   (#1344): what a resource kind's rows, a templates list's cards and an author's tab read to show a source's rows;
+ *   `rows` gives the canvas its rows, and an event kind reads its own narrowing through its part
  */
 export declare const PlanPayloadType: StructType<{
     readonly plan: StructType<{
-        readonly rows: import("@elaraai/east-ui").RowSourceType<ArrayType<StructType<{
+        readonly rows: RowSourceType<ArrayType<StructType<{
             readonly fixed: BooleanType;
             readonly parent: OptionType<VariantType<{
                 readonly entry: StructType<{
@@ -1526,671 +1539,265 @@ export declare const PlanPayloadType: StructType<{
         }>>;
         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: SetType<StringType>;
-                                readonly notIn: 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: 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: SetType<StringType>;
-                                    readonly notIn: 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: 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: SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<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: SetType<StringType>;
-                                readonly notIn: 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: 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: SetType<StringType>;
-                                    readonly notIn: 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: 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 boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    readonly activeCohorts: SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<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: SetType<StringType>;
-                            readonly notIn: 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: 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: SetType<StringType>;
-                                readonly notIn: 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: 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 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 datetime: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly before: DateTimeType;
-                                readonly after: DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: DateTimeType;
-                                    readonly to: DateTimeType;
+                        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 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: SetType<StringType>;
-                                readonly notIn: 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: 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;
+                            }>>;
+                            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 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<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<[], import("@elaraai/east").DictType<StringType, IntegerType>>;
-                readonly toggleFilter: FunctionType<[VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: SetType<StringType>;
-                            readonly notIn: 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: 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 footer: ArrayType<StructType<{
             readonly text: StringType;
@@ -2502,171 +2109,6 @@ export declare const PlanPayloadType: StructType<{
             }>>;
             readonly gutterWidth: 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;
-            }>>;
-        }>>;
     }>;
     readonly resources: ArrayType<StructType<{
         readonly key: StringType;
@@ -2730,7 +2172,7 @@ export declare const PlanPayloadType: StructType<{
             readonly quantity: OptionType<StringType>;
             readonly lane: OptionType<StringType>;
         }>;
-        readonly planItems: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly planItems: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly state: VariantType<{
                 readonly estimated: NullType;
                 readonly proposed: VariantType<{
@@ -2773,7 +2215,7 @@ export declare const PlanPayloadType: StructType<{
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly planUnscheduled: FunctionType<[import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly planUnscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly state: VariantType<{
                 readonly estimated: NullType;
                 readonly proposed: VariantType<{
@@ -2816,7 +2258,7 @@ export declare const PlanPayloadType: StructType<{
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly planEvent: FunctionType<[StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly planEvent: FunctionType<[StringType, DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
             readonly item: StructType<{
                 readonly state: VariantType<{
                     readonly estimated: NullType;
@@ -2899,6 +2341,7 @@ export declare const PlanPayloadType: StructType<{
             }>;
             readonly values: import("@elaraai/east").BlobType;
         }>>;
+        readonly templatesSource: OptionType<StringType>;
         readonly fields: ArrayType<StructType<{
             readonly path: ArrayType<StringType>;
             readonly label: StringType;
@@ -2982,7 +2425,7 @@ export declare const PlanPayloadType: StructType<{
                 readonly readonly: NullType;
             }>;
         }>>;
-        readonly items: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly items: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly kind: StringType;
             readonly key: StringType;
             readonly title: StringType;
@@ -3006,7 +2449,7 @@ export declare const PlanPayloadType: StructType<{
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly unscheduled: FunctionType<[import("@elaraai/east").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;
@@ -3261,7 +2704,7 @@ export declare const PlanPayloadType: StructType<{
             readonly at: DateTimeType;
             readonly delta: OptionType<StringType>;
         }>>>>;
-        readonly event: FunctionType<[StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly event: FunctionType<[StringType, DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
             readonly item: StructType<{
                 readonly kind: StringType;
                 readonly key: StringType;
@@ -3296,7 +2739,7 @@ export declare const PlanPayloadType: StructType<{
             readonly status: OptionType<StringType>;
         }>;
     }>>;
-    readonly blocks: OptionType<FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<ArrayType<StructType<{
+    readonly blocks: OptionType<FunctionType<[DateTimeType, DateTimeType, DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>, DictType<StringType, SetType<StringType>>], OptionType<ArrayType<StructType<{
         readonly fixed: BooleanType;
         readonly parent: OptionType<VariantType<{
             readonly entry: StructType<{
@@ -4312,7 +3755,7 @@ export declare const PlanPayloadType: StructType<{
     readonly paged: OptionType<StructType<{
         readonly kind: StringType;
         readonly id: StringType;
-        readonly placed: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, ArrayType<StructType<{
+        readonly placed: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<DictType<StringType, DictType<StringType, ArrayType<StructType<{
             readonly item: StructType<{
                 readonly state: VariantType<{
                     readonly estimated: NullType;
@@ -4435,7 +3878,7 @@ export declare const PlanPayloadType: StructType<{
                 }>>;
             }>;
         }>>>>>>;
-        readonly rows: FunctionType<[IntegerType, IntegerType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, ArrayType<StructType<{
+        readonly rows: FunctionType<[IntegerType, IntegerType, DictType<StringType, DictType<StringType, ArrayType<StructType<{
             readonly item: StructType<{
                 readonly state: VariantType<{
                     readonly estimated: NullType;
@@ -5802,9 +5245,11 @@ export declare const PlanPayloadType: StructType<{
                     readonly value: import("@elaraai/east").BlobType;
                 }>>;
             }>>;
+            readonly source: OptionType<StringType>;
         }>;
     }>>;
     readonly inspector: BooleanType;
+    readonly narrowed: DictType<StringType, RowSourceType<ArrayType<StringType>>>;
 }>;
 /** Type representing the `Plan` renderer's payload. */
 export type PlanPayloadType = typeof PlanPayloadType;
@@ -5815,7 +5260,7 @@ export type PlanPayloadType = typeof PlanPayloadType;
  */
 export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
     readonly plan: StructType<{
-        readonly rows: import("@elaraai/east-ui").RowSourceType<ArrayType<StructType<{
+        readonly rows: RowSourceType<ArrayType<StructType<{
             readonly fixed: BooleanType;
             readonly parent: OptionType<VariantType<{
                 readonly entry: StructType<{
@@ -7226,678 +6671,272 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                             readonly left: OptionType<StringType>;
                         }>>;
                     }>>;
-                }>>;
-                readonly count: OptionType<IntegerType>;
-                readonly narrowed: 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: SetType<StringType>;
-                                readonly notIn: 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: 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: SetType<StringType>;
-                                    readonly notIn: 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: 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 count: OptionType<IntegerType>;
+                readonly narrowed: BooleanType;
+            }>>;
+        }>>;
+        readonly slice: OptionType<StructType<{
+            readonly slice: StructType<{
+                readonly key: import("@elaraai/east").StringType;
+                readonly parts: ArrayType<StructType<{
+                    readonly source: import("@elaraai/east").StringType;
+                    readonly label: OptionType<import("@elaraai/east").StringType>;
+                    readonly icon: OptionType<StructType<{
+                        readonly name: import("@elaraai/east").StringType;
+                        readonly prefix: import("@elaraai/east").StringType;
+                        readonly label: OptionType<import("@elaraai/east").StringType>;
+                        readonly style: OptionType<StructType<{
+                            readonly size: OptionType<VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<import("@elaraai/east").StringType>;
+                            readonly background: OptionType<import("@elaraai/east").StringType>;
+                            readonly colorPalette: OptionType<VariantType<{
+                                readonly brand: NullType;
+                                readonly gray: NullType;
+                                readonly red: NullType;
+                                readonly orange: NullType;
+                                readonly yellow: NullType;
+                                readonly green: NullType;
+                                readonly teal: NullType;
+                                readonly blue: NullType;
+                                readonly cyan: NullType;
+                                readonly purple: NullType;
+                                readonly pink: NullType;
+                                readonly success: NullType;
+                                readonly warning: NullType;
+                                readonly danger: NullType;
+                                readonly info: NullType;
+                                readonly neutral: NullType;
+                            }>>;
+                            readonly opacity: OptionType<import("@elaraai/east").FloatType>;
+                            readonly borderRadius: OptionType<import("@elaraai/east").StringType>;
+                            readonly overflow: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<import("@elaraai/east").StringType>;
+                            readonly height: OptionType<import("@elaraai/east").StringType>;
+                            readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
+                        }>>;
+                    }>>;
+                    readonly slice: StructType<{
+                        readonly key: import("@elaraai/east").StringType;
+                        readonly config: StructType<{
+                            readonly fields: ArrayType<StructType<{
+                                readonly fieldId: import("@elaraai/east").StringType;
+                                readonly label: import("@elaraai/east").StringType;
+                                readonly kind: import("@elaraai/east").StringType;
+                                readonly optional: import("@elaraai/east").BooleanType;
+                                readonly multiple: import("@elaraai/east").BooleanType;
+                                readonly set: import("@elaraai/east").BooleanType;
+                                readonly values: ArrayType<StructType<{
+                                    readonly value: import("@elaraai/east").StringType;
+                                    readonly label: import("@elaraai/east").StringType;
+                                }>>;
+                                readonly format: OptionType<VariantType<{
+                                    readonly number: NullType;
+                                    readonly currency: StructType<{
+                                        readonly code: import("@elaraai/east").StringType;
+                                        readonly compact: import("@elaraai/east").BooleanType;
                                     }>;
-                                }>;
-                            }>;
-                            readonly boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    readonly activeCohorts: SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<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: SetType<StringType>;
-                                readonly notIn: 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: 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: SetType<StringType>;
-                                    readonly notIn: 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: 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 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 boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    readonly activeCohorts: SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<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: SetType<StringType>;
-                            readonly notIn: 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: 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: SetType<StringType>;
-                                readonly notIn: 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: 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 prefix: import("@elaraai/east").StringType;
+                                }>>;
+                            }>>;
                         }>;
-                        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 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 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: SetType<StringType>;
-                                readonly notIn: 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: 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;
+                            }>>;
+                            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 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<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<[], import("@elaraai/east").DictType<StringType, IntegerType>>;
-                readonly toggleFilter: FunctionType<[VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: SetType<StringType>;
-                            readonly notIn: 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: 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 footer: ArrayType<StructType<{
             readonly text: StringType;
@@ -8209,171 +7248,6 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             }>>;
             readonly gutterWidth: 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;
-            }>>;
-        }>>;
     }>;
     readonly resources: ArrayType<StructType<{
         readonly key: StringType;
@@ -8437,7 +7311,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly quantity: OptionType<StringType>;
             readonly lane: OptionType<StringType>;
         }>;
-        readonly planItems: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly planItems: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly state: VariantType<{
                 readonly estimated: NullType;
                 readonly proposed: VariantType<{
@@ -8480,7 +7354,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly planUnscheduled: FunctionType<[import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly planUnscheduled: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly state: VariantType<{
                 readonly estimated: NullType;
                 readonly proposed: VariantType<{
@@ -8523,7 +7397,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly planEvent: FunctionType<[StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly planEvent: FunctionType<[StringType, DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
             readonly item: StructType<{
                 readonly state: VariantType<{
                     readonly estimated: NullType;
@@ -8606,6 +7480,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             }>;
             readonly values: import("@elaraai/east").BlobType;
         }>>;
+        readonly templatesSource: OptionType<StringType>;
         readonly fields: ArrayType<StructType<{
             readonly path: ArrayType<StringType>;
             readonly label: StringType;
@@ -8689,7 +7564,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                 readonly readonly: NullType;
             }>;
         }>>;
-        readonly items: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
+        readonly items: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, import("@elaraai/east").BlobType>], OptionType<ArrayType<StructType<{
             readonly kind: StringType;
             readonly key: StringType;
             readonly title: StringType;
@@ -8713,7 +7588,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly minutes: IntegerType;
             readonly due: OptionType<DateTimeType>;
         }>>>>;
-        readonly unscheduled: FunctionType<[import("@elaraai/east").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;
@@ -8968,7 +7843,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly at: DateTimeType;
             readonly delta: OptionType<StringType>;
         }>>>>;
-        readonly event: FunctionType<[StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
+        readonly event: FunctionType<[StringType, DictType<StringType, import("@elaraai/east").BlobType>, DateTimeType, DateTimeType], OptionType<StructType<{
             readonly item: StructType<{
                 readonly kind: StringType;
                 readonly key: StringType;
@@ -9003,7 +7878,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
             readonly status: OptionType<StringType>;
         }>;
     }>>;
-    readonly blocks: OptionType<FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<ArrayType<StructType<{
+    readonly blocks: OptionType<FunctionType<[DateTimeType, DateTimeType, DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>, DictType<StringType, SetType<StringType>>], OptionType<ArrayType<StructType<{
         readonly fixed: BooleanType;
         readonly parent: OptionType<VariantType<{
             readonly entry: StructType<{
@@ -10019,7 +8894,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
     readonly paged: OptionType<StructType<{
         readonly kind: StringType;
         readonly id: StringType;
-        readonly placed: FunctionType<[DateTimeType, DateTimeType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, ArrayType<StructType<{
+        readonly placed: FunctionType<[DateTimeType, DateTimeType, DictType<StringType, DictType<StringType, import("@elaraai/east").BlobType>>, ArrayType<StringType>], OptionType<DictType<StringType, DictType<StringType, ArrayType<StructType<{
             readonly item: StructType<{
                 readonly state: VariantType<{
                     readonly estimated: NullType;
@@ -10142,7 +9017,7 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                 }>>;
             }>;
         }>>>>>>;
-        readonly rows: FunctionType<[IntegerType, IntegerType, import("@elaraai/east").DictType<StringType, import("@elaraai/east").DictType<StringType, ArrayType<StructType<{
+        readonly rows: FunctionType<[IntegerType, IntegerType, DictType<StringType, DictType<StringType, ArrayType<StructType<{
             readonly item: StructType<{
                 readonly state: VariantType<{
                     readonly estimated: NullType;
@@ -11509,9 +10384,11 @@ export declare const PlanComponent: import("@elaraai/east-ui").UIComponentDef<St
                     readonly value: import("@elaraai/east").BlobType;
                 }>>;
             }>>;
+            readonly source: OptionType<StringType>;
         }>;
     }>>;
     readonly inspector: BooleanType;
+    readonly narrowed: DictType<StringType, RowSourceType<ArrayType<StringType>>>;
 }>>;
 /**
  * One of a Plan's `rows`: a hand-built row stream (`Plan.chart`, `Plan.span`,
@@ -11534,8 +10411,20 @@ export type PlanRowsItem<K extends PlanAxisKindLiteral = never> = PlanRowsValue<
  * @typeParam K - The canvas's axis kind, inferred from `axis`
  */
 export interface PlanProps<K extends PlanAxisKindLiteral = PlanAxisKindLiteral> extends Omit<PlanConfig<K>, "data" | "canDrop"> {
-    /** The rows' source — a keyed collection, a bind handle over one or a paged source of one, laid out by `series` or `pick` (see {@link PlanConfig}). Leave it out for a Plan of event kinds or `rows` alone. */
+    /** The rows' source — a keyed collection, a bind handle over one or a paged source of one, laid out by `series` or `pick` (see {@link PlanConfig}). Leave it out for a Plan of event kinds or `rows` alone, and beside `slice`'s `rows` source, which gives the rows. */
     data?: PlanConfig<K>["data"];
+    /**
+     * The narrowing (#1344): `slice={{ slice: Slice.bindRecords(key, { rows, … }) }}`, one rail on the toolbar, with
+     * its `affordances` and `persist`. Its `rows` source gives the canvas its rows, paged from it in its index's order —
+     * `data` then gives none — laid out by `series`, edits reaching the record through `editing.onApply`
+     * (`Record.onApply(record, { keyed: true })`). A source named after an event kind's slot narrows that kind's events
+     * and its backlog through the source's interval index, its `range` the kind's start field; one named after a
+     * resource kind's slot narrows that kind's rows; one a templates list or a library tab names narrows its cards.
+     * Every source holding a `range` holds the window with the others: the toolbar's navigation and range, the horizon
+     * brush and the resolution write them together. Calculations — the footer's counts, the overlaps — read every
+     * event. `Slice.bind`, a single `Slice.bindRecord` and a source nothing names are refused.
+     */
+    slice?: RecordSlicesChromeOptions;
     /** The resource kinds, by slot — `Schedule.resources(rows, { … })`, or a paged read of them: the rows events are placed on, in this order. */
     resources?: Readonly<Record<string, ScheduleResourceKind<EastType, EastType>>>;
     /** The event kinds, by slot — `Schedule.events(record, { … })`, each a record of its own: at least one, when given. An event is scheduled in time, so they need a time axis. */
@@ -11579,15 +10468,18 @@ export interface PlanProps<K extends PlanAxisKindLiteral = PlanAxisKindLiteral>
  * @param props - The Plan's props, as `<Plan>` takes them
  * @returns An East expression of {@link PlanPayloadType}
  * @throws {Error} Naming the prop and the remedy: no rows from any source; `resources` without `events`; an event kind's
- *   resource naming a slot `resources` has not, or one not keyed by String; event kinds on a number or ordinal axis; a
+ *   resource naming a slot `resources` has not, or one not keyed by String; an event kind with no `title` (#1367); event
+ *   kinds on a number or ordinal axis; a
  *   link naming an event kind `events` has not; a `rows` item that is neither a hand-built row nor `Plan.over`'s; a
  *   `canDrop` over neither a drag nor a candidate, or over a candidate with no event kinds; an `applyMode` that is neither
  *   batch nor auto, or with no event kinds; an `inspector` with no event kinds; a resource kind with no event kind
  *   placed on it and no measures; more than one paged resource kind, or one beside a paged `data` (#1199);
- *   a key the Plan gives its event rows that another series has; and everything the canvas
- *   refuses ({@link createPlanRoot}). An
- *   axis held in a variable, and links whose kinds are not known at build, are refused in the same words as the Plan
- *   is evaluated
+ *   a key the Plan gives its event rows that another series has; a `slice` that is not `{ slice: Slice.bindRecords(…) }`
+ *   — `Slice.bind`, a single `Slice.bindRecord`, the bare handle — or names a source nothing names, `data` beside its
+ *   `rows` source, a paged resource kind or one not keyed by String its source would narrow, and a kind's own `slice` or
+ *   `filter` (#1344); a templates list written in the code or naming no source of the slice (#1340); and everything the
+ *   canvas refuses ({@link createPlanRoot}). An axis held in a variable, and links whose kinds are not known at build,
+ *   are refused in the same words as the Plan is evaluated
  * @internal
  */
 export declare function createPlanPayload(props: PlanProps): ExprType<PlanPayloadType>;