@elaraai/e3-ui 1.0.93 → 1.0.95

package/dist/src/sheet/sheet.d.ts

@@ -10,33 +10,42 @@
  * author's tabs of cards (#1186), and `inspector`, the selected row's every
  * field (#1188). No prop, no pane.
  *
- * Its rows come from one of two sources:
+ * Its rows come from one of three sources:
  * - `record`, an e3 record bound with its patch mutation: its entries, a
  *   window of them, or one entry's rows (#1182). Apply commits through the
  *   record, and the footer gives the record's last save;
  * - `data`, the host's rows: an array, a bind handle (`State.bind`,
  *   `Data.bind`) or a paged source (`Data.bindPaged`). Edits reach the host
  *   through `onApply`, `onUpdate` and `onPatch`, and with none of them the
- *   sheet is read only.
+ *   sheet is read only;
+ * - the `rows` source of its `slice`, a `Slice.bindRecords` over records
+ *   (#1345): the rows it narrows to, paged from it, its record's keys their
+ *   ids; edits reach the record through `onApply`
+ *   (`Record.onApply(record, { keyed: true })`).
+ *
+ * Its narrowing is that one `Slice.bindRecords`, one rail on its toolbar:
+ * its `rows` source narrows the rows, and each other source the templates
+ * list or the library tab that names it. Templates are records, each list
+ * its own source (#1340).
  *
  * The sheet is an interface. Its payload holds the sheet whole — its grid,
- * its rows and its session ({@link SheetRootType}) — beside the templates'
- * cards and seeds, the library's tabs, the inspector's pane, the record's
- * history and the sheet's name. The `Sheet` renderer in
- * `@elaraai/e3-ui-components` draws it.
+ * its rows, its narrowing's chrome and its session ({@link SheetRootType}) —
+ * beside the templates' cards and seeds, the library's tabs, each source's
+ * narrowed keys, the inspector's pane, the record's history and the sheet's
+ * name. The `Sheet` renderer in `@elaraai/e3-ui-components` draws it.
  *
  * @packageDocumentation
  */
-import { ArrayType, BooleanType, FunctionType, NullType, OptionType, StringType, StructType, type DictType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
-import { UIComponentType, type UIElement } from "@elaraai/east-ui";
-import { type DataRowType, type FieldHints, type PagedSource } from "@elaraai/east-ui/internal";
+import { ArrayType, BooleanType, DictType, FunctionType, NullType, OptionType, StringType, StructType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
+import { RowSourceType, UIComponentType, type UIElement } from "@elaraai/east-ui";
+import { type DataRowType, type FieldHints, type PagedSource, type RecordSlicesChromeOptions } from "@elaraai/east-ui/internal";
 import { type SheetEntryOf, type SheetLinesField, type SheetLineOf } from "./types.js";
 import { type SheetBindHandle, type SheetBuild, type SheetEntriesOptions, type SheetGroupedOptions, type SheetOptions, type SheetIndexedOptions, type SheetStringField } from "./root.js";
 import type { SheetColumnSpec, SheetFieldKey } from "./columns.js";
 import type { SheetGroupValue } from "./group.js";
 import type { SheetArrayField, SheetElementOf } from "./sub-rows.js";
 import { type SheetRecordEntry } from "./record.js";
-import { type SheetTemplatesInput } from "./templates.js";
+import { type SheetTemplatesProp } from "./templates.js";
 import { type SheetLibraryTab } from "./library.js";
 import type { OrderedRowSource } from "../utils/ordered-source.js";
 /**
@@ -445,9 +454,10 @@ export type SheetHistoryType = typeof SheetHistoryType;
 /**
  * The `Sheet` renderer's payload: the sheet's interface.
  *
- * @property sheet - The sheet whole — its grid, its rows and its session wired to its source
- * @property templates - The Rows tab's cards and their seeds
+ * @property sheet - The sheet whole — its grid, its rows, its narrowing's chrome and its session wired to its source
+ * @property templates - The Rows tab's cards and their seeds, each with the source its list follows
  * @property library - The library pane's tabs, in the order `library` lists them; none, no library pane
+ * @property narrowed - Each source of the slice's narrowed keys, paged through its part, by the source's name (#1345): what the Rows tab and an author's tab read to show a source's rows
  * @property inspector - The inspector pane: its forms, and the author's own Details; `none`, no inspector pane
  * @property history - Over a record, its commits: the last save, and who changed it; `none` over `data`
  * @property missing - With `entry`, the entry's key while the record does not hold it: what the frame's banner names
@@ -455,7 +465,7 @@ export type SheetHistoryType = typeof SheetHistoryType;
  */
 export declare const SheetPayloadType: StructType<{
     readonly sheet: StructType<{
-        readonly rows: import("@elaraai/east-ui").RowSourceType<ArrayType<StructType<{
+        readonly rows: RowSourceType<ArrayType<StructType<{
             readonly id: StringType;
             readonly owned: BooleanType;
             readonly cells: DictType<StringType, import("@elaraai/east").VariantType<{
@@ -2968,824 +2978,279 @@ export declare const SheetPayloadType: StructType<{
         }>>;
         readonly slice: OptionType<StructType<{
             readonly slice: StructType<{
-                readonly key: StringType;
-                readonly read: FunctionType<[], StructType<{
-                    readonly range: OptionType<import("@elaraai/east").VariantType<{
-                        readonly datetime: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                        readonly datetimePreset: import("@elaraai/east").VariantType<{
-                            readonly today: NullType;
-                            readonly last7d: NullType;
-                            readonly last30d: NullType;
-                            readonly last90d: NullType;
-                            readonly ytd: NullType;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly from: import("@elaraai/east").IntegerType;
-                            readonly to: import("@elaraai/east").IntegerType;
-                        }>;
-                        readonly float: StructType<{
-                            readonly from: import("@elaraai/east").FloatType;
-                            readonly to: import("@elaraai/east").FloatType;
-                        }>;
-                    }>>;
-                    readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                        readonly previousPeriod: NullType;
-                        readonly previousYear: NullType;
-                    }>>;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly cohorts: ArrayType<StructType<{
-                        readonly id: StringType;
-                        readonly name: StringType;
-                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                            readonly string: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: StringType;
-                                    readonly neq: StringType;
-                                    readonly in: import("@elaraai/east").SetType<StringType>;
-                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                    readonly contains: StringType;
-                                    readonly matches: StringType;
-                                    readonly startsWith: StringType;
-                                    readonly endsWith: StringType;
-                                    readonly isEmpty: NullType;
-                                    readonly isNotEmpty: NullType;
-                                }>;
-                            }>;
-                            readonly integer: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: import("@elaraai/east").IntegerType;
-                                    readonly neq: import("@elaraai/east").IntegerType;
-                                    readonly lt: import("@elaraai/east").IntegerType;
-                                    readonly lte: import("@elaraai/east").IntegerType;
-                                    readonly gt: import("@elaraai/east").IntegerType;
-                                    readonly gte: import("@elaraai/east").IntegerType;
-                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                                }>;
-                            }>;
-                            readonly float: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                    readonly before: import("@elaraai/east").DateTimeType;
-                                    readonly after: import("@elaraai/east").DateTimeType;
-                                    readonly between: StructType<{
-                                        readonly from: import("@elaraai/east").DateTimeType;
-                                        readonly to: import("@elaraai/east").DateTimeType;
-                                    }>;
-                                }>;
-                            }>;
-                            readonly boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<import("@elaraai/east").StringType>;
+                            readonly background: OptionType<import("@elaraai/east").StringType>;
+                            readonly colorPalette: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<import("@elaraai/east").StringType>;
+                            readonly height: OptionType<import("@elaraai/east").StringType>;
+                            readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
                         }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                    readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly resolution: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
-                        readonly datetime: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                        readonly datetimePreset: import("@elaraai/east").VariantType<{
-                            readonly today: NullType;
-                            readonly last7d: NullType;
-                            readonly last30d: NullType;
-                            readonly last90d: NullType;
-                            readonly ytd: NullType;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly from: import("@elaraai/east").IntegerType;
-                            readonly to: import("@elaraai/east").IntegerType;
-                        }>;
-                        readonly float: StructType<{
-                            readonly from: import("@elaraai/east").FloatType;
-                            readonly to: import("@elaraai/east").FloatType;
-                        }>;
-                    }>>;
-                    readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                        readonly previousPeriod: NullType;
-                        readonly previousYear: NullType;
-                    }>>;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
                     }>>;
-                    readonly cohorts: ArrayType<StructType<{
-                        readonly id: StringType;
-                        readonly name: StringType;
-                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                            readonly string: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: StringType;
-                                    readonly neq: StringType;
-                                    readonly in: import("@elaraai/east").SetType<StringType>;
-                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                    readonly contains: StringType;
-                                    readonly matches: StringType;
-                                    readonly startsWith: StringType;
-                                    readonly endsWith: StringType;
-                                    readonly isEmpty: NullType;
-                                    readonly isNotEmpty: NullType;
-                                }>;
-                            }>;
-                            readonly integer: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: import("@elaraai/east").IntegerType;
-                                    readonly neq: import("@elaraai/east").IntegerType;
-                                    readonly lt: import("@elaraai/east").IntegerType;
-                                    readonly lte: import("@elaraai/east").IntegerType;
-                                    readonly gt: import("@elaraai/east").IntegerType;
-                                    readonly gte: import("@elaraai/east").IntegerType;
-                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                                }>;
-                            }>;
-                            readonly float: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                    readonly before: import("@elaraai/east").DateTimeType;
-                                    readonly after: import("@elaraai/east").DateTimeType;
-                                    readonly between: StructType<{
-                                        readonly from: import("@elaraai/east").DateTimeType;
-                                        readonly to: import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                    readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly resolution: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>], NullType>;
-                readonly setCompare: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>], NullType>;
-                readonly addFilter: FunctionType<[import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>], NullType>;
-                readonly removeFilter: FunctionType<[import("@elaraai/east").IntegerType], NullType>;
-                readonly clearFilters: FunctionType<[], NullType>;
-                readonly defineCohort: FunctionType<[StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>], NullType>;
-                readonly updateCohort: FunctionType<[StringType, StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
+                        readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").IntegerType>;
-                }>>], NullType>;
-                readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
-                readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
-                readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
-                readonly isActive: FunctionType<[], BooleanType>;
-                readonly activeCount: FunctionType<[], import("@elaraai/east").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<import("@elaraai/east").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<[], import("@elaraai/east").IntegerType>;
-                readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
-                readonly groups: FunctionType<[], ArrayType<StructType<{
-                    readonly key: StringType;
-                    readonly count: import("@elaraai/east").IntegerType;
-                    readonly color: StringType;
-                }>>>;
-                readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
-                    readonly key: StringType;
-                    readonly color: StringType;
-                    readonly points: ArrayType<StructType<{
-                        readonly x: import("@elaraai/east").VariantType<{
-                            readonly category: StringType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly time: import("@elaraai/east").DateTimeType;
-                        }>;
-                        readonly value: import("@elaraai/east").FloatType;
-                        readonly size: OptionType<import("@elaraai/east").FloatType>;
-                        readonly color: OptionType<StringType>;
-                    }>>;
-                }>>>;
-                readonly matches: FunctionType<[], ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly label: StringType;
-                    readonly meta: OptionType<StringType>;
-                }>>>;
-                readonly cohortCounts: FunctionType<[], DictType<StringType, import("@elaraai/east").IntegerType>>;
-                readonly toggleFilter: FunctionType<[import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").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, import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
-                    readonly color: StringType;
-                }>>>;
-                readonly setResolution: FunctionType<[OptionType<import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                readonly local: NullType;
+                readonly session: NullType;
+                readonly url: NullType;
+            }>>;
         }>>;
         readonly views: ArrayType<StructType<{
             readonly id: StringType;
             readonly name: StringType;
-            readonly narrowing: StructType<{
-                readonly range: OptionType<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: BooleanType;
-                        }>;
+            readonly narrowing: DictType<StringType, StructType<{
+                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
+                    readonly values: ArrayType<StringType>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
                     }>;
+                    readonly prefix: StringType;
                 }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly preset: OptionType<StringType>;
                 readonly resolution: OptionType<import("@elaraai/east").VariantType<{
                     readonly auto: NullType;
                     readonly hour: NullType;
@@ -3795,7 +3260,7 @@ export declare const SheetPayloadType: StructType<{
                     readonly quarter: NullType;
                     readonly year: NullType;
                 }>>;
-            }>;
+            }>>;
             readonly context: import("@elaraai/east").IntegerType;
             readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
             readonly folds: DictType<StringType, BooleanType>;
