@elaraai/e3-ui 1.0.4 → 1.0.6

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

@@ -0,0 +1,4594 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Decision.bind` — the per-surface decision handle (see
+ * `docs/decision-loop.md` and the `Decision.Handle` block in
+ * `design/decide.html`).
+ *
+ * Decisions arrive from multiple reasoning tasks, each bound with its own
+ * {@link Data.bind} diff view (read-only source ⊕ operator patch overlay);
+ * the operator's staged contribution is a judgements dict bound the same
+ * way. `Decision.bind` is a generic platform function over those bindings'
+ * descriptors — the `Data.bind` / `Slice.bind` pattern: the East layer
+ * declares the contract, the runtime (in `@elaraai/e3-ui-components`)
+ * implements the handle's closures. It adds only what no single binding
+ * can: the union of the decision views, write-routing by case id, the
+ * handle-owned case selection, and the derived commit gate.
+ *
+ * The type parameter is the solution's **constraint contract** — a by-name
+ * `VariantType` declared once in the solution package and imported by both
+ * the reasoning task (which `$.matchTag`s injected constraints, fully
+ * typed) and the surface. Pass it like `Data.bind`'s type token:
+ * `Decision.bind([RosterConstraint], { decisions, judgements })`; omit it
+ * for the default primitive op-variant.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, DictType, OptionType, StructType, VariantType, FunctionType, StringType, IntegerType, NullType, type EastType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
+import { SliceStateType } from '@elaraai/east-ui/internal';
+import { type BoundValue } from '../data.js';
+import { DecisionType, DecisionConstraintType } from './types.js';
+/**
+ * The derived commit gate for one case — a pure function of the decision's
+ * `prompts` and the staged judgement's `answers`.
+ *
+ * @property gated - That many prompts are still unanswered; Apply disabled
+ * @property blocked - Some prompt was answered `no`; commit blocked
+ * @property handoff - Some prompt was answered `unknown`; the case routes to
+ *   handoff
+ * @property ready - Every prompt answered `yes` (or the case has no
+ *   prompts); Apply enabled
+ */
+export declare const CommitStateType: VariantType<{
+    readonly gated: IntegerType;
+    readonly blocked: NullType;
+    readonly handoff: NullType;
+    readonly ready: NullType;
+}>;
+/** Type alias for {@link CommitStateType}. */
+export type CommitStateType = typeof CommitStateType;
+/**
+ * Build the judgements dataset type for a constraint contract — staged
+ * judgements keyed by case id. Bind it with
+ * `Data.bind([Decision.Types.Judgements(Contract)], judgementsInput.path)`.
+ */
+export declare function judgementsType<C extends EastType = DecisionConstraintType>(constraint?: C): DictType<StringType, StructType<{
+    readonly caseId: StringType;
+    readonly answers: DictType<StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>>;
+    readonly knowledge: OptionType<StringType>;
+    readonly constraints: ArrayType<C>;
+    readonly verdict: OptionType<VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>>;
+    readonly resolvedAt: OptionType<import("@elaraai/east").DateTimeType>;
+}>>;
+/** The default judgements dataset type (primitive op-variant constraints). */
+export declare const JudgementsType: DictType<StringType, StructType<{
+    readonly caseId: StringType;
+    readonly answers: DictType<StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>>;
+    readonly knowledge: OptionType<StringType>;
+    readonly constraints: ArrayType<VariantType<{
+        readonly string: VariantType<{
+            readonly eq: StringType;
+            readonly neq: StringType;
+            readonly in: import("@elaraai/east").SetType<StringType>;
+            readonly notIn: import("@elaraai/east").SetType<StringType>;
+        }>;
+        readonly integer: VariantType<{
+            readonly eq: IntegerType;
+            readonly atMost: IntegerType;
+            readonly atLeast: IntegerType;
+            readonly between: StructType<{
+                readonly min: IntegerType;
+                readonly max: IntegerType;
+            }>;
+        }>;
+        readonly float: VariantType<{
+            readonly eq: import("@elaraai/east").FloatType;
+            readonly atMost: import("@elaraai/east").FloatType;
+            readonly atLeast: import("@elaraai/east").FloatType;
+            readonly between: StructType<{
+                readonly min: import("@elaraai/east").FloatType;
+                readonly max: import("@elaraai/east").FloatType;
+            }>;
+        }>;
+        readonly datetime: VariantType<{
+            readonly before: import("@elaraai/east").DateTimeType;
+            readonly after: import("@elaraai/east").DateTimeType;
+            readonly between: StructType<{
+                readonly min: import("@elaraai/east").DateTimeType;
+                readonly max: import("@elaraai/east").DateTimeType;
+            }>;
+        }>;
+        readonly boolean: VariantType<{
+            readonly is: import("@elaraai/east").BooleanType;
+        }>;
+    }>>;
+    readonly verdict: OptionType<VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>>;
+    readonly resolvedAt: OptionType<import("@elaraai/east").DateTimeType>;
+}>>;
+/** Type alias for {@link JudgementsType}. */
+export type JudgementsType = typeof JudgementsType;
+/**
+ * Build the decision-handle type for a constraint contract.
+ *
+ * The descriptor fields identify the underlying bindings (renderer
+ * subscriptions, provenance); the closures — implemented by the platform
+ * runtime, like `Data.bind`'s — are the only read/write paths, so the
+ * handle's semantics live once.
+ *
+ * @property decisions - Per-source binding descriptors
+ * @property judgements - The judgements binding descriptor
+ * @property sliceInit - The initial slice state passed at bind (data; feeds
+ *   component payload refs)
+ * @property slice - The handle-owned slice over the unioned queue (canonical
+ *   `DecisionType` config; key derived from the bound source paths, like the
+ *   selection). Components mount its rail; seeding `slice` at bind with no
+ *   rail mounted gives an invisible author scope.
+ * @property queue - The visible queue: union of every bound view (source ⊕
+ *   patch each)
+ * @property selected - The selected case id, if any
+ * @property select - Open a case (Triage → Understand)
+ * @property clearSelection - Close the case without resolving
+ * @property decision - The selected case's decision, if it is still queued
+ * @property update - Probe edit: write an edited decision through its owning
+ *   view's patch overlay (routed by `id`)
+ * @property judgement - The staged judgement for a case (a fresh empty one
+ *   when nothing is staged yet)
+ * @property answer - Record the response to one judgement prompt (keyed by
+ *   prompt id)
+ * @property addKnowledge - Record free-text context the model can't see
+ * @property inject - Stage a typed constraint (a contract-variant value;
+ *   upserts by case name); the next optimiser run folds it in
+ * @property resolve - Commit a verdict: writes it to the judgement, removes
+ *   the case through its owning patch overlay, clears the selection (closes
+ *   the loop back to Triage)
+ * @property commitState - The derived commit gate for a case — see
+ *   {@link CommitStateType}
+ */
+export declare function decisionHandleType<C extends EastType = DecisionConstraintType>(constraint?: C): 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 sliceInit: 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: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>;
+        readonly compare: OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>;
+        readonly filters: ArrayType<VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>>;
+    readonly slice: 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: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            readonly compare: OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: import("@elaraai/east").BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>>;
+        readonly 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: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            readonly compare: OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: import("@elaraai/east").BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>], 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: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>], NullType>;
+        readonly setCompare: FunctionType<[OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>], NullType>;
+        readonly addFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").BooleanType;
+                }>;
+            }>;
+        }>], NullType>;
+        readonly removeFilter: FunctionType<[IntegerType], NullType>;
+        readonly clearFilters: FunctionType<[], NullType>;
+        readonly defineCohort: FunctionType<[StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly removeCohort: FunctionType<[StringType], NullType>;
+        readonly toggleCohort: FunctionType<[StringType], NullType>;
+        readonly setBreakdown: FunctionType<[OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>], NullType>;
+        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+        readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+        readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
+        readonly activeCount: FunctionType<[], IntegerType>;
+        readonly dimensions: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+        }>>>;
+        readonly fields: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+            readonly kind: StringType;
+        }>>>;
+        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+        readonly totalCount: FunctionType<[], IntegerType>;
+        readonly resultCount: FunctionType<[], IntegerType>;
+        readonly groups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: IntegerType;
+            readonly color: StringType;
+        }>>>;
+        readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly color: StringType;
+            readonly points: ArrayType<StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: import("@elaraai/east").FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly value: import("@elaraai/east").FloatType;
+                readonly size: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
+        }>>>;
+        readonly matches: FunctionType<[], ArrayType<StructType<{
+            readonly id: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>>;
+        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+    }>;
+    readonly queue: FunctionType<[], ArrayType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 selected: FunctionType<[], OptionType<StringType>>;
+    readonly select: FunctionType<[StringType], NullType>;
+    readonly clearSelection: FunctionType<[], NullType>;
+    readonly decision: FunctionType<[], OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 update: 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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 judgement: FunctionType<[StringType], StructType<{
+        readonly caseId: StringType;
+        readonly answers: DictType<StringType, VariantType<{
+            readonly yes: NullType;
+            readonly no: NullType;
+            readonly unknown: NullType;
+        }>>;
+        readonly knowledge: OptionType<StringType>;
+        readonly constraints: ArrayType<C>;
+        readonly verdict: OptionType<VariantType<{
+            readonly accepted: StringType;
+            readonly rejected: NullType;
+            readonly deferred: OptionType<StringType>;
+            readonly handoff: StringType;
+        }>>;
+        readonly resolvedAt: OptionType<import("@elaraai/east").DateTimeType>;
+    }>>;
+    readonly answer: FunctionType<[StringType, StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>], NullType>;
+    readonly addKnowledge: FunctionType<[StringType, StringType], NullType>;
+    readonly inject: FunctionType<[StringType, C], NullType>;
+    readonly resolve: FunctionType<[StringType, VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>], NullType>;
+    readonly commitState: FunctionType<[StringType], VariantType<{
+        readonly gated: IntegerType;
+        readonly blocked: NullType;
+        readonly handoff: NullType;
+        readonly ready: NullType;
+    }>>;
+}>;
+/** The default handle type (primitive op-variant constraints). */
+export declare const DecisionHandleType: 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 sliceInit: 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: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>;
+        readonly compare: OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>;
+        readonly filters: ArrayType<VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>>;
+    readonly slice: 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: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            readonly compare: OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: import("@elaraai/east").BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>>;
+        readonly 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: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            readonly compare: OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: import("@elaraai/east").BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>], 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: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>], NullType>;
+        readonly setCompare: FunctionType<[OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>], NullType>;
+        readonly addFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").BooleanType;
+                }>;
+            }>;
+        }>], NullType>;
+        readonly removeFilter: FunctionType<[IntegerType], NullType>;
+        readonly clearFilters: FunctionType<[], NullType>;
+        readonly defineCohort: FunctionType<[StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly removeCohort: FunctionType<[StringType], NullType>;
+        readonly toggleCohort: FunctionType<[StringType], NullType>;
+        readonly setBreakdown: FunctionType<[OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>], NullType>;
+        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+        readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+        readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
+        readonly activeCount: FunctionType<[], IntegerType>;
+        readonly dimensions: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+        }>>>;
+        readonly fields: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+            readonly kind: StringType;
+        }>>>;
+        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+        readonly totalCount: FunctionType<[], IntegerType>;
+        readonly resultCount: FunctionType<[], IntegerType>;
+        readonly groups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: IntegerType;
+            readonly color: StringType;
+        }>>>;
+        readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly color: StringType;
+            readonly points: ArrayType<StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: import("@elaraai/east").FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly value: import("@elaraai/east").FloatType;
+                readonly size: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
+        }>>>;
+        readonly matches: FunctionType<[], ArrayType<StructType<{
+            readonly id: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>>;
+        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+    }>;
+    readonly queue: FunctionType<[], ArrayType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 selected: FunctionType<[], OptionType<StringType>>;
+    readonly select: FunctionType<[StringType], NullType>;
+    readonly clearSelection: FunctionType<[], NullType>;
+    readonly decision: FunctionType<[], OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 update: 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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 judgement: FunctionType<[StringType], StructType<{
+        readonly caseId: StringType;
+        readonly answers: DictType<StringType, VariantType<{
+            readonly yes: NullType;
+            readonly no: NullType;
+            readonly unknown: NullType;
+        }>>;
+        readonly knowledge: OptionType<StringType>;
+        readonly constraints: ArrayType<VariantType<{
+            readonly string: VariantType<{
+                readonly eq: StringType;
+                readonly neq: StringType;
+                readonly in: import("@elaraai/east").SetType<StringType>;
+                readonly notIn: import("@elaraai/east").SetType<StringType>;
+            }>;
+            readonly integer: VariantType<{
+                readonly eq: IntegerType;
+                readonly atMost: IntegerType;
+                readonly atLeast: IntegerType;
+                readonly between: StructType<{
+                    readonly min: IntegerType;
+                    readonly max: IntegerType;
+                }>;
+            }>;
+            readonly float: VariantType<{
+                readonly eq: import("@elaraai/east").FloatType;
+                readonly atMost: import("@elaraai/east").FloatType;
+                readonly atLeast: import("@elaraai/east").FloatType;
+                readonly between: StructType<{
+                    readonly min: import("@elaraai/east").FloatType;
+                    readonly max: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: VariantType<{
+                readonly before: import("@elaraai/east").DateTimeType;
+                readonly after: import("@elaraai/east").DateTimeType;
+                readonly between: StructType<{
+                    readonly min: import("@elaraai/east").DateTimeType;
+                    readonly max: import("@elaraai/east").DateTimeType;
+                }>;
+            }>;
+            readonly boolean: VariantType<{
+                readonly is: import("@elaraai/east").BooleanType;
+            }>;
+        }>>;
+        readonly verdict: OptionType<VariantType<{
+            readonly accepted: StringType;
+            readonly rejected: NullType;
+            readonly deferred: OptionType<StringType>;
+            readonly handoff: StringType;
+        }>>;
+        readonly resolvedAt: OptionType<import("@elaraai/east").DateTimeType>;
+    }>>;
+    readonly answer: FunctionType<[StringType, StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>], NullType>;
+    readonly addKnowledge: FunctionType<[StringType, StringType], NullType>;
+    readonly inject: FunctionType<[StringType, VariantType<{
+        readonly string: VariantType<{
+            readonly eq: StringType;
+            readonly neq: StringType;
+            readonly in: import("@elaraai/east").SetType<StringType>;
+            readonly notIn: import("@elaraai/east").SetType<StringType>;
+        }>;
+        readonly integer: VariantType<{
+            readonly eq: IntegerType;
+            readonly atMost: IntegerType;
+            readonly atLeast: IntegerType;
+            readonly between: StructType<{
+                readonly min: IntegerType;
+                readonly max: IntegerType;
+            }>;
+        }>;
+        readonly float: VariantType<{
+            readonly eq: import("@elaraai/east").FloatType;
+            readonly atMost: import("@elaraai/east").FloatType;
+            readonly atLeast: import("@elaraai/east").FloatType;
+            readonly between: StructType<{
+                readonly min: import("@elaraai/east").FloatType;
+                readonly max: import("@elaraai/east").FloatType;
+            }>;
+        }>;
+        readonly datetime: VariantType<{
+            readonly before: import("@elaraai/east").DateTimeType;
+            readonly after: import("@elaraai/east").DateTimeType;
+            readonly between: StructType<{
+                readonly min: import("@elaraai/east").DateTimeType;
+                readonly max: import("@elaraai/east").DateTimeType;
+            }>;
+        }>;
+        readonly boolean: VariantType<{
+            readonly is: import("@elaraai/east").BooleanType;
+        }>;
+    }>], NullType>;
+    readonly resolve: FunctionType<[StringType, VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>], NullType>;
+    readonly commitState: FunctionType<[StringType], VariantType<{
+        readonly gated: IntegerType;
+        readonly blocked: NullType;
+        readonly handoff: NullType;
+        readonly ready: NullType;
+    }>>;
+}>;
+/** Type alias for {@link DecisionHandleType}. */
+export type DecisionHandleType = typeof DecisionHandleType;
+/** The TypeScript type of a {@link decisionBind} handle expression. */
+export type DecisionHandle<C extends EastType = DecisionConstraintType> = ExprType<ReturnType<typeof decisionHandleType<C>>>;
+/** What a surface needs from a handle of ANY contract — the descriptor
+ *  fields its payload ref carries. Components accept this so one queue
+ *  serves every solution contract. */
+export type DecisionHandleLike = Pick<DecisionHandle, 'decisions' | 'judgements' | 'sliceInit'>;
+/**
+ * The encodable identity of a handle — its binding descriptors. Extension
+ * component payloads are beast2-encoded, so they carry this ref (plain
+ * data); the renderer runtime reconstructs the live handle from it. The
+ * closure-rich handle itself never crosses an encoding boundary.
+ *
+ * @property decisions - Per-source binding descriptors
+ * @property judgements - The judgements binding descriptor
+ */
+export declare const DecisionHandleRefType: 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 integer: StructType<{
+                readonly from: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>;
+        readonly compare: OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>;
+        readonly filters: ArrayType<VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>>;
+}>;
+/** Type alias for {@link DecisionHandleRefType}. */
+export type DecisionHandleRefType = typeof DecisionHandleRefType;
+/**
+ * The underlying `Decision.bind` platform-function definition. End-users
+ * call {@link decisionBind} (via `Decision.bind`); the runtime
+ * implementation registers against this raw definition in
+ * `@elaraai/e3-ui-components` via `decisionBindPlatformFn.implement(...)`.
+ */
+export declare const decisionBindPlatformFn: import("@elaraai/east").GenericPlatformDefinition<readonly ["C"], readonly [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;
+    }>;
+}>>, 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;
+    }>;
+}>, 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: IntegerType;
+            readonly to: IntegerType;
+        }>;
+        readonly float: StructType<{
+            readonly from: import("@elaraai/east").FloatType;
+            readonly to: import("@elaraai/east").FloatType;
+        }>;
+    }>>;
+    readonly compare: OptionType<VariantType<{
+        readonly previousPeriod: NullType;
+        readonly previousYear: NullType;
+    }>>;
+    readonly filters: ArrayType<VariantType<{
+        readonly string: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly eq: StringType;
+                readonly neq: StringType;
+                readonly in: import("@elaraai/east").SetType<StringType>;
+                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                readonly contains: StringType;
+                readonly matches: StringType;
+            }>;
+        }>;
+        readonly integer: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly eq: IntegerType;
+                readonly neq: IntegerType;
+                readonly lt: IntegerType;
+                readonly lte: IntegerType;
+                readonly gt: IntegerType;
+                readonly gte: IntegerType;
+                readonly in: import("@elaraai/east").SetType<IntegerType>;
+            }>;
+        }>;
+        readonly float: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly lt: import("@elaraai/east").FloatType;
+                readonly lte: import("@elaraai/east").FloatType;
+                readonly gt: import("@elaraai/east").FloatType;
+                readonly gte: import("@elaraai/east").FloatType;
+            }>;
+        }>;
+        readonly datetime: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").BooleanType;
+                }>;
+            }>;
+        }>>;
+    }>>;
+    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+    readonly breakdown: OptionType<StructType<{
+        readonly fieldId: StringType;
+        readonly limit: OptionType<IntegerType>;
+    }>>;
+    readonly search: OptionType<StringType>;
+    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+    readonly selectedIndex: OptionType<IntegerType>;
+}>>], 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 sliceInit: 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: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>;
+        readonly compare: OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>;
+        readonly filters: ArrayType<VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>>;
+    readonly slice: 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: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            readonly compare: OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: import("@elaraai/east").BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>>;
+        readonly 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: IntegerType;
+                    readonly to: IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: import("@elaraai/east").FloatType;
+                    readonly to: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            readonly compare: OptionType<VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: import("@elaraai/east").FloatType;
+                            readonly lte: import("@elaraai/east").FloatType;
+                            readonly gt: import("@elaraai/east").FloatType;
+                            readonly gte: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: 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: import("@elaraai/east").BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>>;
+            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>], 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: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: import("@elaraai/east").FloatType;
+                readonly to: import("@elaraai/east").FloatType;
+            }>;
+        }>>], NullType>;
+        readonly setCompare: FunctionType<[OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>], NullType>;
+        readonly addFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: import("@elaraai/east").SetType<StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: 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: import("@elaraai/east").BooleanType;
+                }>;
+            }>;
+        }>], NullType>;
+        readonly removeFilter: FunctionType<[IntegerType], NullType>;
+        readonly clearFilters: FunctionType<[], NullType>;
+        readonly defineCohort: FunctionType<[StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").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 integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: import("@elaraai/east").SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: import("@elaraai/east").FloatType;
+                        readonly lte: import("@elaraai/east").FloatType;
+                        readonly gt: import("@elaraai/east").FloatType;
+                        readonly gte: import("@elaraai/east").FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: 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: import("@elaraai/east").BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly removeCohort: FunctionType<[StringType], NullType>;
+        readonly toggleCohort: FunctionType<[StringType], NullType>;
+        readonly setBreakdown: FunctionType<[OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>], NullType>;
+        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+        readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+        readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
+        readonly activeCount: FunctionType<[], IntegerType>;
+        readonly dimensions: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+        }>>>;
+        readonly fields: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+            readonly kind: StringType;
+        }>>>;
+        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+        readonly totalCount: FunctionType<[], IntegerType>;
+        readonly resultCount: FunctionType<[], IntegerType>;
+        readonly groups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: IntegerType;
+            readonly color: StringType;
+        }>>>;
+        readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly color: StringType;
+            readonly points: ArrayType<StructType<{
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: import("@elaraai/east").FloatType;
+                    readonly time: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly value: import("@elaraai/east").FloatType;
+                readonly size: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
+        }>>>;
+        readonly matches: FunctionType<[], ArrayType<StructType<{
+            readonly id: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>>;
+        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+    }>;
+    readonly queue: FunctionType<[], ArrayType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 selected: FunctionType<[], OptionType<StringType>>;
+    readonly select: FunctionType<[StringType], NullType>;
+    readonly clearSelection: FunctionType<[], NullType>;
+    readonly decision: FunctionType<[], OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 update: 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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+            }>;
+            readonly percent: import("@elaraai/east").StructType<{
+                readonly minimumFractionDigits: import("@elaraai/east").OptionType<IntegerType>;
+                readonly maximumFractionDigits: import("@elaraai/east").OptionType<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 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 judgement: FunctionType<[StringType], StructType<{
+        readonly caseId: StringType;
+        readonly answers: DictType<StringType, VariantType<{
+            readonly yes: NullType;
+            readonly no: NullType;
+            readonly unknown: NullType;
+        }>>;
+        readonly knowledge: OptionType<StringType>;
+        readonly constraints: ArrayType<never>;
+        readonly verdict: OptionType<VariantType<{
+            readonly accepted: StringType;
+            readonly rejected: NullType;
+            readonly deferred: OptionType<StringType>;
+            readonly handoff: StringType;
+        }>>;
+        readonly resolvedAt: OptionType<import("@elaraai/east").DateTimeType>;
+    }>>;
+    readonly answer: FunctionType<[StringType, StringType, VariantType<{
+        readonly yes: NullType;
+        readonly no: NullType;
+        readonly unknown: NullType;
+    }>], NullType>;
+    readonly addKnowledge: FunctionType<[StringType, StringType], NullType>;
+    readonly inject: FunctionType<[StringType, never], NullType>;
+    readonly resolve: FunctionType<[StringType, VariantType<{
+        readonly accepted: StringType;
+        readonly rejected: NullType;
+        readonly deferred: OptionType<StringType>;
+        readonly handoff: StringType;
+    }>], NullType>;
+    readonly commitState: FunctionType<[StringType], VariantType<{
+        readonly gated: IntegerType;
+        readonly blocked: NullType;
+        readonly handoff: NullType;
+        readonly ready: NullType;
+    }>>;
+}>>;
+/**
+ * Options for {@link decisionBind}.
+ *
+ * @property decisions - The bound decision views — one
+ *   `Data.bind([ArrayType(Decision.Types.Decision)], …)` handle per
+ *   reasoning task (source ⊕ patch each)
+ * @property judgements - The bound judgements view —
+ *   `Data.bind([Decision.Types.Judgements(Contract)], …)` (the staged
+ *   operator input)
+ * @property slice - Optional initial state for the handle-owned slice over
+ *   the queue (`Slice.state({ filters: [...] })`). Seeded once; the
+ *   operator's rail edits write over it. With no rail mounted on the queue
+ *   it acts as an invisible author scope.
+ */
+export interface DecisionBindOptions<C extends EastType = DecisionConstraintType> {
+    decisions: BoundValue<ArrayType<DecisionType>>[];
+    judgements: BoundValue<ReturnType<typeof judgementsType<C>>>;
+    slice?: SubtypeExprOrValue<SliceStateType>;
+}
+/**
+ * Build a decision handle from bound decision views + the bound judgements
+ * view. Call once at the surface boundary inside a `Reactive` block; pass
+ * the handle to every Decide component on the surface.
+ *
+ * @param types - Optional constraint-contract token, `Data.bind`-style:
+ *   `Decision.bind([RosterConstraint], options)`. Omit for the default
+ *   primitive op-variant.
+ * @param options - {@link DecisionBindOptions}.
+ * @returns A decision-handle expression.
+ *
+ * @remarks
+ * The handle's case selection is owned by the runtime: it lives in
+ * workspace UI state under a key derived from the bound source paths
+ * (deterministic, so it survives reloads), written only by `select` /
+ * `clearSelection` / `resolve`. Everything consuming the same handle shares
+ * the selection by construction.
+ *
+ * @example
+ * ```tsx
+ * const rosterView = $.let(Data.bind([ArrayType(Decision.Types.Decision)], rosterOut.path, { patch: rosterPatch.path }));
+ * const judgementsView = $.let(Data.bind([Decision.Types.Judgements(RosterConstraint)], judgementsInput.path));
+ * const handle = $.let(Decision.bind([RosterConstraint], { decisions: [rosterView], judgements: judgementsView }));
+ * ```
+ */
+export declare function decisionBind(options: DecisionBindOptions): DecisionHandle;
+export declare function decisionBind<C extends EastType>(types: [C], options: DecisionBindOptions<C>): DecisionHandle<C>;
+//# sourceMappingURL=bind.d.ts.map