@elaraai/e3-ui 1.0.34 → 1.0.36

package/dist/src/decision/queue.d.ts

@@ -21,7 +21,7 @@
  */
 import { ArrayType, StructType, OptionType, VariantType, StringType, BooleanType, NullType, FunctionType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
 import { DensityType, UIComponentType, type DensityLiteral } from "@elaraai/east-ui";
-import { type SliceAffordanceLiteral } from "@elaraai/east-ui/internal";
+import { SliceBindType, type SliceAffordanceLiteral } from "@elaraai/east-ui/internal";
 import { type DecisionHandleLike } from "./bind.js";
 import { DecisionType, DecisionUpdateType } from "./types.js";
 export { DecisionUpdateType } from "./types.js";
@@ -288,9 +288,11 @@ export type DecisionGroupType = typeof DecisionGroupType;
  *   Apply resolves it (the resolution itself goes through the handle).
  * @property onReject - Optional side-effect hook fired with the decision
  *   when Reject resolves it.
- * @property slice - Optional rail affordances. The slice itself is
- *   handle-owned (bound by `Decision.bind`, seeded there); this field only
- *   chooses what mounts in the queue's eyebrow rail.
+ * @property slice - Optional author-bound slice handle over the queue; its
+ *   narrowing (matched with the slice's own bound config) applies before the
+ *   urgency sort and the routine split whether or not a rail mounts.
+ * @property affordances - Which rail affordances mount in the queue's eyebrow
+ *   when `slice` is set.
  * @property maxHeight - Optional cap on the queue's height (a CSS length).
  *   The header stays pinned; the rows scroll.
  * @property density - Information-density preset.
@@ -328,155 +330,6 @@ export declare const DecisionQueuePayloadType: StructType<{
                 readonly direct: NullType;
             }>;
         }>;
-        readonly slice: OptionType<StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: 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<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: 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: VariantType<{
-                        readonly lt: import("@elaraai/east").FloatType;
-                        readonly lte: import("@elaraai/east").FloatType;
-                        readonly gt: import("@elaraai/east").FloatType;
-                        readonly gte: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly datetime: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: 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: VariantType<{
-                        readonly is: BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: 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: VariantType<{
-                            readonly lt: import("@elaraai/east").FloatType;
-                            readonly lte: import("@elaraai/east").FloatType;
-                            readonly gt: import("@elaraai/east").FloatType;
-                            readonly gte: import("@elaraai/east").FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: 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: VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            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 heading: OptionType<StringType>;
     readonly modify: OptionType<FunctionType<[StructType<{
@@ -1695,273 +1548,20 @@ export declare const DecisionQueuePayloadType: StructType<{
             readonly note: OptionType<StringType>;
         }>>;
     }>], NullType>>;
-    readonly slice: OptionType<ArrayType<VariantType<{
-        readonly filter: NullType;
-        readonly search: NullType;
-        readonly breakdown: NullType;
-        readonly range: NullType;
-        readonly cohort: NullType;
-        readonly brush: NullType;
-        readonly presets: NullType;
-        readonly legend: NullType;
-    }>>>;
-    readonly maxHeight: OptionType<StringType>;
-    readonly density: OptionType<VariantType<{
-        readonly comfortable: NullType;
-        readonly compact: NullType;
-        readonly condensed: NullType;
-    }>>;
-    readonly groups: OptionType<ArrayType<StructType<{
-        readonly label: StringType;
-        readonly value: FunctionType<[StructType<{
-            readonly id: StringType;
-            readonly kind: StringType;
-            readonly title: StringType;
-            readonly urgency: VariantType<{
-                readonly overdue: NullType;
-                readonly due: NullType;
-                readonly routine: NullType;
-            }>;
-            readonly value: import("@elaraai/east").FloatType;
-            readonly deadline: OptionType<import("@elaraai/east").DateTimeType>;
-            readonly format: OptionType<VariantType<{
-                readonly number: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
+    readonly slice: OptionType<StructType<{
+        readonly key: StringType;
+        readonly read: FunctionType<[], StructType<{
+            readonly range: OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: import("@elaraai/east").DateTimeType;
+                    readonly to: import("@elaraai/east").DateTimeType;
                 }>;
-                readonly currency: import("@elaraai/east").StructType<{
-                    readonly currency: import("@elaraai/east").VariantType<{
-                        readonly USD: import("@elaraai/east").NullType;
-                        readonly EUR: import("@elaraai/east").NullType;
-                        readonly GBP: import("@elaraai/east").NullType;
-                        readonly JPY: import("@elaraai/east").NullType;
-                        readonly CHF: import("@elaraai/east").NullType;
-                        readonly CAD: import("@elaraai/east").NullType;
-                        readonly AUD: import("@elaraai/east").NullType;
-                        readonly NZD: import("@elaraai/east").NullType;
-                        readonly CNY: import("@elaraai/east").NullType;
-                        readonly HKD: import("@elaraai/east").NullType;
-                        readonly SGD: import("@elaraai/east").NullType;
-                        readonly KRW: import("@elaraai/east").NullType;
-                        readonly INR: import("@elaraai/east").NullType;
-                        readonly TWD: import("@elaraai/east").NullType;
-                        readonly THB: import("@elaraai/east").NullType;
-                        readonly MYR: import("@elaraai/east").NullType;
-                        readonly IDR: import("@elaraai/east").NullType;
-                        readonly PHP: import("@elaraai/east").NullType;
-                        readonly VND: import("@elaraai/east").NullType;
-                        readonly SEK: import("@elaraai/east").NullType;
-                        readonly NOK: import("@elaraai/east").NullType;
-                        readonly DKK: import("@elaraai/east").NullType;
-                        readonly PLN: import("@elaraai/east").NullType;
-                        readonly CZK: import("@elaraai/east").NullType;
-                        readonly HUF: import("@elaraai/east").NullType;
-                        readonly RUB: import("@elaraai/east").NullType;
-                        readonly UAH: import("@elaraai/east").NullType;
-                        readonly RON: import("@elaraai/east").NullType;
-                        readonly MXN: import("@elaraai/east").NullType;
-                        readonly BRL: import("@elaraai/east").NullType;
-                        readonly ARS: import("@elaraai/east").NullType;
-                        readonly CLP: import("@elaraai/east").NullType;
-                        readonly COP: import("@elaraai/east").NullType;
-                        readonly PEN: import("@elaraai/east").NullType;
-                        readonly AED: import("@elaraai/east").NullType;
-                        readonly SAR: import("@elaraai/east").NullType;
-                        readonly ILS: import("@elaraai/east").NullType;
-                        readonly ZAR: import("@elaraai/east").NullType;
-                        readonly TRY: import("@elaraai/east").NullType;
-                        readonly EGP: import("@elaraai/east").NullType;
-                        readonly NGN: import("@elaraai/east").NullType;
-                        readonly KES: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                        readonly code: import("@elaraai/east").NullType;
-                        readonly symbol: import("@elaraai/east").NullType;
-                        readonly narrowSymbol: import("@elaraai/east").NullType;
-                        readonly name: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                }>;
-                readonly percent: import("@elaraai/east").StructType<{
-                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                    readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                        readonly auto: import("@elaraai/east").NullType;
-                        readonly never: import("@elaraai/east").NullType;
-                        readonly always: import("@elaraai/east").NullType;
-                        readonly exceptZero: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly compact: import("@elaraai/east").StructType<{
-                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly unit: import("@elaraai/east").StructType<{
-                    readonly unit: import("@elaraai/east").VariantType<{
-                        readonly bit: import("@elaraai/east").NullType;
-                        readonly byte: import("@elaraai/east").NullType;
-                        readonly kilobit: import("@elaraai/east").NullType;
-                        readonly kilobyte: import("@elaraai/east").NullType;
-                        readonly megabit: import("@elaraai/east").NullType;
-                        readonly megabyte: import("@elaraai/east").NullType;
-                        readonly gigabit: import("@elaraai/east").NullType;
-                        readonly gigabyte: import("@elaraai/east").NullType;
-                        readonly terabit: import("@elaraai/east").NullType;
-                        readonly terabyte: import("@elaraai/east").NullType;
-                        readonly petabyte: import("@elaraai/east").NullType;
-                        readonly nanosecond: import("@elaraai/east").NullType;
-                        readonly microsecond: import("@elaraai/east").NullType;
-                        readonly millisecond: import("@elaraai/east").NullType;
-                        readonly second: import("@elaraai/east").NullType;
-                        readonly minute: import("@elaraai/east").NullType;
-                        readonly hour: import("@elaraai/east").NullType;
-                        readonly day: import("@elaraai/east").NullType;
-                        readonly week: import("@elaraai/east").NullType;
-                        readonly month: import("@elaraai/east").NullType;
-                        readonly year: import("@elaraai/east").NullType;
-                        readonly millimeter: import("@elaraai/east").NullType;
-                        readonly centimeter: import("@elaraai/east").NullType;
-                        readonly meter: import("@elaraai/east").NullType;
-                        readonly kilometer: import("@elaraai/east").NullType;
-                        readonly inch: import("@elaraai/east").NullType;
-                        readonly foot: import("@elaraai/east").NullType;
-                        readonly yard: import("@elaraai/east").NullType;
-                        readonly mile: import("@elaraai/east").NullType;
-                        readonly gram: import("@elaraai/east").NullType;
-                        readonly kilogram: import("@elaraai/east").NullType;
-                        readonly milligram: import("@elaraai/east").NullType;
-                        readonly ounce: import("@elaraai/east").NullType;
-                        readonly pound: import("@elaraai/east").NullType;
-                        readonly stone: import("@elaraai/east").NullType;
-                        readonly celsius: import("@elaraai/east").NullType;
-                        readonly fahrenheit: import("@elaraai/east").NullType;
-                        readonly milliliter: import("@elaraai/east").NullType;
-                        readonly liter: import("@elaraai/east").NullType;
-                        readonly gallon: import("@elaraai/east").NullType;
-                        readonly fluidOunce: import("@elaraai/east").NullType;
-                        readonly acre: import("@elaraai/east").NullType;
-                        readonly hectare: import("@elaraai/east").NullType;
-                        readonly meterPerSecond: import("@elaraai/east").NullType;
-                        readonly kilometerPerHour: import("@elaraai/east").NullType;
-                        readonly milePerHour: import("@elaraai/east").NullType;
-                        readonly percent: import("@elaraai/east").NullType;
-                        readonly degree: import("@elaraai/east").NullType;
-                    }>;
-                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                        readonly short: import("@elaraai/east").NullType;
-                        readonly narrow: import("@elaraai/east").NullType;
-                        readonly long: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly scientific: import("@elaraai/east").NullType;
-                readonly engineering: import("@elaraai/east").NullType;
-                readonly date: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly time: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-                readonly datetime: import("@elaraai/east").StructType<{
-                    readonly format: StringType;
-                }>;
-            }>>;
-            readonly valueAxis: OptionType<StructType<{
-                readonly label: StringType;
-                readonly signed: BooleanType;
-            }>>;
-            readonly summary: OptionType<StringType>;
-            readonly downside: OptionType<import("@elaraai/east").FloatType>;
-            readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-            readonly detail: OptionType<StringType>;
-            readonly stakes: OptionType<VariantType<{
-                readonly low: NullType;
-                readonly medium: NullType;
-                readonly high: NullType;
-                readonly critical: NullType;
-            }>>;
-            readonly prompts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly text: StringType;
-            }>>;
-            readonly levers: ArrayType<StructType<{
-                readonly case: StringType;
-                readonly label: StringType;
-            }>>;
-            readonly evidence: ArrayType<StructType<{
-                readonly label: StringType;
-                readonly text: StringType;
-                readonly note: OptionType<StringType>;
-            }>>;
-            readonly alternatives: ArrayType<StructType<{
-                readonly id: OptionType<StringType>;
-                readonly label: StringType;
-                readonly value: import("@elaraai/east").FloatType;
-                readonly downside: OptionType<import("@elaraai/east").FloatType>;
-                readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-                readonly note: OptionType<StringType>;
-            }>>;
-        }>], StringType>;
-    }>>>;
-    readonly groupBy: OptionType<StringType>;
-    readonly collapsible: OptionType<BooleanType>;
-}>;
-/** Type alias for {@link DecisionQueuePayloadType}. */
-export type DecisionQueuePayloadType = typeof DecisionQueuePayloadType;
-/**
- * Internal {@link EastUI.component} carrier. The React renderer registers
- * against this in `@elaraai/e3-ui-components` via `implementUIComponent`.
- */
-export declare const DecisionQueueComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
-    readonly handle: StructType<{
-        readonly decisions: ArrayType<StructType<{
-            readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>;
-            readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>>;
-            readonly mode: VariantType<{
-                readonly staged: NullType;
-                readonly direct: NullType;
-            }>;
-        }>>;
-        readonly judgements: StructType<{
-            readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>;
-            readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>>;
-            readonly mode: VariantType<{
-                readonly staged: NullType;
-                readonly direct: NullType;
-            }>;
-        }>;
-        readonly slice: OptionType<StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
+                readonly datetimePreset: 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;
@@ -2099,410 +1699,736 @@ export declare const DecisionQueueComponent: import("@elaraai/east-ui").UICompon
             readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
             readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
         }>>;
-    }>;
-    readonly heading: OptionType<StringType>;
-    readonly modify: OptionType<FunctionType<[StructType<{
-        readonly id: StringType;
-        readonly kind: StringType;
-        readonly title: StringType;
-        readonly urgency: VariantType<{
-            readonly overdue: NullType;
-            readonly due: NullType;
-            readonly routine: NullType;
-        }>;
-        readonly value: import("@elaraai/east").FloatType;
-        readonly deadline: OptionType<import("@elaraai/east").DateTimeType>;
-        readonly format: OptionType<VariantType<{
-            readonly number: import("@elaraai/east").StructType<{
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: import("@elaraai/east").NullType;
-                    readonly never: import("@elaraai/east").NullType;
-                    readonly always: import("@elaraai/east").NullType;
-                    readonly exceptZero: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-            readonly currency: import("@elaraai/east").StructType<{
-                readonly currency: import("@elaraai/east").VariantType<{
-                    readonly USD: import("@elaraai/east").NullType;
-                    readonly EUR: import("@elaraai/east").NullType;
-                    readonly GBP: import("@elaraai/east").NullType;
-                    readonly JPY: import("@elaraai/east").NullType;
-                    readonly CHF: import("@elaraai/east").NullType;
-                    readonly CAD: import("@elaraai/east").NullType;
-                    readonly AUD: import("@elaraai/east").NullType;
-                    readonly NZD: import("@elaraai/east").NullType;
-                    readonly CNY: import("@elaraai/east").NullType;
-                    readonly HKD: import("@elaraai/east").NullType;
-                    readonly SGD: import("@elaraai/east").NullType;
-                    readonly KRW: import("@elaraai/east").NullType;
-                    readonly INR: import("@elaraai/east").NullType;
-                    readonly TWD: import("@elaraai/east").NullType;
-                    readonly THB: import("@elaraai/east").NullType;
-                    readonly MYR: import("@elaraai/east").NullType;
-                    readonly IDR: import("@elaraai/east").NullType;
-                    readonly PHP: import("@elaraai/east").NullType;
-                    readonly VND: import("@elaraai/east").NullType;
-                    readonly SEK: import("@elaraai/east").NullType;
-                    readonly NOK: import("@elaraai/east").NullType;
-                    readonly DKK: import("@elaraai/east").NullType;
-                    readonly PLN: import("@elaraai/east").NullType;
-                    readonly CZK: import("@elaraai/east").NullType;
-                    readonly HUF: import("@elaraai/east").NullType;
-                    readonly RUB: import("@elaraai/east").NullType;
-                    readonly UAH: import("@elaraai/east").NullType;
-                    readonly RON: import("@elaraai/east").NullType;
-                    readonly MXN: import("@elaraai/east").NullType;
-                    readonly BRL: import("@elaraai/east").NullType;
-                    readonly ARS: import("@elaraai/east").NullType;
-                    readonly CLP: import("@elaraai/east").NullType;
-                    readonly COP: import("@elaraai/east").NullType;
-                    readonly PEN: import("@elaraai/east").NullType;
-                    readonly AED: import("@elaraai/east").NullType;
-                    readonly SAR: import("@elaraai/east").NullType;
-                    readonly ILS: import("@elaraai/east").NullType;
-                    readonly ZAR: import("@elaraai/east").NullType;
-                    readonly TRY: import("@elaraai/east").NullType;
-                    readonly EGP: import("@elaraai/east").NullType;
-                    readonly NGN: import("@elaraai/east").NullType;
-                    readonly KES: import("@elaraai/east").NullType;
+        readonly write: FunctionType<[StructType<{
+            readonly range: OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: import("@elaraai/east").DateTimeType;
+                    readonly to: import("@elaraai/east").DateTimeType;
                 }>;
-                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly code: import("@elaraai/east").NullType;
-                    readonly symbol: import("@elaraai/east").NullType;
-                    readonly narrowSymbol: import("@elaraai/east").NullType;
-                    readonly name: import("@elaraai/east").NullType;
-                }>>;
-                readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-            }>;
-            readonly percent: import("@elaraai/east").StructType<{
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: import("@elaraai/east").NullType;
-                    readonly never: import("@elaraai/east").NullType;
-                    readonly always: import("@elaraai/east").NullType;
-                    readonly exceptZero: import("@elaraai/east").NullType;
+                readonly datetimePreset: 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<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+            readonly cohorts: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: 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: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
                 }>>;
+            }>>;
+            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>;
+        }>], NullType>;
+        readonly setRange: FunctionType<[OptionType<VariantType<{
+            readonly datetime: StructType<{
+                readonly from: import("@elaraai/east").DateTimeType;
+                readonly to: import("@elaraai/east").DateTimeType;
             }>;
-            readonly compact: import("@elaraai/east").StructType<{
-                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
+            readonly datetimePreset: VariantType<{
+                readonly today: NullType;
+                readonly last7d: NullType;
+                readonly last30d: NullType;
+                readonly last90d: NullType;
+                readonly ytd: NullType;
             }>;
-            readonly unit: import("@elaraai/east").StructType<{
-                readonly unit: import("@elaraai/east").VariantType<{
-                    readonly bit: import("@elaraai/east").NullType;
-                    readonly byte: import("@elaraai/east").NullType;
-                    readonly kilobit: import("@elaraai/east").NullType;
-                    readonly kilobyte: import("@elaraai/east").NullType;
-                    readonly megabit: import("@elaraai/east").NullType;
-                    readonly megabyte: import("@elaraai/east").NullType;
-                    readonly gigabit: import("@elaraai/east").NullType;
-                    readonly gigabyte: import("@elaraai/east").NullType;
-                    readonly terabit: import("@elaraai/east").NullType;
-                    readonly terabyte: import("@elaraai/east").NullType;
-                    readonly petabyte: import("@elaraai/east").NullType;
-                    readonly nanosecond: import("@elaraai/east").NullType;
-                    readonly microsecond: import("@elaraai/east").NullType;
-                    readonly millisecond: import("@elaraai/east").NullType;
-                    readonly second: import("@elaraai/east").NullType;
-                    readonly minute: import("@elaraai/east").NullType;
-                    readonly hour: import("@elaraai/east").NullType;
-                    readonly day: import("@elaraai/east").NullType;
-                    readonly week: import("@elaraai/east").NullType;
-                    readonly month: import("@elaraai/east").NullType;
-                    readonly year: import("@elaraai/east").NullType;
-                    readonly millimeter: import("@elaraai/east").NullType;
-                    readonly centimeter: import("@elaraai/east").NullType;
-                    readonly meter: import("@elaraai/east").NullType;
-                    readonly kilometer: import("@elaraai/east").NullType;
-                    readonly inch: import("@elaraai/east").NullType;
-                    readonly foot: import("@elaraai/east").NullType;
-                    readonly yard: import("@elaraai/east").NullType;
-                    readonly mile: import("@elaraai/east").NullType;
-                    readonly gram: import("@elaraai/east").NullType;
-                    readonly kilogram: import("@elaraai/east").NullType;
-                    readonly milligram: import("@elaraai/east").NullType;
-                    readonly ounce: import("@elaraai/east").NullType;
-                    readonly pound: import("@elaraai/east").NullType;
-                    readonly stone: import("@elaraai/east").NullType;
-                    readonly celsius: import("@elaraai/east").NullType;
-                    readonly fahrenheit: import("@elaraai/east").NullType;
-                    readonly milliliter: import("@elaraai/east").NullType;
-                    readonly liter: import("@elaraai/east").NullType;
-                    readonly gallon: import("@elaraai/east").NullType;
-                    readonly fluidOunce: import("@elaraai/east").NullType;
-                    readonly acre: import("@elaraai/east").NullType;
-                    readonly hectare: import("@elaraai/east").NullType;
-                    readonly meterPerSecond: import("@elaraai/east").NullType;
-                    readonly kilometerPerHour: import("@elaraai/east").NullType;
-                    readonly milePerHour: import("@elaraai/east").NullType;
-                    readonly percent: import("@elaraai/east").NullType;
-                    readonly degree: import("@elaraai/east").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<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>], NullType>;
+        readonly addFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: NullType;
+                    readonly isNotEmpty: NullType;
                 }>;
-                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly narrow: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
             }>;
-            readonly scientific: import("@elaraai/east").NullType;
-            readonly engineering: import("@elaraai/east").NullType;
-            readonly date: import("@elaraai/east").StructType<{
-                readonly format: StringType;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 time: import("@elaraai/east").StructType<{
-                readonly format: StringType;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
             }>;
-            readonly datetime: import("@elaraai/east").StructType<{
-                readonly format: StringType;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 valueAxis: OptionType<StructType<{
-            readonly label: StringType;
-            readonly signed: BooleanType;
-        }>>;
-        readonly summary: OptionType<StringType>;
-        readonly downside: OptionType<import("@elaraai/east").FloatType>;
-        readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-        readonly detail: OptionType<StringType>;
-        readonly stakes: OptionType<VariantType<{
-            readonly low: NullType;
-            readonly medium: NullType;
-            readonly high: NullType;
-            readonly critical: NullType;
-        }>>;
-        readonly prompts: ArrayType<StructType<{
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 text: StringType;
-        }>>;
-        readonly levers: ArrayType<StructType<{
-            readonly case: StringType;
-            readonly label: StringType;
-        }>>;
-        readonly evidence: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly text: StringType;
-            readonly note: OptionType<StringType>;
-        }>>;
-        readonly alternatives: ArrayType<StructType<{
-            readonly id: OptionType<StringType>;
-            readonly label: StringType;
-            readonly value: import("@elaraai/east").FloatType;
-            readonly downside: OptionType<import("@elaraai/east").FloatType>;
-            readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-            readonly note: OptionType<StringType>;
-        }>>;
-    }>, FunctionType<[StructType<{
-        readonly id: StringType;
-        readonly kind: StringType;
-        readonly title: StringType;
-        readonly urgency: VariantType<{
-            readonly overdue: NullType;
-            readonly due: NullType;
-            readonly routine: NullType;
-        }>;
-        readonly value: import("@elaraai/east").FloatType;
-        readonly deadline: OptionType<import("@elaraai/east").DateTimeType>;
-        readonly format: OptionType<VariantType<{
-            readonly number: import("@elaraai/east").StructType<{
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: import("@elaraai/east").NullType;
-                    readonly never: import("@elaraai/east").NullType;
-                    readonly always: import("@elaraai/east").NullType;
-                    readonly exceptZero: import("@elaraai/east").NullType;
-                }>>;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly updateCohort: FunctionType<[StringType, StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], 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<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: 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<[], import("@elaraai/east").DictType<StringType, import("@elaraai/east").IntegerType>>;
+        readonly toggleFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: NullType;
+                    readonly isNotEmpty: NullType;
+                }>;
             }>;
-            readonly currency: import("@elaraai/east").StructType<{
-                readonly currency: import("@elaraai/east").VariantType<{
-                    readonly USD: import("@elaraai/east").NullType;
-                    readonly EUR: import("@elaraai/east").NullType;
-                    readonly GBP: import("@elaraai/east").NullType;
-                    readonly JPY: import("@elaraai/east").NullType;
-                    readonly CHF: import("@elaraai/east").NullType;
-                    readonly CAD: import("@elaraai/east").NullType;
-                    readonly AUD: import("@elaraai/east").NullType;
-                    readonly NZD: import("@elaraai/east").NullType;
-                    readonly CNY: import("@elaraai/east").NullType;
-                    readonly HKD: import("@elaraai/east").NullType;
-                    readonly SGD: import("@elaraai/east").NullType;
-                    readonly KRW: import("@elaraai/east").NullType;
-                    readonly INR: import("@elaraai/east").NullType;
-                    readonly TWD: import("@elaraai/east").NullType;
-                    readonly THB: import("@elaraai/east").NullType;
-                    readonly MYR: import("@elaraai/east").NullType;
-                    readonly IDR: import("@elaraai/east").NullType;
-                    readonly PHP: import("@elaraai/east").NullType;
-                    readonly VND: import("@elaraai/east").NullType;
-                    readonly SEK: import("@elaraai/east").NullType;
-                    readonly NOK: import("@elaraai/east").NullType;
-                    readonly DKK: import("@elaraai/east").NullType;
-                    readonly PLN: import("@elaraai/east").NullType;
-                    readonly CZK: import("@elaraai/east").NullType;
-                    readonly HUF: import("@elaraai/east").NullType;
-                    readonly RUB: import("@elaraai/east").NullType;
-                    readonly UAH: import("@elaraai/east").NullType;
-                    readonly RON: import("@elaraai/east").NullType;
-                    readonly MXN: import("@elaraai/east").NullType;
-                    readonly BRL: import("@elaraai/east").NullType;
-                    readonly ARS: import("@elaraai/east").NullType;
-                    readonly CLP: import("@elaraai/east").NullType;
-                    readonly COP: import("@elaraai/east").NullType;
-                    readonly PEN: import("@elaraai/east").NullType;
-                    readonly AED: import("@elaraai/east").NullType;
-                    readonly SAR: import("@elaraai/east").NullType;
-                    readonly ILS: import("@elaraai/east").NullType;
-                    readonly ZAR: import("@elaraai/east").NullType;
-                    readonly TRY: import("@elaraai/east").NullType;
-                    readonly EGP: import("@elaraai/east").NullType;
-                    readonly NGN: import("@elaraai/east").NullType;
-                    readonly KES: import("@elaraai/east").NullType;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly code: import("@elaraai/east").NullType;
-                    readonly symbol: import("@elaraai/east").NullType;
-                    readonly narrowSymbol: import("@elaraai/east").NullType;
-                    readonly name: import("@elaraai/east").NullType;
-                }>>;
-                readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
             }>;
-            readonly percent: import("@elaraai/east").StructType<{
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: import("@elaraai/east").NullType;
-                    readonly never: import("@elaraai/east").NullType;
-                    readonly always: import("@elaraai/east").NullType;
-                    readonly exceptZero: import("@elaraai/east").NullType;
-                }>>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
             }>;
-            readonly compact: import("@elaraai/east").StructType<{
-                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 unit: import("@elaraai/east").StructType<{
-                readonly unit: import("@elaraai/east").VariantType<{
-                    readonly bit: import("@elaraai/east").NullType;
-                    readonly byte: import("@elaraai/east").NullType;
-                    readonly kilobit: import("@elaraai/east").NullType;
-                    readonly kilobyte: import("@elaraai/east").NullType;
-                    readonly megabit: import("@elaraai/east").NullType;
-                    readonly megabyte: import("@elaraai/east").NullType;
-                    readonly gigabit: import("@elaraai/east").NullType;
-                    readonly gigabyte: import("@elaraai/east").NullType;
-                    readonly terabit: import("@elaraai/east").NullType;
-                    readonly terabyte: import("@elaraai/east").NullType;
-                    readonly petabyte: import("@elaraai/east").NullType;
-                    readonly nanosecond: import("@elaraai/east").NullType;
-                    readonly microsecond: import("@elaraai/east").NullType;
-                    readonly millisecond: import("@elaraai/east").NullType;
-                    readonly second: import("@elaraai/east").NullType;
-                    readonly minute: import("@elaraai/east").NullType;
-                    readonly hour: import("@elaraai/east").NullType;
-                    readonly day: import("@elaraai/east").NullType;
-                    readonly week: import("@elaraai/east").NullType;
-                    readonly month: import("@elaraai/east").NullType;
-                    readonly year: import("@elaraai/east").NullType;
-                    readonly millimeter: import("@elaraai/east").NullType;
-                    readonly centimeter: import("@elaraai/east").NullType;
-                    readonly meter: import("@elaraai/east").NullType;
-                    readonly kilometer: import("@elaraai/east").NullType;
-                    readonly inch: import("@elaraai/east").NullType;
-                    readonly foot: import("@elaraai/east").NullType;
-                    readonly yard: import("@elaraai/east").NullType;
-                    readonly mile: import("@elaraai/east").NullType;
-                    readonly gram: import("@elaraai/east").NullType;
-                    readonly kilogram: import("@elaraai/east").NullType;
-                    readonly milligram: import("@elaraai/east").NullType;
-                    readonly ounce: import("@elaraai/east").NullType;
-                    readonly pound: import("@elaraai/east").NullType;
-                    readonly stone: import("@elaraai/east").NullType;
-                    readonly celsius: import("@elaraai/east").NullType;
-                    readonly fahrenheit: import("@elaraai/east").NullType;
-                    readonly milliliter: import("@elaraai/east").NullType;
-                    readonly liter: import("@elaraai/east").NullType;
-                    readonly gallon: import("@elaraai/east").NullType;
-                    readonly fluidOunce: import("@elaraai/east").NullType;
-                    readonly acre: import("@elaraai/east").NullType;
-                    readonly hectare: import("@elaraai/east").NullType;
-                    readonly meterPerSecond: import("@elaraai/east").NullType;
-                    readonly kilometerPerHour: import("@elaraai/east").NullType;
-                    readonly milePerHour: import("@elaraai/east").NullType;
-                    readonly percent: import("@elaraai/east").NullType;
-                    readonly degree: import("@elaraai/east").NullType;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly is: BooleanType;
                 }>;
-                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly narrow: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-            readonly scientific: import("@elaraai/east").NullType;
-            readonly engineering: import("@elaraai/east").NullType;
-            readonly date: import("@elaraai/east").StructType<{
-                readonly format: StringType;
-            }>;
-            readonly time: import("@elaraai/east").StructType<{
-                readonly format: StringType;
-            }>;
-            readonly datetime: import("@elaraai/east").StructType<{
-                readonly format: StringType;
             }>;
-        }>>;
-        readonly valueAxis: OptionType<StructType<{
-            readonly label: StringType;
-            readonly signed: BooleanType;
-        }>>;
-        readonly summary: OptionType<StringType>;
-        readonly downside: OptionType<import("@elaraai/east").FloatType>;
-        readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-        readonly detail: OptionType<StringType>;
-        readonly stakes: OptionType<VariantType<{
-            readonly low: NullType;
-            readonly medium: NullType;
-            readonly high: NullType;
-            readonly critical: NullType;
-        }>>;
-        readonly prompts: ArrayType<StructType<{
+        }>], NullType>;
+        readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: import("@elaraai/east").IntegerType;
+            readonly color: StringType;
+        }>>>;
+    }>>;
+    readonly affordances: OptionType<ArrayType<VariantType<{
+        readonly filter: NullType;
+        readonly search: NullType;
+        readonly breakdown: NullType;
+        readonly range: NullType;
+        readonly cohort: NullType;
+        readonly brush: NullType;
+        readonly presets: NullType;
+        readonly legend: NullType;
+    }>>>;
+    readonly maxHeight: OptionType<StringType>;
+    readonly density: OptionType<VariantType<{
+        readonly comfortable: NullType;
+        readonly compact: NullType;
+        readonly condensed: NullType;
+    }>>;
+    readonly groups: OptionType<ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: FunctionType<[StructType<{
             readonly id: StringType;
-            readonly text: StringType;
-        }>>;
-        readonly levers: ArrayType<StructType<{
-            readonly case: StringType;
-            readonly label: StringType;
-        }>>;
-        readonly evidence: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly text: StringType;
-            readonly note: OptionType<StringType>;
-        }>>;
-        readonly alternatives: ArrayType<StructType<{
-            readonly id: OptionType<StringType>;
-            readonly label: StringType;
+            readonly kind: StringType;
+            readonly title: StringType;
+            readonly urgency: VariantType<{
+                readonly overdue: NullType;
+                readonly due: NullType;
+                readonly routine: NullType;
+            }>;
             readonly value: import("@elaraai/east").FloatType;
+            readonly deadline: OptionType<import("@elaraai/east").DateTimeType>;
+            readonly format: OptionType<VariantType<{
+                readonly number: import("@elaraai/east").StructType<{
+                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                    readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly auto: import("@elaraai/east").NullType;
+                        readonly never: import("@elaraai/east").NullType;
+                        readonly always: import("@elaraai/east").NullType;
+                        readonly exceptZero: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly currency: import("@elaraai/east").StructType<{
+                    readonly currency: import("@elaraai/east").VariantType<{
+                        readonly USD: import("@elaraai/east").NullType;
+                        readonly EUR: import("@elaraai/east").NullType;
+                        readonly GBP: import("@elaraai/east").NullType;
+                        readonly JPY: import("@elaraai/east").NullType;
+                        readonly CHF: import("@elaraai/east").NullType;
+                        readonly CAD: import("@elaraai/east").NullType;
+                        readonly AUD: import("@elaraai/east").NullType;
+                        readonly NZD: import("@elaraai/east").NullType;
+                        readonly CNY: import("@elaraai/east").NullType;
+                        readonly HKD: import("@elaraai/east").NullType;
+                        readonly SGD: import("@elaraai/east").NullType;
+                        readonly KRW: import("@elaraai/east").NullType;
+                        readonly INR: import("@elaraai/east").NullType;
+                        readonly TWD: import("@elaraai/east").NullType;
+                        readonly THB: import("@elaraai/east").NullType;
+                        readonly MYR: import("@elaraai/east").NullType;
+                        readonly IDR: import("@elaraai/east").NullType;
+                        readonly PHP: import("@elaraai/east").NullType;
+                        readonly VND: import("@elaraai/east").NullType;
+                        readonly SEK: import("@elaraai/east").NullType;
+                        readonly NOK: import("@elaraai/east").NullType;
+                        readonly DKK: import("@elaraai/east").NullType;
+                        readonly PLN: import("@elaraai/east").NullType;
+                        readonly CZK: import("@elaraai/east").NullType;
+                        readonly HUF: import("@elaraai/east").NullType;
+                        readonly RUB: import("@elaraai/east").NullType;
+                        readonly UAH: import("@elaraai/east").NullType;
+                        readonly RON: import("@elaraai/east").NullType;
+                        readonly MXN: import("@elaraai/east").NullType;
+                        readonly BRL: import("@elaraai/east").NullType;
+                        readonly ARS: import("@elaraai/east").NullType;
+                        readonly CLP: import("@elaraai/east").NullType;
+                        readonly COP: import("@elaraai/east").NullType;
+                        readonly PEN: import("@elaraai/east").NullType;
+                        readonly AED: import("@elaraai/east").NullType;
+                        readonly SAR: import("@elaraai/east").NullType;
+                        readonly ILS: import("@elaraai/east").NullType;
+                        readonly ZAR: import("@elaraai/east").NullType;
+                        readonly TRY: import("@elaraai/east").NullType;
+                        readonly EGP: import("@elaraai/east").NullType;
+                        readonly NGN: import("@elaraai/east").NullType;
+                        readonly KES: import("@elaraai/east").NullType;
+                    }>;
+                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly code: import("@elaraai/east").NullType;
+                        readonly symbol: import("@elaraai/east").NullType;
+                        readonly narrowSymbol: import("@elaraai/east").NullType;
+                        readonly name: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly short: import("@elaraai/east").NullType;
+                        readonly long: import("@elaraai/east").NullType;
+                    }>>;
+                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                readonly percent: import("@elaraai/east").StructType<{
+                    readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                    readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                    readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly auto: import("@elaraai/east").NullType;
+                        readonly never: import("@elaraai/east").NullType;
+                        readonly always: import("@elaraai/east").NullType;
+                        readonly exceptZero: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly compact: import("@elaraai/east").StructType<{
+                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly short: import("@elaraai/east").NullType;
+                        readonly long: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly unit: import("@elaraai/east").StructType<{
+                    readonly unit: import("@elaraai/east").VariantType<{
+                        readonly bit: import("@elaraai/east").NullType;
+                        readonly byte: import("@elaraai/east").NullType;
+                        readonly kilobit: import("@elaraai/east").NullType;
+                        readonly kilobyte: import("@elaraai/east").NullType;
+                        readonly megabit: import("@elaraai/east").NullType;
+                        readonly megabyte: import("@elaraai/east").NullType;
+                        readonly gigabit: import("@elaraai/east").NullType;
+                        readonly gigabyte: import("@elaraai/east").NullType;
+                        readonly terabit: import("@elaraai/east").NullType;
+                        readonly terabyte: import("@elaraai/east").NullType;
+                        readonly petabyte: import("@elaraai/east").NullType;
+                        readonly nanosecond: import("@elaraai/east").NullType;
+                        readonly microsecond: import("@elaraai/east").NullType;
+                        readonly millisecond: import("@elaraai/east").NullType;
+                        readonly second: import("@elaraai/east").NullType;
+                        readonly minute: import("@elaraai/east").NullType;
+                        readonly hour: import("@elaraai/east").NullType;
+                        readonly day: import("@elaraai/east").NullType;
+                        readonly week: import("@elaraai/east").NullType;
+                        readonly month: import("@elaraai/east").NullType;
+                        readonly year: import("@elaraai/east").NullType;
+                        readonly millimeter: import("@elaraai/east").NullType;
+                        readonly centimeter: import("@elaraai/east").NullType;
+                        readonly meter: import("@elaraai/east").NullType;
+                        readonly kilometer: import("@elaraai/east").NullType;
+                        readonly inch: import("@elaraai/east").NullType;
+                        readonly foot: import("@elaraai/east").NullType;
+                        readonly yard: import("@elaraai/east").NullType;
+                        readonly mile: import("@elaraai/east").NullType;
+                        readonly gram: import("@elaraai/east").NullType;
+                        readonly kilogram: import("@elaraai/east").NullType;
+                        readonly milligram: import("@elaraai/east").NullType;
+                        readonly ounce: import("@elaraai/east").NullType;
+                        readonly pound: import("@elaraai/east").NullType;
+                        readonly stone: import("@elaraai/east").NullType;
+                        readonly celsius: import("@elaraai/east").NullType;
+                        readonly fahrenheit: import("@elaraai/east").NullType;
+                        readonly milliliter: import("@elaraai/east").NullType;
+                        readonly liter: import("@elaraai/east").NullType;
+                        readonly gallon: import("@elaraai/east").NullType;
+                        readonly fluidOunce: import("@elaraai/east").NullType;
+                        readonly acre: import("@elaraai/east").NullType;
+                        readonly hectare: import("@elaraai/east").NullType;
+                        readonly meterPerSecond: import("@elaraai/east").NullType;
+                        readonly kilometerPerHour: import("@elaraai/east").NullType;
+                        readonly milePerHour: import("@elaraai/east").NullType;
+                        readonly percent: import("@elaraai/east").NullType;
+                        readonly degree: import("@elaraai/east").NullType;
+                    }>;
+                    readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                        readonly short: import("@elaraai/east").NullType;
+                        readonly narrow: import("@elaraai/east").NullType;
+                        readonly long: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly scientific: import("@elaraai/east").NullType;
+                readonly engineering: import("@elaraai/east").NullType;
+                readonly date: import("@elaraai/east").StructType<{
+                    readonly format: StringType;
+                }>;
+                readonly time: import("@elaraai/east").StructType<{
+                    readonly format: StringType;
+                }>;
+                readonly datetime: import("@elaraai/east").StructType<{
+                    readonly format: StringType;
+                }>;
+            }>>;
+            readonly valueAxis: OptionType<StructType<{
+                readonly label: StringType;
+                readonly signed: BooleanType;
+            }>>;
+            readonly summary: OptionType<StringType>;
             readonly downside: OptionType<import("@elaraai/east").FloatType>;
             readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-            readonly note: OptionType<StringType>;
-        }>>;
-    }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
-    readonly evidence: OptionType<FunctionType<[StructType<{
+            readonly detail: OptionType<StringType>;
+            readonly stakes: OptionType<VariantType<{
+                readonly low: NullType;
+                readonly medium: NullType;
+                readonly high: NullType;
+                readonly critical: NullType;
+            }>>;
+            readonly prompts: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly text: StringType;
+            }>>;
+            readonly levers: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly evidence: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly text: StringType;
+                readonly note: OptionType<StringType>;
+            }>>;
+            readonly alternatives: ArrayType<StructType<{
+                readonly id: OptionType<StringType>;
+                readonly label: StringType;
+                readonly value: import("@elaraai/east").FloatType;
+                readonly downside: OptionType<import("@elaraai/east").FloatType>;
+                readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+                readonly note: OptionType<StringType>;
+            }>>;
+        }>], StringType>;
+    }>>>;
+    readonly groupBy: OptionType<StringType>;
+    readonly collapsible: OptionType<BooleanType>;
+}>;
+/** Type alias for {@link DecisionQueuePayloadType}. */
+export type DecisionQueuePayloadType = typeof DecisionQueuePayloadType;
+/**
+ * Internal {@link EastUI.component} carrier. The React renderer registers
+ * against this in `@elaraai/e3-ui-components` via `implementUIComponent`.
+ */
+export declare const DecisionQueueComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
+    readonly handle: StructType<{
+        readonly decisions: ArrayType<StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>>;
+        readonly judgements: StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>;
+    }>;
+    readonly heading: OptionType<StringType>;
+    readonly modify: OptionType<FunctionType<[StructType<{
         readonly id: StringType;
         readonly kind: StringType;
         readonly title: StringType;
@@ -2702,8 +2628,7 @@ export declare const DecisionQueueComponent: import("@elaraai/east-ui").UICompon
             readonly confidence: OptionType<import("@elaraai/east").FloatType>;
             readonly note: OptionType<StringType>;
         }>>;
-    }>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
-    readonly defaultExpanded: OptionType<StructType<{
+    }>, FunctionType<[StructType<{
         readonly id: StringType;
         readonly kind: StringType;
         readonly title: StringType;
@@ -2903,19 +2828,8 @@ export declare const DecisionQueueComponent: import("@elaraai/east-ui").UICompon
             readonly confidence: OptionType<import("@elaraai/east").FloatType>;
             readonly note: OptionType<StringType>;
         }>>;
-    }>>;
-    readonly defaultFacet: OptionType<VariantType<{
-        readonly evidence: NullType;
-        readonly options: NullType;
-        readonly judgement: NullType;
-        readonly modify: NullType;
-    }>>;
-    readonly facets: OptionType<ArrayType<VariantType<{
-        readonly evidence: NullType;
-        readonly options: NullType;
-        readonly judgement: NullType;
-    }>>>;
-    readonly onApply: OptionType<FunctionType<[StructType<{
+    }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly evidence: OptionType<FunctionType<[StructType<{
         readonly id: StringType;
         readonly kind: StringType;
         readonly title: StringType;
@@ -3115,8 +3029,8 @@ export declare const DecisionQueueComponent: import("@elaraai/east-ui").UICompon
             readonly confidence: OptionType<import("@elaraai/east").FloatType>;
             readonly note: OptionType<StringType>;
         }>>;
-    }>], NullType>>;
-    readonly onReject: OptionType<FunctionType<[StructType<{
+    }>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly defaultExpanded: OptionType<StructType<{
         readonly id: StringType;
         readonly kind: StringType;
         readonly title: StringType;
@@ -3196,128 +3110,1164 @@ export declare const DecisionQueueComponent: import("@elaraai/east-ui").UICompon
                 readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
                 readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
             }>;
-            readonly percent: import("@elaraai/east").StructType<{
-                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
-                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly auto: import("@elaraai/east").NullType;
-                    readonly never: import("@elaraai/east").NullType;
-                    readonly always: import("@elaraai/east").NullType;
-                    readonly exceptZero: import("@elaraai/east").NullType;
-                }>>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: import("@elaraai/east").NullType;
+                    readonly never: import("@elaraai/east").NullType;
+                    readonly always: import("@elaraai/east").NullType;
+                    readonly exceptZero: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly compact: import("@elaraai/east").StructType<{
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly unit: import("@elaraai/east").StructType<{
+                readonly unit: import("@elaraai/east").VariantType<{
+                    readonly bit: import("@elaraai/east").NullType;
+                    readonly byte: import("@elaraai/east").NullType;
+                    readonly kilobit: import("@elaraai/east").NullType;
+                    readonly kilobyte: import("@elaraai/east").NullType;
+                    readonly megabit: import("@elaraai/east").NullType;
+                    readonly megabyte: import("@elaraai/east").NullType;
+                    readonly gigabit: import("@elaraai/east").NullType;
+                    readonly gigabyte: import("@elaraai/east").NullType;
+                    readonly terabit: import("@elaraai/east").NullType;
+                    readonly terabyte: import("@elaraai/east").NullType;
+                    readonly petabyte: import("@elaraai/east").NullType;
+                    readonly nanosecond: import("@elaraai/east").NullType;
+                    readonly microsecond: import("@elaraai/east").NullType;
+                    readonly millisecond: import("@elaraai/east").NullType;
+                    readonly second: import("@elaraai/east").NullType;
+                    readonly minute: import("@elaraai/east").NullType;
+                    readonly hour: import("@elaraai/east").NullType;
+                    readonly day: import("@elaraai/east").NullType;
+                    readonly week: import("@elaraai/east").NullType;
+                    readonly month: import("@elaraai/east").NullType;
+                    readonly year: import("@elaraai/east").NullType;
+                    readonly millimeter: import("@elaraai/east").NullType;
+                    readonly centimeter: import("@elaraai/east").NullType;
+                    readonly meter: import("@elaraai/east").NullType;
+                    readonly kilometer: import("@elaraai/east").NullType;
+                    readonly inch: import("@elaraai/east").NullType;
+                    readonly foot: import("@elaraai/east").NullType;
+                    readonly yard: import("@elaraai/east").NullType;
+                    readonly mile: import("@elaraai/east").NullType;
+                    readonly gram: import("@elaraai/east").NullType;
+                    readonly kilogram: import("@elaraai/east").NullType;
+                    readonly milligram: import("@elaraai/east").NullType;
+                    readonly ounce: import("@elaraai/east").NullType;
+                    readonly pound: import("@elaraai/east").NullType;
+                    readonly stone: import("@elaraai/east").NullType;
+                    readonly celsius: import("@elaraai/east").NullType;
+                    readonly fahrenheit: import("@elaraai/east").NullType;
+                    readonly milliliter: import("@elaraai/east").NullType;
+                    readonly liter: import("@elaraai/east").NullType;
+                    readonly gallon: import("@elaraai/east").NullType;
+                    readonly fluidOunce: import("@elaraai/east").NullType;
+                    readonly acre: import("@elaraai/east").NullType;
+                    readonly hectare: import("@elaraai/east").NullType;
+                    readonly meterPerSecond: import("@elaraai/east").NullType;
+                    readonly kilometerPerHour: import("@elaraai/east").NullType;
+                    readonly milePerHour: import("@elaraai/east").NullType;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly degree: import("@elaraai/east").NullType;
+                }>;
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly narrow: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly scientific: import("@elaraai/east").NullType;
+            readonly engineering: import("@elaraai/east").NullType;
+            readonly date: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+            readonly time: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+            readonly datetime: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+        }>>;
+        readonly valueAxis: OptionType<StructType<{
+            readonly label: StringType;
+            readonly signed: BooleanType;
+        }>>;
+        readonly summary: OptionType<StringType>;
+        readonly downside: OptionType<import("@elaraai/east").FloatType>;
+        readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+        readonly detail: OptionType<StringType>;
+        readonly stakes: OptionType<VariantType<{
+            readonly low: NullType;
+            readonly medium: NullType;
+            readonly high: NullType;
+            readonly critical: NullType;
+        }>>;
+        readonly prompts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly text: StringType;
+        }>>;
+        readonly levers: ArrayType<StructType<{
+            readonly case: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly evidence: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly text: StringType;
+            readonly note: OptionType<StringType>;
+        }>>;
+        readonly alternatives: ArrayType<StructType<{
+            readonly id: OptionType<StringType>;
+            readonly label: StringType;
+            readonly value: import("@elaraai/east").FloatType;
+            readonly downside: OptionType<import("@elaraai/east").FloatType>;
+            readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+            readonly note: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly defaultFacet: OptionType<VariantType<{
+        readonly evidence: NullType;
+        readonly options: NullType;
+        readonly judgement: NullType;
+        readonly modify: NullType;
+    }>>;
+    readonly facets: OptionType<ArrayType<VariantType<{
+        readonly evidence: NullType;
+        readonly options: NullType;
+        readonly judgement: NullType;
+    }>>>;
+    readonly onApply: OptionType<FunctionType<[StructType<{
+        readonly id: StringType;
+        readonly kind: StringType;
+        readonly title: StringType;
+        readonly urgency: VariantType<{
+            readonly overdue: NullType;
+            readonly due: NullType;
+            readonly routine: NullType;
+        }>;
+        readonly value: import("@elaraai/east").FloatType;
+        readonly deadline: OptionType<import("@elaraai/east").DateTimeType>;
+        readonly format: OptionType<VariantType<{
+            readonly number: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: import("@elaraai/east").NullType;
+                    readonly never: import("@elaraai/east").NullType;
+                    readonly always: import("@elaraai/east").NullType;
+                    readonly exceptZero: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly currency: import("@elaraai/east").StructType<{
+                readonly currency: import("@elaraai/east").VariantType<{
+                    readonly USD: import("@elaraai/east").NullType;
+                    readonly EUR: import("@elaraai/east").NullType;
+                    readonly GBP: import("@elaraai/east").NullType;
+                    readonly JPY: import("@elaraai/east").NullType;
+                    readonly CHF: import("@elaraai/east").NullType;
+                    readonly CAD: import("@elaraai/east").NullType;
+                    readonly AUD: import("@elaraai/east").NullType;
+                    readonly NZD: import("@elaraai/east").NullType;
+                    readonly CNY: import("@elaraai/east").NullType;
+                    readonly HKD: import("@elaraai/east").NullType;
+                    readonly SGD: import("@elaraai/east").NullType;
+                    readonly KRW: import("@elaraai/east").NullType;
+                    readonly INR: import("@elaraai/east").NullType;
+                    readonly TWD: import("@elaraai/east").NullType;
+                    readonly THB: import("@elaraai/east").NullType;
+                    readonly MYR: import("@elaraai/east").NullType;
+                    readonly IDR: import("@elaraai/east").NullType;
+                    readonly PHP: import("@elaraai/east").NullType;
+                    readonly VND: import("@elaraai/east").NullType;
+                    readonly SEK: import("@elaraai/east").NullType;
+                    readonly NOK: import("@elaraai/east").NullType;
+                    readonly DKK: import("@elaraai/east").NullType;
+                    readonly PLN: import("@elaraai/east").NullType;
+                    readonly CZK: import("@elaraai/east").NullType;
+                    readonly HUF: import("@elaraai/east").NullType;
+                    readonly RUB: import("@elaraai/east").NullType;
+                    readonly UAH: import("@elaraai/east").NullType;
+                    readonly RON: import("@elaraai/east").NullType;
+                    readonly MXN: import("@elaraai/east").NullType;
+                    readonly BRL: import("@elaraai/east").NullType;
+                    readonly ARS: import("@elaraai/east").NullType;
+                    readonly CLP: import("@elaraai/east").NullType;
+                    readonly COP: import("@elaraai/east").NullType;
+                    readonly PEN: import("@elaraai/east").NullType;
+                    readonly AED: import("@elaraai/east").NullType;
+                    readonly SAR: import("@elaraai/east").NullType;
+                    readonly ILS: import("@elaraai/east").NullType;
+                    readonly ZAR: import("@elaraai/east").NullType;
+                    readonly TRY: import("@elaraai/east").NullType;
+                    readonly EGP: import("@elaraai/east").NullType;
+                    readonly NGN: import("@elaraai/east").NullType;
+                    readonly KES: import("@elaraai/east").NullType;
+                }>;
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly code: import("@elaraai/east").NullType;
+                    readonly symbol: import("@elaraai/east").NullType;
+                    readonly narrowSymbol: import("@elaraai/east").NullType;
+                    readonly name: import("@elaraai/east").NullType;
+                }>>;
+                readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: import("@elaraai/east").NullType;
+                    readonly never: import("@elaraai/east").NullType;
+                    readonly always: import("@elaraai/east").NullType;
+                    readonly exceptZero: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly compact: import("@elaraai/east").StructType<{
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly unit: import("@elaraai/east").StructType<{
+                readonly unit: import("@elaraai/east").VariantType<{
+                    readonly bit: import("@elaraai/east").NullType;
+                    readonly byte: import("@elaraai/east").NullType;
+                    readonly kilobit: import("@elaraai/east").NullType;
+                    readonly kilobyte: import("@elaraai/east").NullType;
+                    readonly megabit: import("@elaraai/east").NullType;
+                    readonly megabyte: import("@elaraai/east").NullType;
+                    readonly gigabit: import("@elaraai/east").NullType;
+                    readonly gigabyte: import("@elaraai/east").NullType;
+                    readonly terabit: import("@elaraai/east").NullType;
+                    readonly terabyte: import("@elaraai/east").NullType;
+                    readonly petabyte: import("@elaraai/east").NullType;
+                    readonly nanosecond: import("@elaraai/east").NullType;
+                    readonly microsecond: import("@elaraai/east").NullType;
+                    readonly millisecond: import("@elaraai/east").NullType;
+                    readonly second: import("@elaraai/east").NullType;
+                    readonly minute: import("@elaraai/east").NullType;
+                    readonly hour: import("@elaraai/east").NullType;
+                    readonly day: import("@elaraai/east").NullType;
+                    readonly week: import("@elaraai/east").NullType;
+                    readonly month: import("@elaraai/east").NullType;
+                    readonly year: import("@elaraai/east").NullType;
+                    readonly millimeter: import("@elaraai/east").NullType;
+                    readonly centimeter: import("@elaraai/east").NullType;
+                    readonly meter: import("@elaraai/east").NullType;
+                    readonly kilometer: import("@elaraai/east").NullType;
+                    readonly inch: import("@elaraai/east").NullType;
+                    readonly foot: import("@elaraai/east").NullType;
+                    readonly yard: import("@elaraai/east").NullType;
+                    readonly mile: import("@elaraai/east").NullType;
+                    readonly gram: import("@elaraai/east").NullType;
+                    readonly kilogram: import("@elaraai/east").NullType;
+                    readonly milligram: import("@elaraai/east").NullType;
+                    readonly ounce: import("@elaraai/east").NullType;
+                    readonly pound: import("@elaraai/east").NullType;
+                    readonly stone: import("@elaraai/east").NullType;
+                    readonly celsius: import("@elaraai/east").NullType;
+                    readonly fahrenheit: import("@elaraai/east").NullType;
+                    readonly milliliter: import("@elaraai/east").NullType;
+                    readonly liter: import("@elaraai/east").NullType;
+                    readonly gallon: import("@elaraai/east").NullType;
+                    readonly fluidOunce: import("@elaraai/east").NullType;
+                    readonly acre: import("@elaraai/east").NullType;
+                    readonly hectare: import("@elaraai/east").NullType;
+                    readonly meterPerSecond: import("@elaraai/east").NullType;
+                    readonly kilometerPerHour: import("@elaraai/east").NullType;
+                    readonly milePerHour: import("@elaraai/east").NullType;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly degree: import("@elaraai/east").NullType;
+                }>;
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly narrow: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly scientific: import("@elaraai/east").NullType;
+            readonly engineering: import("@elaraai/east").NullType;
+            readonly date: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+            readonly time: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+            readonly datetime: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+        }>>;
+        readonly valueAxis: OptionType<StructType<{
+            readonly label: StringType;
+            readonly signed: BooleanType;
+        }>>;
+        readonly summary: OptionType<StringType>;
+        readonly downside: OptionType<import("@elaraai/east").FloatType>;
+        readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+        readonly detail: OptionType<StringType>;
+        readonly stakes: OptionType<VariantType<{
+            readonly low: NullType;
+            readonly medium: NullType;
+            readonly high: NullType;
+            readonly critical: NullType;
+        }>>;
+        readonly prompts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly text: StringType;
+        }>>;
+        readonly levers: ArrayType<StructType<{
+            readonly case: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly evidence: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly text: StringType;
+            readonly note: OptionType<StringType>;
+        }>>;
+        readonly alternatives: ArrayType<StructType<{
+            readonly id: OptionType<StringType>;
+            readonly label: StringType;
+            readonly value: import("@elaraai/east").FloatType;
+            readonly downside: OptionType<import("@elaraai/east").FloatType>;
+            readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+            readonly note: OptionType<StringType>;
+        }>>;
+    }>], NullType>>;
+    readonly onReject: OptionType<FunctionType<[StructType<{
+        readonly id: StringType;
+        readonly kind: StringType;
+        readonly title: StringType;
+        readonly urgency: VariantType<{
+            readonly overdue: NullType;
+            readonly due: NullType;
+            readonly routine: NullType;
+        }>;
+        readonly value: import("@elaraai/east").FloatType;
+        readonly deadline: OptionType<import("@elaraai/east").DateTimeType>;
+        readonly format: OptionType<VariantType<{
+            readonly number: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: import("@elaraai/east").NullType;
+                    readonly never: import("@elaraai/east").NullType;
+                    readonly always: import("@elaraai/east").NullType;
+                    readonly exceptZero: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly currency: import("@elaraai/east").StructType<{
+                readonly currency: import("@elaraai/east").VariantType<{
+                    readonly USD: import("@elaraai/east").NullType;
+                    readonly EUR: import("@elaraai/east").NullType;
+                    readonly GBP: import("@elaraai/east").NullType;
+                    readonly JPY: import("@elaraai/east").NullType;
+                    readonly CHF: import("@elaraai/east").NullType;
+                    readonly CAD: import("@elaraai/east").NullType;
+                    readonly AUD: import("@elaraai/east").NullType;
+                    readonly NZD: import("@elaraai/east").NullType;
+                    readonly CNY: import("@elaraai/east").NullType;
+                    readonly HKD: import("@elaraai/east").NullType;
+                    readonly SGD: import("@elaraai/east").NullType;
+                    readonly KRW: import("@elaraai/east").NullType;
+                    readonly INR: import("@elaraai/east").NullType;
+                    readonly TWD: import("@elaraai/east").NullType;
+                    readonly THB: import("@elaraai/east").NullType;
+                    readonly MYR: import("@elaraai/east").NullType;
+                    readonly IDR: import("@elaraai/east").NullType;
+                    readonly PHP: import("@elaraai/east").NullType;
+                    readonly VND: import("@elaraai/east").NullType;
+                    readonly SEK: import("@elaraai/east").NullType;
+                    readonly NOK: import("@elaraai/east").NullType;
+                    readonly DKK: import("@elaraai/east").NullType;
+                    readonly PLN: import("@elaraai/east").NullType;
+                    readonly CZK: import("@elaraai/east").NullType;
+                    readonly HUF: import("@elaraai/east").NullType;
+                    readonly RUB: import("@elaraai/east").NullType;
+                    readonly UAH: import("@elaraai/east").NullType;
+                    readonly RON: import("@elaraai/east").NullType;
+                    readonly MXN: import("@elaraai/east").NullType;
+                    readonly BRL: import("@elaraai/east").NullType;
+                    readonly ARS: import("@elaraai/east").NullType;
+                    readonly CLP: import("@elaraai/east").NullType;
+                    readonly COP: import("@elaraai/east").NullType;
+                    readonly PEN: import("@elaraai/east").NullType;
+                    readonly AED: import("@elaraai/east").NullType;
+                    readonly SAR: import("@elaraai/east").NullType;
+                    readonly ILS: import("@elaraai/east").NullType;
+                    readonly ZAR: import("@elaraai/east").NullType;
+                    readonly TRY: import("@elaraai/east").NullType;
+                    readonly EGP: import("@elaraai/east").NullType;
+                    readonly NGN: import("@elaraai/east").NullType;
+                    readonly KES: import("@elaraai/east").NullType;
+                }>;
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly code: import("@elaraai/east").NullType;
+                    readonly symbol: import("@elaraai/east").NullType;
+                    readonly narrowSymbol: import("@elaraai/east").NullType;
+                    readonly name: import("@elaraai/east").NullType;
+                }>>;
+                readonly compact: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly signDisplay: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: import("@elaraai/east").NullType;
+                    readonly never: import("@elaraai/east").NullType;
+                    readonly always: import("@elaraai/east").NullType;
+                    readonly exceptZero: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly compact: import("@elaraai/east").StructType<{
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly unit: import("@elaraai/east").StructType<{
+                readonly unit: import("@elaraai/east").VariantType<{
+                    readonly bit: import("@elaraai/east").NullType;
+                    readonly byte: import("@elaraai/east").NullType;
+                    readonly kilobit: import("@elaraai/east").NullType;
+                    readonly kilobyte: import("@elaraai/east").NullType;
+                    readonly megabit: import("@elaraai/east").NullType;
+                    readonly megabyte: import("@elaraai/east").NullType;
+                    readonly gigabit: import("@elaraai/east").NullType;
+                    readonly gigabyte: import("@elaraai/east").NullType;
+                    readonly terabit: import("@elaraai/east").NullType;
+                    readonly terabyte: import("@elaraai/east").NullType;
+                    readonly petabyte: import("@elaraai/east").NullType;
+                    readonly nanosecond: import("@elaraai/east").NullType;
+                    readonly microsecond: import("@elaraai/east").NullType;
+                    readonly millisecond: import("@elaraai/east").NullType;
+                    readonly second: import("@elaraai/east").NullType;
+                    readonly minute: import("@elaraai/east").NullType;
+                    readonly hour: import("@elaraai/east").NullType;
+                    readonly day: import("@elaraai/east").NullType;
+                    readonly week: import("@elaraai/east").NullType;
+                    readonly month: import("@elaraai/east").NullType;
+                    readonly year: import("@elaraai/east").NullType;
+                    readonly millimeter: import("@elaraai/east").NullType;
+                    readonly centimeter: import("@elaraai/east").NullType;
+                    readonly meter: import("@elaraai/east").NullType;
+                    readonly kilometer: import("@elaraai/east").NullType;
+                    readonly inch: import("@elaraai/east").NullType;
+                    readonly foot: import("@elaraai/east").NullType;
+                    readonly yard: import("@elaraai/east").NullType;
+                    readonly mile: import("@elaraai/east").NullType;
+                    readonly gram: import("@elaraai/east").NullType;
+                    readonly kilogram: import("@elaraai/east").NullType;
+                    readonly milligram: import("@elaraai/east").NullType;
+                    readonly ounce: import("@elaraai/east").NullType;
+                    readonly pound: import("@elaraai/east").NullType;
+                    readonly stone: import("@elaraai/east").NullType;
+                    readonly celsius: import("@elaraai/east").NullType;
+                    readonly fahrenheit: import("@elaraai/east").NullType;
+                    readonly milliliter: import("@elaraai/east").NullType;
+                    readonly liter: import("@elaraai/east").NullType;
+                    readonly gallon: import("@elaraai/east").NullType;
+                    readonly fluidOunce: import("@elaraai/east").NullType;
+                    readonly acre: import("@elaraai/east").NullType;
+                    readonly hectare: import("@elaraai/east").NullType;
+                    readonly meterPerSecond: import("@elaraai/east").NullType;
+                    readonly kilometerPerHour: import("@elaraai/east").NullType;
+                    readonly milePerHour: import("@elaraai/east").NullType;
+                    readonly percent: import("@elaraai/east").NullType;
+                    readonly degree: import("@elaraai/east").NullType;
+                }>;
+                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+                    readonly short: import("@elaraai/east").NullType;
+                    readonly narrow: import("@elaraai/east").NullType;
+                    readonly long: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly scientific: import("@elaraai/east").NullType;
+            readonly engineering: import("@elaraai/east").NullType;
+            readonly date: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+            readonly time: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+            readonly datetime: import("@elaraai/east").StructType<{
+                readonly format: StringType;
+            }>;
+        }>>;
+        readonly valueAxis: OptionType<StructType<{
+            readonly label: StringType;
+            readonly signed: BooleanType;
+        }>>;
+        readonly summary: OptionType<StringType>;
+        readonly downside: OptionType<import("@elaraai/east").FloatType>;
+        readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+        readonly detail: OptionType<StringType>;
+        readonly stakes: OptionType<VariantType<{
+            readonly low: NullType;
+            readonly medium: NullType;
+            readonly high: NullType;
+            readonly critical: NullType;
+        }>>;
+        readonly prompts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly text: StringType;
+        }>>;
+        readonly levers: ArrayType<StructType<{
+            readonly case: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly evidence: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly text: StringType;
+            readonly note: OptionType<StringType>;
+        }>>;
+        readonly alternatives: ArrayType<StructType<{
+            readonly id: OptionType<StringType>;
+            readonly label: StringType;
+            readonly value: import("@elaraai/east").FloatType;
+            readonly downside: OptionType<import("@elaraai/east").FloatType>;
+            readonly confidence: OptionType<import("@elaraai/east").FloatType>;
+            readonly note: OptionType<StringType>;
+        }>>;
+    }>], NullType>>;
+    readonly slice: OptionType<StructType<{
+        readonly key: StringType;
+        readonly read: FunctionType<[], StructType<{
+            readonly range: OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: import("@elaraai/east").DateTimeType;
+                    readonly to: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly datetimePreset: 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<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+            readonly cohorts: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: 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: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            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 write: FunctionType<[StructType<{
+            readonly range: OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: import("@elaraai/east").DateTimeType;
+                    readonly to: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly datetimePreset: 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<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+            readonly cohorts: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: 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: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            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>;
+        }>], NullType>;
+        readonly setRange: FunctionType<[OptionType<VariantType<{
+            readonly datetime: StructType<{
+                readonly from: import("@elaraai/east").DateTimeType;
+                readonly to: import("@elaraai/east").DateTimeType;
+            }>;
+            readonly datetimePreset: 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 compact: import("@elaraai/east").StructType<{
-                readonly display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
+        }>>], NullType>;
+        readonly setCompare: FunctionType<[OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>], NullType>;
+        readonly addFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: NullType;
+                    readonly isNotEmpty: NullType;
+                }>;
             }>;
-            readonly unit: import("@elaraai/east").StructType<{
-                readonly unit: import("@elaraai/east").VariantType<{
-                    readonly bit: import("@elaraai/east").NullType;
-                    readonly byte: import("@elaraai/east").NullType;
-                    readonly kilobit: import("@elaraai/east").NullType;
-                    readonly kilobyte: import("@elaraai/east").NullType;
-                    readonly megabit: import("@elaraai/east").NullType;
-                    readonly megabyte: import("@elaraai/east").NullType;
-                    readonly gigabit: import("@elaraai/east").NullType;
-                    readonly gigabyte: import("@elaraai/east").NullType;
-                    readonly terabit: import("@elaraai/east").NullType;
-                    readonly terabyte: import("@elaraai/east").NullType;
-                    readonly petabyte: import("@elaraai/east").NullType;
-                    readonly nanosecond: import("@elaraai/east").NullType;
-                    readonly microsecond: import("@elaraai/east").NullType;
-                    readonly millisecond: import("@elaraai/east").NullType;
-                    readonly second: import("@elaraai/east").NullType;
-                    readonly minute: import("@elaraai/east").NullType;
-                    readonly hour: import("@elaraai/east").NullType;
-                    readonly day: import("@elaraai/east").NullType;
-                    readonly week: import("@elaraai/east").NullType;
-                    readonly month: import("@elaraai/east").NullType;
-                    readonly year: import("@elaraai/east").NullType;
-                    readonly millimeter: import("@elaraai/east").NullType;
-                    readonly centimeter: import("@elaraai/east").NullType;
-                    readonly meter: import("@elaraai/east").NullType;
-                    readonly kilometer: import("@elaraai/east").NullType;
-                    readonly inch: import("@elaraai/east").NullType;
-                    readonly foot: import("@elaraai/east").NullType;
-                    readonly yard: import("@elaraai/east").NullType;
-                    readonly mile: import("@elaraai/east").NullType;
-                    readonly gram: import("@elaraai/east").NullType;
-                    readonly kilogram: import("@elaraai/east").NullType;
-                    readonly milligram: import("@elaraai/east").NullType;
-                    readonly ounce: import("@elaraai/east").NullType;
-                    readonly pound: import("@elaraai/east").NullType;
-                    readonly stone: import("@elaraai/east").NullType;
-                    readonly celsius: import("@elaraai/east").NullType;
-                    readonly fahrenheit: import("@elaraai/east").NullType;
-                    readonly milliliter: import("@elaraai/east").NullType;
-                    readonly liter: import("@elaraai/east").NullType;
-                    readonly gallon: import("@elaraai/east").NullType;
-                    readonly fluidOunce: import("@elaraai/east").NullType;
-                    readonly acre: import("@elaraai/east").NullType;
-                    readonly hectare: import("@elaraai/east").NullType;
-                    readonly meterPerSecond: import("@elaraai/east").NullType;
-                    readonly kilometerPerHour: import("@elaraai/east").NullType;
-                    readonly milePerHour: import("@elaraai/east").NullType;
-                    readonly percent: import("@elaraai/east").NullType;
-                    readonly degree: import("@elaraai/east").NullType;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 display: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly short: import("@elaraai/east").NullType;
-                    readonly narrow: import("@elaraai/east").NullType;
-                    readonly long: import("@elaraai/east").NullType;
-                }>>;
             }>;
-            readonly scientific: import("@elaraai/east").NullType;
-            readonly engineering: import("@elaraai/east").NullType;
-            readonly date: import("@elaraai/east").StructType<{
-                readonly format: StringType;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
             }>;
-            readonly time: import("@elaraai/east").StructType<{
-                readonly format: StringType;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: 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 datetime: import("@elaraai/east").StructType<{
-                readonly format: StringType;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly is: BooleanType;
+                }>;
             }>;
-        }>>;
-        readonly valueAxis: OptionType<StructType<{
-            readonly label: StringType;
-            readonly signed: BooleanType;
-        }>>;
-        readonly summary: OptionType<StringType>;
-        readonly downside: OptionType<import("@elaraai/east").FloatType>;
-        readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-        readonly detail: OptionType<StringType>;
-        readonly stakes: OptionType<VariantType<{
-            readonly low: NullType;
-            readonly medium: NullType;
-            readonly high: NullType;
-            readonly critical: NullType;
-        }>>;
-        readonly prompts: ArrayType<StructType<{
+        }>], NullType>;
+        readonly removeFilter: FunctionType<[import("@elaraai/east").IntegerType], NullType>;
+        readonly clearFilters: FunctionType<[], NullType>;
+        readonly defineCohort: FunctionType<[StructType<{
             readonly id: StringType;
-            readonly text: StringType;
-        }>>;
-        readonly levers: ArrayType<StructType<{
-            readonly case: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly updateCohort: FunctionType<[StringType, StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: 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: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], 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 evidence: ArrayType<StructType<{
+        }>>>;
+        readonly fields: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
             readonly label: StringType;
-            readonly text: StringType;
-            readonly note: OptionType<StringType>;
-        }>>;
-        readonly alternatives: ArrayType<StructType<{
-            readonly id: OptionType<StringType>;
+            readonly kind: StringType;
+            readonly hints: ArrayType<StringType>;
+            readonly format: OptionType<VariantType<{
+                readonly number: NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: NullType;
+                readonly compact: NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
+        }>>>;
+        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+        readonly totalCount: FunctionType<[], 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: 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 value: import("@elaraai/east").FloatType;
-            readonly downside: OptionType<import("@elaraai/east").FloatType>;
-            readonly confidence: OptionType<import("@elaraai/east").FloatType>;
-            readonly note: OptionType<StringType>;
-        }>>;
-    }>], NullType>>;
-    readonly slice: OptionType<ArrayType<VariantType<{
+            readonly meta: OptionType<StringType>;
+        }>>>;
+        readonly cohortCounts: FunctionType<[], import("@elaraai/east").DictType<StringType, import("@elaraai/east").IntegerType>>;
+        readonly toggleFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: NullType;
+                    readonly isNotEmpty: NullType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: 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: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>], NullType>;
+        readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: import("@elaraai/east").IntegerType;
+            readonly color: StringType;
+        }>>>;
+    }>>;
+    readonly affordances: OptionType<ArrayType<VariantType<{
         readonly filter: NullType;
         readonly search: NullType;
         readonly breakdown: NullType;
@@ -3559,12 +4509,19 @@ export declare const DecisionQueueComponent: import("@elaraai/east-ui").UICompon
  *   `evidence`).
  * @property onApply - Optional per-row Apply side-effect hook.
  * @property onReject - Optional per-row Reject side-effect hook.
- * @property slice - Operator-facing rail over the handle-owned slice: list
- *   the affordances (`["filter", "search"]`-style, or `true` for that
- *   default). The slice itself (binding, initial state, key) belongs to
- *   `Decision.bind`; its narrowing applies before the urgency sort and the
- *   routine split whether or not a rail is mounted — seeding state at bind
- *   with no rail gives an invisible author scope. `brush` is rejected.
+ * @property slice - Author-bound slice handle over the queue — the `Table`
+ *   pattern, with an ordinary `Slice.config` over the decision envelope and
+ *   the handle's own queue union as the rows feed:
+ *   `Slice.bind([Decision.Types.Decision], key, cfg, Slice.state({…}),
+ *   handle.queue(), none)`. You own the key (per-surface scopes over one
+ *   handle, shareable with any other component) and the config (which fields
+ *   the rail offers; the queue's narrowing matches with the same bound
+ *   config). Narrowing applies before the urgency sort and the routine split
+ *   whether or not a rail is mounted — seeding state with no rail gives an
+ *   invisible author scope.
+ * @property affordances - Rail affordances when `slice` is set (default
+ *   `["filter", "search"]`). `brush` is rejected — the queue has no
+ *   continuous axis.
  * @property maxHeight - Optional cap on the queue's height (a CSS length).
  *   The header stays pinned; the rows scroll. Unset, the queue grows with
  *   its content.
@@ -3602,7 +4559,10 @@ export interface DecisionQueueOptions {
     onApply?: SubtypeExprOrValue<FunctionType<[DecisionType], NullType>>;
     /** Per-row Reject side-effect hook — a pass-through `East.function` value, not invoked at build time. */
     onReject?: SubtypeExprOrValue<FunctionType<[DecisionType], NullType>>;
-    slice?: SliceAffordanceLiteral[] | true;
+    /** Author-bound slice handle over the queue (`Slice.bind` over the decision envelope, rows = `handle.queue()`) — chrome + narrowing. */
+    slice?: SubtypeExprOrValue<SliceBindType>;
+    /** Rail affordances when `slice` is set. Default `["filter", "search"]`; `[]` keeps the narrowing with no rail; `brush` is rejected. */
+    affordances?: SliceAffordanceLiteral[];
     maxHeight?: SubtypeExprOrValue<StringType>;
     density?: SubtypeExprOrValue<OptionType<DensityType>> | DensityLiteral;
     /** Custom groupings for the Group-by toolbar — a map of toolbar label →