@@ -3804,155 +3269,16 @@ export declare const SheetPayloadType: StructType<{
         readonly onViewsChange: OptionType<FunctionType<[ArrayType<StructType<{
             readonly id: StringType;
             readonly name: StringType;
-            readonly narrowing: StructType<{
-                readonly range: OptionType<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
+            readonly narrowing: DictType<StringType, StructType<{
+                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
+                    readonly values: ArrayType<StringType>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
                     }>;
+                    readonly prefix: StringType;
                 }>>;
-                readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly preset: OptionType<StringType>;
                 readonly resolution: OptionType<import("@elaraai/east").VariantType<{
                     readonly auto: NullType;
                     readonly hour: NullType;
@@ -3962,7 +3288,7 @@ export declare const SheetPayloadType: StructType<{
                     readonly quarter: NullType;
                     readonly year: NullType;
                 }>>;
-            }>;
+            }>>;
             readonly context: import("@elaraai/east").IntegerType;
             readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
             readonly folds: DictType<StringType, BooleanType>;
@@ -5281,229 +4607,11 @@ export declare const SheetPayloadType: StructType<{
         readonly style: OptionType<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<import("@elaraai/east").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, import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
-                readonly local: NullType;
-                readonly session: NullType;
-                readonly url: NullType;
-            }>>;
-        }>>;
-        readonly recordViews: ArrayType<StructType<{
-            readonly narrowing: StructType<{
-                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
-                    readonly values: ArrayType<StringType>;
-                    readonly range: StructType<{
-                        readonly from: StringType;
-                        readonly to: StringType;
-                    }>;
-                    readonly prefix: StringType;
-                }>>;
-                readonly preset: OptionType<StringType>;
-                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>;
-            }>;
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly context: import("@elaraai/east").IntegerType;
-            readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
-            readonly folds: DictType<StringType, BooleanType>;
-        }>>;
-        readonly onRecordViewsChange: OptionType<FunctionType<[ArrayType<StructType<{
-            readonly narrowing: StructType<{
-                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
-                    readonly values: ArrayType<StringType>;
-                    readonly range: StructType<{
-                        readonly from: StringType;
-                        readonly to: StringType;
-                    }>;
-                    readonly prefix: StringType;
-                }>>;
-                readonly preset: OptionType<StringType>;
-                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>;
-            }>;
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly context: import("@elaraai/east").IntegerType;
-            readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
-            readonly folds: DictType<StringType, BooleanType>;
-        }>>], NullType>>;
         readonly ordered: BooleanType;
     }>;
     readonly templates: ArrayType<StructType<{
         readonly key: StringType;
+        readonly source: StringType;
         readonly name: StringType;
         readonly group: OptionType<StringType>;
         readonly cells: DictType<StringType, import("@elaraai/east").VariantType<{
@@ -5641,8 +4749,10 @@ export declare const SheetPayloadType: StructType<{
                     }>;
                 }>>;
             }>>;
+            readonly source: OptionType<StringType>;
         }>;
     }>>;
+    readonly narrowed: DictType<StringType, RowSourceType<ArrayType<StringType>>>;
     readonly inspector: OptionType<StructType<{
         readonly forms: StructType<{
             readonly row: StructType<{
@@ -6016,7 +5126,7 @@ export type SheetPayloadType = typeof SheetPayloadType;
  */
 export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
     readonly sheet: StructType<{
-        readonly rows: import("@elaraai/east-ui").RowSourceType<ArrayType<StructType<{
+        readonly rows: RowSourceType<ArrayType<StructType<{
             readonly id: StringType;
             readonly owned: BooleanType;
             readonly cells: DictType<StringType, import("@elaraai/east").VariantType<{
@@ -8529,824 +7639,279 @@ export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<S
         }>>;
         readonly slice: OptionType<StructType<{
             readonly slice: StructType<{
-                readonly key: StringType;
-                readonly read: FunctionType<[], StructType<{
-                    readonly range: OptionType<import("@elaraai/east").VariantType<{
-                        readonly datetime: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                        readonly datetimePreset: import("@elaraai/east").VariantType<{
-                            readonly today: NullType;
-                            readonly last7d: NullType;
-                            readonly last30d: NullType;
-                            readonly last90d: NullType;
-                            readonly ytd: NullType;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly from: import("@elaraai/east").IntegerType;
-                            readonly to: import("@elaraai/east").IntegerType;
-                        }>;
-                        readonly float: StructType<{
-                            readonly from: import("@elaraai/east").FloatType;
-                            readonly to: import("@elaraai/east").FloatType;
-                        }>;
-                    }>>;
-                    readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                        readonly previousPeriod: NullType;
-                        readonly previousYear: NullType;
-                    }>>;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly cohorts: ArrayType<StructType<{
-                        readonly id: StringType;
-                        readonly name: StringType;
-                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                            readonly string: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: StringType;
-                                    readonly neq: StringType;
-                                    readonly in: import("@elaraai/east").SetType<StringType>;
-                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                    readonly contains: StringType;
-                                    readonly matches: StringType;
-                                    readonly startsWith: StringType;
-                                    readonly endsWith: StringType;
-                                    readonly isEmpty: NullType;
-                                    readonly isNotEmpty: NullType;
-                                }>;
-                            }>;
-                            readonly integer: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: import("@elaraai/east").IntegerType;
-                                    readonly neq: import("@elaraai/east").IntegerType;
-                                    readonly lt: import("@elaraai/east").IntegerType;
-                                    readonly lte: import("@elaraai/east").IntegerType;
-                                    readonly gt: import("@elaraai/east").IntegerType;
-                                    readonly gte: import("@elaraai/east").IntegerType;
-                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                                }>;
-                            }>;
-                            readonly float: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                    readonly before: import("@elaraai/east").DateTimeType;
-                                    readonly after: import("@elaraai/east").DateTimeType;
-                                    readonly between: StructType<{
-                                        readonly from: import("@elaraai/east").DateTimeType;
-                                        readonly to: import("@elaraai/east").DateTimeType;
-                                    }>;
-                                }>;
-                            }>;
-                            readonly boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly xs: NullType;
+                                readonly sm: NullType;
+                                readonly md: NullType;
+                                readonly lg: NullType;
+                                readonly xl: NullType;
+                                readonly "2xl": NullType;
+                            }>>;
+                            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                                readonly solid: NullType;
+                            }>>;
+                            readonly color: OptionType<import("@elaraai/east").StringType>;
+                            readonly background: OptionType<import("@elaraai/east").StringType>;
+                            readonly colorPalette: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowX: OptionType<import("@elaraai/east").VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly overflowY: OptionType<import("@elaraai/east").VariantType<{
+                                readonly visible: NullType;
+                                readonly hidden: NullType;
+                                readonly scroll: NullType;
+                                readonly auto: NullType;
+                            }>>;
+                            readonly width: OptionType<import("@elaraai/east").StringType>;
+                            readonly height: OptionType<import("@elaraai/east").StringType>;
+                            readonly minWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly minHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxWidth: OptionType<import("@elaraai/east").StringType>;
+                            readonly maxHeight: OptionType<import("@elaraai/east").StringType>;
+                            readonly padding: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
+                            readonly margin: OptionType<StructType<{
+                                readonly top: OptionType<import("@elaraai/east").StringType>;
+                                readonly right: OptionType<import("@elaraai/east").StringType>;
+                                readonly bottom: OptionType<import("@elaraai/east").StringType>;
+                                readonly left: OptionType<import("@elaraai/east").StringType>;
+                            }>>;
                         }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                    readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly resolution: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
-                        readonly datetime: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                        readonly datetimePreset: import("@elaraai/east").VariantType<{
-                            readonly today: NullType;
-                            readonly last7d: NullType;
-                            readonly last30d: NullType;
-                            readonly last90d: NullType;
-                            readonly ytd: NullType;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly from: import("@elaraai/east").IntegerType;
-                            readonly to: import("@elaraai/east").IntegerType;
-                        }>;
-                        readonly float: StructType<{
-                            readonly from: import("@elaraai/east").FloatType;
-                            readonly to: import("@elaraai/east").FloatType;
-                        }>;
-                    }>>;
-                    readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                        readonly previousPeriod: NullType;
-                        readonly previousYear: NullType;
                     }>>;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
+                    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<import("@elaraai/east").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, import("@elaraai/east").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 cohorts: ArrayType<StructType<{
-                        readonly id: StringType;
-                        readonly name: StringType;
-                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                            readonly string: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: StringType;
-                                    readonly neq: StringType;
-                                    readonly in: import("@elaraai/east").SetType<StringType>;
-                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                    readonly contains: StringType;
-                                    readonly matches: StringType;
-                                    readonly startsWith: StringType;
-                                    readonly endsWith: StringType;
-                                    readonly isEmpty: NullType;
-                                    readonly isNotEmpty: NullType;
-                                }>;
-                            }>;
-                            readonly integer: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly eq: import("@elaraai/east").IntegerType;
-                                    readonly neq: import("@elaraai/east").IntegerType;
-                                    readonly lt: import("@elaraai/east").IntegerType;
-                                    readonly lte: import("@elaraai/east").IntegerType;
-                                    readonly gt: import("@elaraai/east").IntegerType;
-                                    readonly gte: import("@elaraai/east").IntegerType;
-                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                                }>;
-                            }>;
-                            readonly float: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").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 read: import("@elaraai/east").FunctionType<[], StructType<{
+                            readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").VariantType<{
+                            readonly values: ArrayType<import("@elaraai/east").StringType>;
+                            readonly range: StructType<{
+                                readonly from: import("@elaraai/east").StringType;
+                                readonly to: import("@elaraai/east").StringType;
                             }>;
-                            readonly datetime: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: import("@elaraai/east").VariantType<{
-                                    readonly before: import("@elaraai/east").DateTimeType;
-                                    readonly after: import("@elaraai/east").DateTimeType;
-                                    readonly between: StructType<{
-                                        readonly from: import("@elaraai/east").DateTimeType;
-                                        readonly to: import("@elaraai/east").DateTimeType;
-                                    }>;
-                                }>;
+                            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<import("@elaraai/east").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, import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
+                            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, import("@elaraai/east").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>;
-                    }>>;
-                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                    readonly breakdown: OptionType<StructType<{
-                        readonly fieldId: StringType;
-                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                    }>>;
-                    readonly search: OptionType<StringType>;
-                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                    readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly resolution: OptionType<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>], NullType>;
-                readonly setCompare: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>], NullType>;
-                readonly addFilter: FunctionType<[import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>], NullType>;
-                readonly removeFilter: FunctionType<[import("@elaraai/east").IntegerType], NullType>;
-                readonly clearFilters: FunctionType<[], NullType>;
-                readonly defineCohort: FunctionType<[StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>], NullType>;
-                readonly updateCohort: FunctionType<[StringType, StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>], NullType>;
-                readonly removeCohort: FunctionType<[StringType], NullType>;
-                readonly toggleCohort: FunctionType<[StringType], NullType>;
-                readonly setBreakdown: FunctionType<[OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>], NullType>;
-                readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
-                readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
-                readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
-                readonly isActive: FunctionType<[], BooleanType>;
-                readonly activeCount: FunctionType<[], import("@elaraai/east").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<import("@elaraai/east").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<[], import("@elaraai/east").IntegerType>;
-                readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
-                readonly groups: FunctionType<[], ArrayType<StructType<{
-                    readonly key: StringType;
-                    readonly count: import("@elaraai/east").IntegerType;
-                    readonly color: StringType;
-                }>>>;
-                readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
-                    readonly key: StringType;
-                    readonly color: StringType;
-                    readonly points: ArrayType<StructType<{
-                        readonly x: import("@elaraai/east").VariantType<{
-                            readonly category: StringType;
-                            readonly number: import("@elaraai/east").FloatType;
-                            readonly time: import("@elaraai/east").DateTimeType;
-                        }>;
-                        readonly value: import("@elaraai/east").FloatType;
-                        readonly size: OptionType<import("@elaraai/east").FloatType>;
-                        readonly color: OptionType<StringType>;
-                    }>>;
-                }>>>;
-                readonly matches: FunctionType<[], ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly label: StringType;
-                    readonly meta: OptionType<StringType>;
-                }>>>;
-                readonly cohortCounts: FunctionType<[], DictType<StringType, import("@elaraai/east").IntegerType>>;
-                readonly toggleFilter: FunctionType<[import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
-                    readonly color: StringType;
-                }>>>;
-                readonly setResolution: FunctionType<[OptionType<import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
+                readonly local: NullType;
+                readonly session: NullType;
+                readonly url: NullType;
+            }>>;
         }>>;
         readonly views: ArrayType<StructType<{
             readonly id: StringType;
             readonly name: StringType;
-            readonly narrowing: StructType<{
-                readonly range: OptionType<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: BooleanType;
-                        }>;
+            readonly narrowing: DictType<StringType, StructType<{
+                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
+                    readonly values: ArrayType<StringType>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
                     }>;
+                    readonly prefix: StringType;
                 }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly preset: OptionType<StringType>;
                 readonly resolution: OptionType<import("@elaraai/east").VariantType<{
                     readonly auto: NullType;
                     readonly hour: NullType;
@@ -9356,7 +7921,7 @@ export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<S
                     readonly quarter: NullType;
                     readonly year: NullType;
                 }>>;
-            }>;
+            }>>;
             readonly context: import("@elaraai/east").IntegerType;
             readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
             readonly folds: DictType<StringType, BooleanType>;
@@ -9365,155 +7930,16 @@ export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<S
         readonly onViewsChange: OptionType<FunctionType<[ArrayType<StructType<{
             readonly id: StringType;
             readonly name: StringType;
-            readonly narrowing: StructType<{
-                readonly range: OptionType<import("@elaraai/east").VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                    readonly datetimePreset: import("@elaraai/east").VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: import("@elaraai/east").IntegerType;
-                        readonly to: import("@elaraai/east").IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: import("@elaraai/east").FloatType;
-                        readonly to: import("@elaraai/east").FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<import("@elaraai/east").VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: BooleanType;
-                        }>;
+            readonly narrowing: DictType<StringType, StructType<{
+                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
+                    readonly values: ArrayType<StringType>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
                     }>;
+                    readonly prefix: StringType;
                 }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
-                            }>;
-                        }>;
-                        readonly integer: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly eq: import("@elaraai/east").IntegerType;
-                                readonly neq: import("@elaraai/east").IntegerType;
-                                readonly lt: import("@elaraai/east").IntegerType;
-                                readonly lte: import("@elaraai/east").IntegerType;
-                                readonly gt: import("@elaraai/east").IntegerType;
-                                readonly gte: import("@elaraai/east").IntegerType;
-                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                            }>;
-                        }>;
-                        readonly float: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").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: import("@elaraai/east").VariantType<{
-                                readonly before: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: import("@elaraai/east").VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly preset: OptionType<StringType>;
                 readonly resolution: OptionType<import("@elaraai/east").VariantType<{
                     readonly auto: NullType;
                     readonly hour: NullType;
@@ -9523,7 +7949,7 @@ export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<S
                     readonly quarter: NullType;
                     readonly year: NullType;
                 }>>;
-            }>;
+            }>>;
             readonly context: import("@elaraai/east").IntegerType;
             readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
             readonly folds: DictType<StringType, BooleanType>;
@@ -10842,229 +9268,11 @@ export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<S
         readonly style: OptionType<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<import("@elaraai/east").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, import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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, import("@elaraai/east").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<import("@elaraai/east").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<import("@elaraai/east").VariantType<{
-                readonly local: NullType;
-                readonly session: NullType;
-                readonly url: NullType;
-            }>>;
-        }>>;
-        readonly recordViews: ArrayType<StructType<{
-            readonly narrowing: StructType<{
-                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
-                    readonly values: ArrayType<StringType>;
-                    readonly range: StructType<{
-                        readonly from: StringType;
-                        readonly to: StringType;
-                    }>;
-                    readonly prefix: StringType;
-                }>>;
-                readonly preset: OptionType<StringType>;
-                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>;
-            }>;
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly context: import("@elaraai/east").IntegerType;
-            readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
-            readonly folds: DictType<StringType, BooleanType>;
-        }>>;
-        readonly onRecordViewsChange: OptionType<FunctionType<[ArrayType<StructType<{
-            readonly narrowing: StructType<{
-                readonly where: DictType<StringType, import("@elaraai/east").VariantType<{
-                    readonly values: ArrayType<StringType>;
-                    readonly range: StructType<{
-                        readonly from: StringType;
-                        readonly to: StringType;
-                    }>;
-                    readonly prefix: StringType;
-                }>>;
-                readonly preset: OptionType<StringType>;
-                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>;
-            }>;
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly context: import("@elaraai/east").IntegerType;
-            readonly reveals: ArrayType<import("@elaraai/east").IntegerType>;
-            readonly folds: DictType<StringType, BooleanType>;
-        }>>], NullType>>;
         readonly ordered: BooleanType;
     }>;
     readonly templates: ArrayType<StructType<{
         readonly key: StringType;
+        readonly source: StringType;
         readonly name: StringType;
         readonly group: OptionType<StringType>;
         readonly cells: DictType<StringType, import("@elaraai/east").VariantType<{
@@ -11202,8 +9410,10 @@ export declare const SheetComponent: import("@elaraai/east-ui").UIComponentDef<S
                     }>;
                 }>>;
             }>>;
+            readonly source: OptionType<StringType>;
         }>;
     }>>;
+    readonly narrowed: DictType<StringType, RowSourceType<ArrayType<StringType>>>;
     readonly inspector: OptionType<StructType<{
         readonly forms: StructType<{
             readonly row: StructType<{
@@ -11624,14 +9834,32 @@ export interface SheetLooseEntryRows<K extends EastType, V extends StructType, P
 }
 /**
  * What every `<Sheet>` takes beside its rows, its columns and the sheet's
- * own options: its panes, its templates, its views and its name.
+ * own options: its narrowing, its panes, its templates, its views and its
+ * name.
  *
  * @typeParam L - The row type (a grouped sheet's line type)
  * @typeParam G - The group type, on a grouped sheet
  */
 export interface SheetCommon<L extends StructType, G extends StructType = never> {
-    /** The Rows tab's cards. */
-    templates?: SheetTemplatesInput<L, G>;
+    /**
+     * The narrowing (#1345): `slice={{ slice: Slice.bindRecords(key, { rows, … }) }}`,
+     * one rail on the toolbar, with its `affordances` and `persist`. Its
+     * `rows` source narrows the sheet's rows, which the sheet pages from it —
+     * then `record`, `data`, `entry` and `window` give none, and edits reach the
+     * record through `onApply` (`Record.onApply(record, { keyed: true })`). Each
+     * other source narrows the templates list or the library tab that names it.
+     * `Slice.bind`, a single `Slice.bindRecord` and a source nothing names are
+     * refused.
+     */
+    slice?: RecordSlicesChromeOptions;
+    /**
+     * The Rows tab's cards: templates records, each list
+     * `Sheet.templates(rows, { name, group?, values, source })` over its
+     * record's `read()`, naming its source of `slice` — a grouped sheet's row
+     * templates and group templates two lists, two records, two sources. A
+     * list written in the code is refused.
+     */
+    templates?: SheetTemplatesProp<L, G>;
     /** The library pane's tabs, in order, each a `Sheet.library.*` call — `rows()`, `columns()` and `tab(data, { … })`; left out, or empty, no library pane (SB59). */
     library?: readonly SheetLibraryTab[];
     /**
@@ -11651,7 +9879,7 @@ export interface SheetCommon<L extends StructType, G extends StructType = never>
     fields?: FieldHints<L["fields"]>;
     /** Hints for a group's own fields in the inspector, on a grouped sheet. */
     groupFields?: [G] extends [never] ? never : FieldHints<G["fields"]>;
-    /** The saved views — a bind handle of `Array<Sheet.Types.View>`: `State.bind` keeps them per viewer, `Data.bind` shares them. */
+    /** The saved views — a bind handle of `Array<Sheet.Types.RecordView>`, each every source's narrowing: `State.bind` keeps them per viewer, `Data.bind` shares them. Their tabs show while `slice` narrows the rows. */
     views?: unknown;
     /** Names the sheet — needed only when one surface holds two. */
     name?: string;
@@ -11661,13 +9889,13 @@ type SheetRecordOwned = "id" | "onApply" | "onUpdate";
 /**
  * Creates the sheet's payload alone — what `<Sheet>` returns through the
  * `Sheet` carrier — for the tests and the renderer's fixtures, which read it
- * whole: the sheet over its rows, its templates, its library's tabs, its
- * inspector pane, the record's history, the missing entry's key and the
- * sheet's name.
+ * whole: the sheet over its rows, its templates, its library's tabs, each
+ * source's narrowed keys, its inspector pane, the record's history, the
+ * missing entry's key and the sheet's name.
  *
  * @param props - The sheet's props, as `<Sheet>` takes them
  * @returns An East expression of {@link SheetPayloadType}
- * @throws Error naming the prop and the remedy: rows from both `record` and `data`, or from neither; `entry` or `window` without a record; `id`, `onApply` or `onUpdate` over a record; `onViewsChange`, which `views` replaces; `fields` or `groupFields` without an inspector; and everything `Sheet Spec.md` §3.12 and `Sheet Builder Spec.md` §4.3 refuse
+ * @throws Error naming the prop and the remedy: rows from both `record` and `data`, or from neither; `entry` or `window` without a record; `id`, `onApply` or `onUpdate` over a record; `onViewsChange`, which `views` replaces; `fields` or `groupFields` without an inspector; a `slice` that is not `{ slice: Slice.bindRecords(…) }`, one holding a source nothing names, and the rows of its `rows` source beside `record`, `data`, `entry` or `window`; `affordances` and `persist`, which moved into `slice`; a templates list written in the code or naming no source of the slice, and two naming the same; and everything `Sheet Spec.md` §3.12 and `Sheet Builder Spec.md` §4.3 refuse
  * @internal
  */
 export declare function createSheetPayload(props: {
@@ -11813,6 +10041,27 @@ export declare function SheetTag<K extends EastType, R extends StructType, P ext
     data: OrderedRowSource<K, R, P, IK>;
     columns: SheetColumnSpec<R>;
 } & SheetCommon<R> & SheetIndexedOptions<K, R>): UIElement;
+/**
+ * `<Sheet slice={{ slice }} group={Sheet.group(P, "lines", …)} columns={{ … }} onApply={Record.onApply(record, { keyed: true })} />`
+ * — the groups the `rows` source of `slice` narrows to (#1345), paged from it
+ * in its index's order, each group's id its record key; `columns` are
+ * declared over their lines.
+ */
+export declare function SheetTag<K extends EastType, P extends StructType, F extends SheetLinesField<P>>(props: {
+    slice: RecordSlicesChromeOptions;
+    group: SheetGroupValue<P, F>;
+    columns: SheetColumnSpec<SheetLineOf<P, F>>;
+} & SheetCommon<SheetLineOf<P, F>, P> & Omit<SheetGroupedOptions<P, F>, "group" | "onApply"> & Pick<SheetIndexedOptions<K, P>, "onApply">): UIElement;
+/**
+ * `<Sheet slice={{ slice }} columns={{ … }} onApply={Record.onApply(record, { keyed: true })} />`
+ * — the rows the `rows` source of `slice` narrows to (#1345), paged from it
+ * in its index's order, each row's id its record key: `slice`'s rail narrows
+ * them, and Save commits through `onApply` by original primary key.
+ */
+export declare function SheetTag<K extends EastType, R extends StructType>(props: {
+    slice: RecordSlicesChromeOptions;
+    columns: SheetColumnSpec<R>;
+} & SheetCommon<R> & SheetIndexedOptions<K, R>): UIElement;
 /** The type of `<Sheet>` as a tag: every form its props take. */
 export type SheetTagType = typeof SheetTag;
 export {};