@elaraai/east-ui 1.0.39 → 1.0.41

package/dist/src/collections/deck/index.d.ts

@@ -0,0 +1,2229 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Deck — the declarative grouped card collection (#359).
+ *
+ * `Deck.Root(data, config)` renders rows as presentation cards: a
+ * structured face (`card` accessor — title / sublabel / icon / status /
+ * tone / facts) or a fully custom face (`render` accessor returning any
+ * UI component), grouped by named GROUP BY toolbar options, laid out as
+ * a wrapping card grid or a single-column list. Filtering and search
+ * flow through the SLICE interface (like Table) — a Deck has no bespoke
+ * search of its own.
+ *
+ * Cards carry two states: the LIST face (the summary above) and an
+ * optional VIEW state rendered in an anchored POPOVER CARD. The
+ * `onClick` and `onHover` accessors return the popover's BODY content
+ * (any UI component); the popover's head is INHERITED from the card
+ * face (icon, title, sublabel, status, tone rule). Clicking opens a
+ * sticky popover (Esc / outside / × closes); hovering shows a transient
+ * peek on hover-capable pointers. `onOpen` / `onClose` report the
+ * click-popover transitions; `onCardClick` remains the plain tap
+ * callback. Cards are tap targets, never drag sources.
+ */
+import { type ExprType, type SubtypeExprOrValue, type ValueTypeOf, ArrayType, AsyncFunctionType, BooleanType, DictType, Expr, FloatType, FunctionType, NullType, OptionType, StringType, StructType } from "@elaraai/east";
+import { UIComponentType } from "../../component.js";
+import { type IconName } from "../../display/icon/types.js";
+import { type StatusTokenLiteral } from "../../style/interaction.js";
+import { ValueFormatType } from "../../contracts/format.js";
+import { SliceBindType } from "../../platform/slice/index.js";
+import { type SliceAffordanceLiteral } from "../../contracts/slice-affordances.js";
+import type { RowElement } from "../library/index.js";
+import { DeckFactType, DeckMetricType, DeckStatusesType, type DeckLayoutLiteral, type DeckStyle } from "./types.js";
+export { DeckFactType, DeckFillType, DeckLayoutType, DeckMetricType, DeckNoteType, DeckReadoutType, DeckRowsType, DeckStatusColorType, DeckStatusType, DeckStatusesType, DeckStyleType, type DeckLayoutLiteral, type DeckStyle, } from "./types.js";
+/**
+ * The structured face produced by the `card` accessor — the per-row
+ * fields before the factory merges in groups / search / custom face.
+ */
+export declare const DeckCardFaceType: StructType<{
+    readonly key: StringType;
+    readonly title: StringType;
+    readonly sublabel: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
+    readonly status: OptionType<StringType>;
+    readonly metrics: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: OptionType<FloatType>;
+        readonly format: OptionType<import("@elaraai/east").VariantType<{
+            readonly number: NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: NullType;
+            readonly compact: NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
+        readonly text: OptionType<StringType>;
+        readonly warn: BooleanType;
+    }>>;
+    readonly fill: OptionType<StructType<{
+        readonly value: FloatType;
+        readonly max: FloatType;
+        readonly format: OptionType<import("@elaraai/east").VariantType<{
+            readonly number: NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: NullType;
+            readonly compact: NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
+        readonly text: OptionType<StringType>;
+    }>>;
+    readonly facts: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: import("@elaraai/east").VariantType<{
+            readonly meter: StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+                readonly text: OptionType<StringType>;
+            }>;
+            readonly chips: ArrayType<StringType>;
+            readonly text: StringType;
+        }>;
+    }>>;
+    readonly filtered: BooleanType;
+}>;
+/**
+ * Type representing the structured Deck card face.
+ */
+export type DeckCardFaceType = typeof DeckCardFaceType;
+/**
+ * A resolved Deck item — the face merged with groups / search / custom
+ * face at factory time (the renderer never sees the host row type).
+ *
+ * @remarks
+ * Mirrors the inline `Deck` variant's `items` element in `component.ts`
+ * (the Card convention for containers whose payload references the
+ * recursive `UIComponentType`).
+ */
+export declare const DeckItemType: StructType<{
+    readonly key: StringType;
+    readonly title: StringType;
+    readonly sublabel: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
+    readonly status: OptionType<StringType>;
+    readonly metrics: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: OptionType<FloatType>;
+        readonly format: OptionType<import("@elaraai/east").VariantType<{
+            readonly number: NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: NullType;
+            readonly compact: NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
+        readonly text: OptionType<StringType>;
+        readonly warn: BooleanType;
+    }>>;
+    readonly fill: OptionType<StructType<{
+        readonly value: FloatType;
+        readonly max: FloatType;
+        readonly format: OptionType<import("@elaraai/east").VariantType<{
+            readonly number: NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: NullType;
+            readonly compact: NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
+        readonly text: OptionType<StringType>;
+    }>>;
+    readonly facts: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: import("@elaraai/east").VariantType<{
+            readonly meter: StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+                readonly text: OptionType<StringType>;
+            }>;
+            readonly chips: ArrayType<StringType>;
+            readonly text: StringType;
+        }>;
+    }>>;
+    readonly filtered: BooleanType;
+    readonly groups: DictType<StringType, StringType>;
+    readonly face: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    readonly detail: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    readonly hover: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+}>;
+/**
+ * Type representing a resolved Deck item.
+ */
+export type DeckItemType = typeof DeckItemType;
+/**
+ * The full Deck payload — mirrors the inline `Deck` variant in
+ * `component.ts`; use for `ValueTypeOf<typeof Deck.Types.Deck>` in
+ * renderers and assertions.
+ */
+export declare const DeckRootType: StructType<{
+    readonly items: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly title: StringType;
+        readonly sublabel: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly status: OptionType<StringType>;
+        readonly metrics: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: OptionType<FloatType>;
+            readonly format: OptionType<import("@elaraai/east").VariantType<{
+                readonly number: NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: NullType;
+                readonly compact: NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
+            readonly text: OptionType<StringType>;
+            readonly warn: BooleanType;
+        }>>;
+        readonly fill: OptionType<StructType<{
+            readonly value: FloatType;
+            readonly max: FloatType;
+            readonly format: OptionType<import("@elaraai/east").VariantType<{
+                readonly number: NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: NullType;
+                readonly compact: NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
+            readonly text: OptionType<StringType>;
+        }>>;
+        readonly facts: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: import("@elaraai/east").VariantType<{
+                readonly meter: StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                    readonly text: OptionType<StringType>;
+                }>;
+                readonly chips: ArrayType<StringType>;
+                readonly text: StringType;
+            }>;
+        }>>;
+        readonly filtered: BooleanType;
+        readonly groups: DictType<StringType, StringType>;
+        readonly face: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+        readonly detail: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+        readonly hover: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    }>>;
+    readonly statuses: DictType<StringType, StructType<{
+        readonly label: StringType;
+        readonly color: import("@elaraai/east").VariantType<{
+            readonly token: import("@elaraai/east").VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly custom: StringType;
+        }>;
+        readonly pulse: BooleanType;
+        readonly hint: OptionType<StringType>;
+    }>>;
+    readonly groupOptions: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+    }>>;
+    readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
+    readonly footer: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: StringType;
+    }>>;
+    readonly legend: BooleanType;
+    readonly layout: OptionType<import("@elaraai/east").VariantType<{
+        readonly grid: NullType;
+        readonly list: NullType;
+    }>>;
+    readonly onCardClick: OptionType<FunctionType<[StringType], NullType>>;
+    readonly onOpen: OptionType<AsyncFunctionType<[StringType], NullType>>;
+    readonly onClose: OptionType<AsyncFunctionType<[], NullType>>;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: StringType;
+            readonly read: FunctionType<[], StructType<{
+                readonly range: OptionType<import("@elaraai/east").VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: import("@elaraai/east").DateTimeType;
+                        readonly to: import("@elaraai/east").DateTimeType;
+                    }>;
+                    readonly datetimePreset: import("@elaraai/east").VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<import("@elaraai/east").VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly before: import("@elaraai/east").DateTimeType;
+                            readonly after: import("@elaraai/east").DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+            }>>;
+            readonly write: FunctionType<[StructType<{
+                readonly range: OptionType<import("@elaraai/east").VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: import("@elaraai/east").DateTimeType;
+                        readonly to: import("@elaraai/east").DateTimeType;
+                    }>;
+                    readonly datetimePreset: import("@elaraai/east").VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<import("@elaraai/east").VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly before: import("@elaraai/east").DateTimeType;
+                            readonly after: import("@elaraai/east").DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+            }>], NullType>;
+            readonly setRange: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: import("@elaraai/east").DateTimeType;
+                    readonly to: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly datetimePreset: import("@elaraai/east").VariantType<{
+                    readonly today: NullType;
+                    readonly last7d: NullType;
+                    readonly last30d: NullType;
+                    readonly last90d: NullType;
+                    readonly ytd: NullType;
+                }>;
+                readonly integer: StructType<{
+                    readonly from: import("@elaraai/east").IntegerType;
+                    readonly to: import("@elaraai/east").IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: FloatType;
+                    readonly to: FloatType;
+                }>;
+            }>>], NullType>;
+            readonly setCompare: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                readonly previousPeriod: NullType;
+                readonly previousYear: NullType;
+            }>>], NullType>;
+            readonly addFilter: FunctionType<[import("@elaraai/east").VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: import("@elaraai/east").IntegerType;
+                        readonly neq: import("@elaraai/east").IntegerType;
+                        readonly lt: import("@elaraai/east").IntegerType;
+                        readonly lte: import("@elaraai/east").IntegerType;
+                        readonly gt: import("@elaraai/east").IntegerType;
+                        readonly gte: import("@elaraai/east").IntegerType;
+                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly before: import("@elaraai/east").DateTimeType;
+                        readonly after: import("@elaraai/east").DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: import("@elaraai/east").DateTimeType;
+                            readonly to: import("@elaraai/east").DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly removeFilter: FunctionType<[import("@elaraai/east").IntegerType], NullType>;
+            readonly clearFilters: FunctionType<[], NullType>;
+            readonly defineCohort: FunctionType<[StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly before: import("@elaraai/east").DateTimeType;
+                            readonly after: import("@elaraai/east").DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>], NullType>;
+            readonly updateCohort: FunctionType<[StringType, StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly before: import("@elaraai/east").DateTimeType;
+                            readonly after: import("@elaraai/east").DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+            }>], NullType>;
+            readonly removeCohort: FunctionType<[StringType], NullType>;
+            readonly toggleCohort: FunctionType<[StringType], NullType>;
+            readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+            }>>], NullType>;
+            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+            readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+            readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
+            readonly isActive: FunctionType<[], BooleanType>;
+            readonly activeCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+            }>>>;
+            readonly fields: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+                readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+            }>>>;
+            readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+            readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+            readonly totalCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly groups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: import("@elaraai/east").DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
+                    readonly color: OptionType<StringType>;
+                }>>;
+            }>>>;
+            readonly matches: FunctionType<[], ArrayType<StructType<{
+                readonly id: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+            }>>>;
+            readonly cohortCounts: FunctionType<[], DictType<StringType, import("@elaraai/east").IntegerType>>;
+            readonly toggleFilter: FunctionType<[import("@elaraai/east").VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: import("@elaraai/east").SetType<StringType>;
+                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: NullType;
+                        readonly isNotEmpty: NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: import("@elaraai/east").IntegerType;
+                        readonly neq: import("@elaraai/east").IntegerType;
+                        readonly lt: import("@elaraai/east").IntegerType;
+                        readonly lte: import("@elaraai/east").IntegerType;
+                        readonly gt: import("@elaraai/east").IntegerType;
+                        readonly gte: import("@elaraai/east").IntegerType;
+                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly before: import("@elaraai/east").DateTimeType;
+                        readonly after: import("@elaraai/east").DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: import("@elaraai/east").DateTimeType;
+                            readonly to: import("@elaraai/east").DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").IntegerType;
+                readonly color: StringType;
+            }>>>;
+        }>;
+        readonly affordances: ArrayType<import("@elaraai/east").VariantType<{
+            readonly filter: NullType;
+            readonly search: NullType;
+            readonly breakdown: NullType;
+            readonly range: NullType;
+            readonly cohort: NullType;
+            readonly brush: NullType;
+            readonly presets: NullType;
+            readonly legend: NullType;
+        }>>;
+    }>>;
+    readonly style: OptionType<StructType<{
+        readonly height: OptionType<StringType>;
+        readonly maxHeight: OptionType<StringType>;
+        readonly minCardWidth: OptionType<StringType>;
+    }>>;
+}>;
+/**
+ * Type representing the full Deck payload.
+ */
+export type DeckRootType = typeof DeckRootType;
+/**
+ * The structured card-face fields accepted by the `card` accessor.
+ *
+ * @property key - Card identity (reported by `onCardClick` / `onOpen`)
+ * @property title - Primary identity line
+ * @property sublabel - Optional muted mono-uppercase second line
+ * @property icon - Optional Font Awesome solid icon name
+ * @property status - Optional status KEY into the deck's `statuses`
+ *   registry — drives the solid status tag (+ dot / pulse), the faint
+ *   face wash and the fill-bar colour
+ * @property metrics - Optional metric strip (`Deck.metric(...)`)
+ * @property fill - Optional status-coloured fill bar
+ * @property facts - Optional labelled facts (`Deck.meter` / `Deck.chips` / `Deck.text`)
+ * @property filtered - Render de-emphasised (the `Slice.partition` "keep the excluded" feed)
+ */
+export interface DeckCardFields {
+    /** Card identity (reported by `onCardClick` / `onOpen`) */
+    key: SubtypeExprOrValue<StringType>;
+    /** Primary identity line */
+    title: SubtypeExprOrValue<StringType>;
+    /** Optional muted mono-uppercase second line */
+    sublabel?: SubtypeExprOrValue<StringType>;
+    /** Optional Font Awesome solid icon name */
+    icon?: SubtypeExprOrValue<StringType> | IconName;
+    /** Optional status key into the deck's `statuses` registry */
+    status?: SubtypeExprOrValue<StringType>;
+    /** Optional metric strip (`Deck.metric(...)`) */
+    metrics?: Array<ExprType<DeckMetricType>>;
+    /** Optional status-coloured fill bar */
+    fill?: DeckFillFields;
+    /** Optional labelled facts */
+    facts?: Array<ExprType<typeof DeckFactType>>;
+    /** Render de-emphasised (dimmed) */
+    filtered?: SubtypeExprOrValue<BooleanType>;
+}
+/**
+ * The card fill-bar fields.
+ *
+ * @property value - Current value
+ * @property max - Full-bar value
+ * @property format - Reading format: a shared {@link ValueFormatType}
+ *   spec over `value`, or an accessor over `(value, max)`; omitted, the
+ *   renderer shows the percentage
+ */
+export interface DeckFillFields {
+    /** Current value */
+    value: SubtypeExprOrValue<FloatType>;
+    /** Full-bar value */
+    max: SubtypeExprOrValue<FloatType>;
+    /** Reading format (spec over `value`, or accessor over `(value, max)`) */
+    format?: ExprType<ValueFormatType> | ((value: ExprType<FloatType>, max: ExprType<FloatType>) => SubtypeExprOrValue<StringType>);
+}
+/**
+ * One entry of the `Deck.statuses` config.
+ *
+ * @property label - The tag / legend label
+ * @property color - A standard status tone literal, or any custom CSS
+ *   colour (the faint face tint is derived from it)
+ * @property pulse - Pulse the tag dot (active states)
+ * @property hint - Optional legend / group-head description
+ */
+export interface DeckStatusOption {
+    /** The tag / legend label */
+    label: string;
+    /** Standard status tone literal, or a custom CSS colour */
+    color: StatusTokenLiteral | (string & {});
+    /** Pulse the tag dot (active states) */
+    pulse?: boolean;
+    /** Optional legend / group-head description */
+    hint?: string;
+}
+/**
+ * Builds the deck's status registry — the single definition per state
+ * that drives the card's solid status tag (+ dot / pulse), the faint
+ * face wash, the fill-bar colour, group-head swatches, the legend and
+ * the popover head wash. Card faces reference entries by key via their
+ * `status` field.
+ *
+ * @param statuses - Status key → definition
+ * @returns The registry value for the `statuses` config option
+ */
+declare function createStatuses(statuses: Record<string, DeckStatusOption>): ValueTypeOf<DeckStatusesType>;
+/** Format option: a shared {@link ValueFormatType} spec, or a text
+ *  accessor over the raw value (reified at authoring time). */
+type DeckFormatOption = ExprType<ValueFormatType> | ((value: ExprType<FloatType>) => SubtypeExprOrValue<StringType>);
+/**
+ * Builds one card metric — a label-over-value pair in the mono tabular
+ * voice. The value stays RAW in the payload; display formatting uses
+ * the shared {@link ValueFormatType} vocabulary (`Chart.format.*`) or a
+ * text accessor. Option-valued metrics render "—" when `none`.
+ *
+ * @param label - Metric caption (mono uppercase)
+ * @param value - The raw value (Float, or an Option of Float)
+ * @param options - `format` (spec or accessor) + `warn` flag
+ * @returns A {@link DeckMetricType} expression
+ */
+declare function createMetric(label: SubtypeExprOrValue<StringType>, value: SubtypeExprOrValue<FloatType> | Expr, options?: {
+    /** Display format: a `Chart.format.*` spec or a text accessor */
+    format?: DeckFormatOption;
+    /** Render the value in the danger tone */
+    warn?: SubtypeExprOrValue<BooleanType>;
+}): ExprType<DeckMetricType>;
+/**
+ * One cell of a `Deck.Readout` rail.
+ *
+ * @property label - Cell caption (mono uppercase)
+ * @property value - The raw value (Float, or an Option of Float)
+ * @property format - Display format (spec or accessor)
+ * @property unit - Optional small muted unit suffix
+ * @property warn - Render the value in the danger tone
+ */
+export interface DeckReadoutCell {
+    /** Cell caption (mono uppercase) */
+    label: SubtypeExprOrValue<StringType>;
+    /** The raw value (Float, or an Option of Float) */
+    value: SubtypeExprOrValue<FloatType> | Expr;
+    /** Display format (spec or accessor) */
+    format?: DeckFormatOption;
+    /** Optional small muted unit suffix */
+    unit?: SubtypeExprOrValue<StringType>;
+    /** Render the value in the danger tone */
+    warn?: SubtypeExprOrValue<BooleanType>;
+}
+/**
+ * Creates a readout rail — a bordered grid of big mono values with
+ * units, the popover body's headline numbers.
+ *
+ * @param cells - The readout cells ({@link DeckReadoutCell})
+ * @returns An East expression of `UIComponentType`
+ */
+declare function createReadout(cells: DeckReadoutCell[]): ExprType<UIComponentType>;
+/**
+ * Creates key–value detail rows — the popover body's labelled facts
+ * (mono uppercase key column, body-voice values).
+ *
+ * @param rows - The rows (`label` + `value`)
+ * @returns An East expression of `UIComponentType`
+ */
+declare function createRows(rows: Array<{
+    label: SubtypeExprOrValue<StringType>;
+    value: SubtypeExprOrValue<StringType>;
+}>): ExprType<UIComponentType>;
+/**
+ * Creates a dashed-top mono footnote — the popover body's trailing note.
+ *
+ * @param text - The note text
+ * @returns An East expression of `UIComponentType`
+ */
+declare function createNote(text: SubtypeExprOrValue<StringType>): ExprType<UIComponentType>;
+/**
+ * A named GROUP BY toolbar option.
+ *
+ * @property key - Option identity (persisted as the active grouping)
+ * @property label - Toolbar label
+ * @property value - Accessor from a row to its group value
+ * @property summary - Optional accessor from a group's rows to the
+ *   right-aligned group-head summary text
+ */
+export interface DeckGroupOption<R extends StructType> {
+    /** Option identity (persisted as the active grouping) */
+    key: string;
+    /** Toolbar label */
+    label: string;
+    /** Accessor from a row to its group value */
+    value: (row: ExprType<R>) => SubtypeExprOrValue<StringType>;
+    /** Optional accessor from a group's rows to the group-head summary */
+    summary?: (rows: ExprType<ArrayType<R>>) => SubtypeExprOrValue<StringType>;
+}
+/**
+ * Configuration for {@link Deck.Root}.
+ *
+ * @property card - Accessor from a row to the structured card face (the
+ *   LIST state — the summary)
+ * @property render - Optional accessor from a row to a fully custom card
+ *   body (any UI component), rendered inside the card frame beneath the
+ *   structured face fields
+ * @property onClick - Optional accessor from a row to the click
+ *   popover's BODY (any UI component); the popover head is inherited
+ *   from the card face. Opens sticky on tap (Esc / outside / × closes)
+ * @property onHover - Optional accessor from a row to the hover peek's
+ *   BODY (same inherited-head popover) — hover-capable pointers only
+ * @property groupBy - Named GROUP BY toolbar options (empty = no toolbar)
+ * @property layout - `"grid"` (default — wrapping card rows) or `"list"`
+ * @property onCardClick - Optional tap callback with the card `key`
+ * @property onOpen - Optional callback when the click popover opens (card `key`)
+ * @property onClose - Optional callback when it closes
+ * @property slice - Optional bound slice handle (rail chrome renders
+ *   above) — filtering and search flow through the slice, like Table
+ * @property affordances - Rail affordances when `slice` is set (default
+ *   `["filter", "search"]`)
+ * @property style - Layout style (height / maxHeight / minCardWidth)
+ */
+export interface DeckConfig<R extends StructType> {
+    /** Accessor from a row to the structured card face (the LIST state) */
+    card: (row: ExprType<R>) => DeckCardFields | ExprType<DeckCardFaceType>;
+    /** Status registry (`Deck.statuses(...)`) — card `status` keys resolve here */
+    statuses?: ValueTypeOf<DeckStatusesType>;
+    /** Optional accessor from a row to a fully custom card body */
+    render?: (row: ExprType<R>) => ExprType<UIComponentType>;
+    /** Optional accessor from a row to the click popover's body */
+    onClick?: (row: ExprType<R>) => ExprType<UIComponentType>;
+    /** Optional accessor from a row to the hover peek's body */
+    onHover?: (row: ExprType<R>) => ExprType<UIComponentType>;
+    /** Optional board-foot key/value stats */
+    footer?: Array<{
+        label: string;
+        value: SubtypeExprOrValue<StringType>;
+    }>;
+    /** Render the status legend beneath the board (from the registry) */
+    legend?: boolean;
+    /** Named GROUP BY toolbar options (empty = no toolbar) */
+    groupBy?: Array<DeckGroupOption<R>>;
+    /** `"grid"` (default) or `"list"` */
+    layout?: DeckLayoutLiteral;
+    /** Optional tap callback with the card `key` */
+    onCardClick?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
+    /** Optional view-opened callback with the card `key` */
+    onOpen?: SubtypeExprOrValue<FunctionType<[StringType], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[StringType], NullType>>;
+    /** Optional view-closed callback */
+    onClose?: SubtypeExprOrValue<FunctionType<[], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[], NullType>>;
+    /** Optional bound slice handle (filter/search flow through it) */
+    slice?: SubtypeExprOrValue<SliceBindType>;
+    /** Rail affordances when `slice` is set (default `["filter", "search"]`) */
+    affordances?: SliceAffordanceLiteral[];
+    /** Layout style (height / maxHeight / minCardWidth) */
+    style?: DeckStyle;
+}
+/**
+ * Creates a Deck — a declarative grouped card collection.
+ *
+ * @typeParam T - The array-of-structs data expression type
+ * @param data - The rows (one card per element)
+ * @param config - The Deck configuration ({@link DeckConfig})
+ * @returns An East expression of `UIComponentType`
+ *
+ * @example
+ * ```ts
+ * import { East } from "@elaraai/east";
+ * import { Deck, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const example = East.function([], UIComponentType, _$ =>
+ *     Deck.Root(
+ *         [{ id: "a-201", name: "Line A", state: "RUNNING", load: 0.62 }],
+ *         {
+ *             card: r => ({
+ *                 key: r.id, title: r.name,
+ *                 status: Deck.status(r.state, "success"),
+ *                 facts: [Deck.meter("Load", r.load.multiply(100.0), 100.0, East.str`${East.print(r.load.multiply(100.0))}%`)],
+ *             }),
+ *             groupBy: [{ key: "state", label: "Status", value: r => r.state }],
+ *         },
+ *     ),
+ * );
+ * ```
+ */
+declare function createDeck<T extends SubtypeExprOrValue<ArrayType<StructType>>>(data: T, config: DeckConfig<RowElement<T>>): ExprType<UIComponentType>;
+/**
+ * Creates a meter fact (utilisation bar + right-aligned text).
+ *
+ * @param label - Fact caption
+ * @param value - Current value
+ * @param max - Full-bar value
+ * @param text - Right-aligned reading
+ * @returns A {@link DeckFactType} expression
+ */
+declare function createMeterFact(label: SubtypeExprOrValue<StringType>, value: SubtypeExprOrValue<FloatType>, max: SubtypeExprOrValue<FloatType>, text: SubtypeExprOrValue<StringType>): ExprType<DeckFactType>;
+/**
+ * Creates a chips fact (a row of small chips).
+ *
+ * @param label - Fact caption
+ * @param values - Chip texts
+ * @returns A {@link DeckFactType} expression
+ */
+declare function createChipsFact(label: SubtypeExprOrValue<StringType>, values: SubtypeExprOrValue<ArrayType<StringType>>): ExprType<DeckFactType>;
+/**
+ * Creates a text fact (a muted caption line).
+ *
+ * @param label - Fact caption
+ * @param text - The caption text
+ * @returns A {@link DeckFactType} expression
+ */
+declare function createTextFact(label: SubtypeExprOrValue<StringType>, text: SubtypeExprOrValue<StringType>): ExprType<DeckFactType>;
+/**
+ * Deck component namespace.
+ *
+ * @remarks
+ * `Deck.Root(data, config)` builds the card collection; the `card` mapper
+ * returns plain face fields per row; `Deck.status` / `Deck.meter` /
+ * `Deck.chips` / `Deck.text` build the face values. Group-by options are
+ * plain config literals, like Library's.
+ */
+export declare const Deck: {
+    /**
+     * Creates a Deck — a declarative grouped card collection.
+     *
+     * @param data - The rows (one card per element)
+     * @param config - The Deck configuration ({@link DeckConfig})
+     * @returns An East expression of `UIComponentType`
+     */
+    readonly Root: typeof createDeck;
+    /** Builds the status registry for the `statuses` config option. */
+    readonly statuses: typeof createStatuses;
+    /** Builds one card metric (label-over-value, raw value + shared format). */
+    readonly metric: typeof createMetric;
+    /** Creates a readout rail (popover headline numbers). */
+    readonly Readout: typeof createReadout;
+    /** Creates key–value detail rows (popover labelled facts). */
+    readonly Rows: typeof createRows;
+    /** Creates a dashed-top mono footnote (popover trailing note). */
+    readonly Note: typeof createNote;
+    /** Creates a meter fact (utilisation bar + right-aligned text). */
+    readonly meter: typeof createMeterFact;
+    /** Creates a chips fact (a row of small chips). */
+    readonly chips: typeof createChipsFact;
+    /** Creates a text fact (a muted caption line). */
+    readonly text: typeof createTextFact;
+    readonly Types: {
+        /** The full Deck payload (mirrors the inline `component.ts` variant). */
+        readonly Deck: StructType<{
+            readonly items: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly title: StringType;
+                readonly sublabel: OptionType<StringType>;
+                readonly icon: OptionType<StringType>;
+                readonly status: OptionType<StringType>;
+                readonly metrics: ArrayType<StructType<{
+                    readonly label: StringType;
+                    readonly value: OptionType<FloatType>;
+                    readonly format: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                    readonly text: OptionType<StringType>;
+                    readonly warn: BooleanType;
+                }>>;
+                readonly fill: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                    readonly format: OptionType<import("@elaraai/east").VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                    readonly text: OptionType<StringType>;
+                }>>;
+                readonly facts: ArrayType<StructType<{
+                    readonly label: StringType;
+                    readonly value: import("@elaraai/east").VariantType<{
+                        readonly meter: StructType<{
+                            readonly value: FloatType;
+                            readonly max: FloatType;
+                            readonly text: OptionType<StringType>;
+                        }>;
+                        readonly chips: ArrayType<StringType>;
+                        readonly text: StringType;
+                    }>;
+                }>>;
+                readonly filtered: BooleanType;
+                readonly groups: DictType<StringType, StringType>;
+                readonly face: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+                readonly detail: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+                readonly hover: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+            }>>;
+            readonly statuses: DictType<StringType, StructType<{
+                readonly label: StringType;
+                readonly color: import("@elaraai/east").VariantType<{
+                    readonly token: import("@elaraai/east").VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly custom: StringType;
+                }>;
+                readonly pulse: BooleanType;
+                readonly hint: OptionType<StringType>;
+            }>>;
+            readonly groupOptions: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
+            readonly footer: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: StringType;
+            }>>;
+            readonly legend: BooleanType;
+            readonly layout: OptionType<import("@elaraai/east").VariantType<{
+                readonly grid: NullType;
+                readonly list: NullType;
+            }>>;
+            readonly onCardClick: OptionType<FunctionType<[StringType], NullType>>;
+            readonly onOpen: OptionType<AsyncFunctionType<[StringType], NullType>>;
+            readonly onClose: OptionType<AsyncFunctionType<[], NullType>>;
+            readonly slice: OptionType<StructType<{
+                readonly slice: StructType<{
+                    readonly key: StringType;
+                    readonly read: FunctionType<[], StructType<{
+                        readonly range: OptionType<import("@elaraai/east").VariantType<{
+                            readonly datetime: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                            readonly datetimePreset: import("@elaraai/east").VariantType<{
+                                readonly today: NullType;
+                                readonly last7d: NullType;
+                                readonly last30d: NullType;
+                                readonly last90d: NullType;
+                                readonly ytd: NullType;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly from: import("@elaraai/east").IntegerType;
+                                readonly to: import("@elaraai/east").IntegerType;
+                            }>;
+                            readonly float: StructType<{
+                                readonly from: FloatType;
+                                readonly to: FloatType;
+                            }>;
+                        }>>;
+                        readonly compare: OptionType<import("@elaraai/east").VariantType<{
+                            readonly previousPeriod: NullType;
+                            readonly previousYear: NullType;
+                        }>>;
+                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                        readonly cohorts: ArrayType<StructType<{
+                            readonly id: StringType;
+                            readonly name: StringType;
+                            readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly string: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly eq: StringType;
+                                        readonly neq: StringType;
+                                        readonly in: import("@elaraai/east").SetType<StringType>;
+                                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                        readonly contains: StringType;
+                                        readonly matches: StringType;
+                                        readonly startsWith: StringType;
+                                        readonly endsWith: StringType;
+                                        readonly isEmpty: NullType;
+                                        readonly isNotEmpty: NullType;
+                                    }>;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly eq: import("@elaraai/east").IntegerType;
+                                        readonly neq: import("@elaraai/east").IntegerType;
+                                        readonly lt: import("@elaraai/east").IntegerType;
+                                        readonly lte: import("@elaraai/east").IntegerType;
+                                        readonly gt: import("@elaraai/east").IntegerType;
+                                        readonly gte: import("@elaraai/east").IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly before: import("@elaraai/east").DateTimeType;
+                                        readonly after: import("@elaraai/east").DateTimeType;
+                                        readonly between: StructType<{
+                                            readonly from: import("@elaraai/east").DateTimeType;
+                                            readonly to: import("@elaraai/east").DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>>;
+                        }>>;
+                        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                        readonly breakdown: OptionType<StructType<{
+                            readonly fieldId: StringType;
+                            readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                        }>>;
+                        readonly search: OptionType<StringType>;
+                        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                        readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                    }>>;
+                    readonly write: FunctionType<[StructType<{
+                        readonly range: OptionType<import("@elaraai/east").VariantType<{
+                            readonly datetime: StructType<{
+                                readonly from: import("@elaraai/east").DateTimeType;
+                                readonly to: import("@elaraai/east").DateTimeType;
+                            }>;
+                            readonly datetimePreset: import("@elaraai/east").VariantType<{
+                                readonly today: NullType;
+                                readonly last7d: NullType;
+                                readonly last30d: NullType;
+                                readonly last90d: NullType;
+                                readonly ytd: NullType;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly from: import("@elaraai/east").IntegerType;
+                                readonly to: import("@elaraai/east").IntegerType;
+                            }>;
+                            readonly float: StructType<{
+                                readonly from: FloatType;
+                                readonly to: FloatType;
+                            }>;
+                        }>>;
+                        readonly compare: OptionType<import("@elaraai/east").VariantType<{
+                            readonly previousPeriod: NullType;
+                            readonly previousYear: NullType;
+                        }>>;
+                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                        readonly cohorts: ArrayType<StructType<{
+                            readonly id: StringType;
+                            readonly name: StringType;
+                            readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                                readonly string: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly eq: StringType;
+                                        readonly neq: StringType;
+                                        readonly in: import("@elaraai/east").SetType<StringType>;
+                                        readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                        readonly contains: StringType;
+                                        readonly matches: StringType;
+                                        readonly startsWith: StringType;
+                                        readonly endsWith: StringType;
+                                        readonly isEmpty: NullType;
+                                        readonly isNotEmpty: NullType;
+                                    }>;
+                                }>;
+                                readonly integer: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly eq: import("@elaraai/east").IntegerType;
+                                        readonly neq: import("@elaraai/east").IntegerType;
+                                        readonly lt: import("@elaraai/east").IntegerType;
+                                        readonly lte: import("@elaraai/east").IntegerType;
+                                        readonly gt: import("@elaraai/east").IntegerType;
+                                        readonly gte: import("@elaraai/east").IntegerType;
+                                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                    }>;
+                                }>;
+                                readonly float: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly lt: FloatType;
+                                        readonly lte: FloatType;
+                                        readonly gt: FloatType;
+                                        readonly gte: FloatType;
+                                    }>;
+                                }>;
+                                readonly datetime: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly before: import("@elaraai/east").DateTimeType;
+                                        readonly after: import("@elaraai/east").DateTimeType;
+                                        readonly between: StructType<{
+                                            readonly from: import("@elaraai/east").DateTimeType;
+                                            readonly to: import("@elaraai/east").DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                readonly boolean: StructType<{
+                                    readonly fieldId: StringType;
+                                    readonly op: import("@elaraai/east").VariantType<{
+                                        readonly is: BooleanType;
+                                    }>;
+                                }>;
+                            }>>;
+                        }>>;
+                        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                        readonly breakdown: OptionType<StructType<{
+                            readonly fieldId: StringType;
+                            readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                        }>>;
+                        readonly search: OptionType<StringType>;
+                        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                        readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                    }>], NullType>;
+                    readonly setRange: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: import("@elaraai/east").DateTimeType;
+                            readonly to: import("@elaraai/east").DateTimeType;
+                        }>;
+                        readonly datetimePreset: import("@elaraai/east").VariantType<{
+                            readonly today: NullType;
+                            readonly last7d: NullType;
+                            readonly last30d: NullType;
+                            readonly last90d: NullType;
+                            readonly ytd: NullType;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly from: import("@elaraai/east").IntegerType;
+                            readonly to: import("@elaraai/east").IntegerType;
+                        }>;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
+                        }>;
+                    }>>], NullType>;
+                    readonly setCompare: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                        readonly previousPeriod: NullType;
+                        readonly previousYear: NullType;
+                    }>>], NullType>;
+                    readonly addFilter: FunctionType<[import("@elaraai/east").VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>], NullType>;
+                    readonly removeFilter: FunctionType<[import("@elaraai/east").IntegerType], NullType>;
+                    readonly clearFilters: FunctionType<[], NullType>;
+                    readonly defineCohort: FunctionType<[StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>], NullType>;
+                    readonly updateCohort: FunctionType<[StringType, StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly eq: import("@elaraai/east").IntegerType;
+                                    readonly neq: import("@elaraai/east").IntegerType;
+                                    readonly lt: import("@elaraai/east").IntegerType;
+                                    readonly lte: import("@elaraai/east").IntegerType;
+                                    readonly gt: import("@elaraai/east").IntegerType;
+                                    readonly gte: import("@elaraai/east").IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly before: import("@elaraai/east").DateTimeType;
+                                    readonly after: import("@elaraai/east").DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: import("@elaraai/east").DateTimeType;
+                                        readonly to: import("@elaraai/east").DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: import("@elaraai/east").VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>], NullType>;
+                    readonly removeCohort: FunctionType<[StringType], NullType>;
+                    readonly toggleCohort: FunctionType<[StringType], NullType>;
+                    readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                    }>>], NullType>;
+                    readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+                    readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+                    readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
+                    readonly isActive: FunctionType<[], BooleanType>;
+                    readonly activeCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+                    readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly label: StringType;
+                    }>>>;
+                    readonly fields: FunctionType<[], ArrayType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly label: StringType;
+                        readonly kind: StringType;
+                        readonly hints: ArrayType<StringType>;
+                        readonly format: OptionType<import("@elaraai/east").VariantType<{
+                            readonly number: NullType;
+                            readonly currency: StructType<{
+                                readonly code: StringType;
+                                readonly compact: BooleanType;
+                            }>;
+                            readonly percent: NullType;
+                            readonly compact: NullType;
+                            readonly date: StringType;
+                            readonly time: StringType;
+                            readonly datetime: StringType;
+                        }>>;
+                    }>>>;
+                    readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+                    readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+                    readonly totalCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+                    readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+                    readonly groups: FunctionType<[], ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly count: import("@elaraai/east").IntegerType;
+                        readonly color: StringType;
+                    }>>>;
+                    readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly color: StringType;
+                        readonly points: ArrayType<StructType<{
+                            readonly x: import("@elaraai/east").VariantType<{
+                                readonly category: StringType;
+                                readonly number: FloatType;
+                                readonly time: import("@elaraai/east").DateTimeType;
+                            }>;
+                            readonly value: FloatType;
+                            readonly size: OptionType<FloatType>;
+                            readonly color: OptionType<StringType>;
+                        }>>;
+                    }>>>;
+                    readonly matches: FunctionType<[], ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly label: StringType;
+                        readonly meta: OptionType<StringType>;
+                    }>>>;
+                    readonly cohortCounts: FunctionType<[], DictType<StringType, import("@elaraai/east").IntegerType>>;
+                    readonly toggleFilter: FunctionType<[import("@elaraai/east").VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly eq: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly before: import("@elaraai/east").DateTimeType;
+                                readonly after: import("@elaraai/east").DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: import("@elaraai/east").DateTimeType;
+                                    readonly to: import("@elaraai/east").DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: import("@elaraai/east").VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>], NullType>;
+                    readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly count: import("@elaraai/east").IntegerType;
+                        readonly color: StringType;
+                    }>>>;
+                }>;
+                readonly affordances: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly filter: NullType;
+                    readonly search: NullType;
+                    readonly breakdown: NullType;
+                    readonly range: NullType;
+                    readonly cohort: NullType;
+                    readonly brush: NullType;
+                    readonly presets: NullType;
+                    readonly legend: NullType;
+                }>>;
+            }>>;
+            readonly style: OptionType<StructType<{
+                readonly height: OptionType<StringType>;
+                readonly maxHeight: OptionType<StringType>;
+                readonly minCardWidth: OptionType<StringType>;
+            }>>;
+        }>;
+        /** A resolved Deck item. */
+        readonly Item: StructType<{
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly sublabel: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly status: OptionType<StringType>;
+            readonly metrics: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: OptionType<FloatType>;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+                readonly warn: BooleanType;
+            }>>;
+            readonly fill: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+            }>>;
+            readonly facts: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: import("@elaraai/east").VariantType<{
+                    readonly meter: StructType<{
+                        readonly value: FloatType;
+                        readonly max: FloatType;
+                        readonly text: OptionType<StringType>;
+                    }>;
+                    readonly chips: ArrayType<StringType>;
+                    readonly text: StringType;
+                }>;
+            }>>;
+            readonly filtered: BooleanType;
+            readonly groups: DictType<StringType, StringType>;
+            readonly face: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+            readonly detail: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+            readonly hover: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+        }>;
+        /** The structured card face (`card` accessor target). */
+        readonly Face: StructType<{
+            readonly key: StringType;
+            readonly title: StringType;
+            readonly sublabel: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly status: OptionType<StringType>;
+            readonly metrics: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: OptionType<FloatType>;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+                readonly warn: BooleanType;
+            }>>;
+            readonly fill: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+            }>>;
+            readonly facts: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: import("@elaraai/east").VariantType<{
+                    readonly meter: StructType<{
+                        readonly value: FloatType;
+                        readonly max: FloatType;
+                        readonly text: OptionType<StringType>;
+                    }>;
+                    readonly chips: ArrayType<StringType>;
+                    readonly text: StringType;
+                }>;
+            }>>;
+            readonly filtered: BooleanType;
+        }>;
+        /** The status registry (key → definition). */
+        readonly Statuses: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly color: import("@elaraai/east").VariantType<{
+                readonly token: import("@elaraai/east").VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly custom: StringType;
+            }>;
+            readonly pulse: BooleanType;
+            readonly hint: OptionType<StringType>;
+        }>>;
+        /** One status registry entry. */
+        readonly Status: StructType<{
+            readonly label: StringType;
+            readonly color: import("@elaraai/east").VariantType<{
+                readonly token: import("@elaraai/east").VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly custom: StringType;
+            }>;
+            readonly pulse: BooleanType;
+            readonly hint: OptionType<StringType>;
+        }>;
+        /** A status colour (token or custom). */
+        readonly StatusColor: import("@elaraai/east").VariantType<{
+            readonly token: import("@elaraai/east").VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly custom: StringType;
+        }>;
+        /** A card metric. */
+        readonly Metric: StructType<{
+            readonly label: StringType;
+            readonly value: OptionType<FloatType>;
+            readonly format: OptionType<import("@elaraai/east").VariantType<{
+                readonly number: NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: NullType;
+                readonly compact: NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
+            readonly text: OptionType<StringType>;
+            readonly warn: BooleanType;
+        }>;
+        /** The card fill bar. */
+        readonly Fill: StructType<{
+            readonly value: FloatType;
+            readonly max: FloatType;
+            readonly format: OptionType<import("@elaraai/east").VariantType<{
+                readonly number: NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: NullType;
+                readonly compact: NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
+            readonly text: OptionType<StringType>;
+        }>;
+        /** The readout rail component payload. */
+        readonly Readout: StructType<{
+            readonly cells: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: OptionType<FloatType>;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+                readonly unit: OptionType<StringType>;
+                readonly warn: BooleanType;
+            }>>;
+        }>;
+        /** The detail-rows component payload. */
+        readonly Rows: StructType<{
+            readonly rows: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: StringType;
+            }>>;
+        }>;
+        /** The note component payload. */
+        readonly Note: StructType<{
+            readonly text: StringType;
+        }>;
+        /** A labelled card fact. */
+        readonly Fact: StructType<{
+            readonly label: StringType;
+            readonly value: import("@elaraai/east").VariantType<{
+                readonly meter: StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                    readonly text: OptionType<StringType>;
+                }>;
+                readonly chips: ArrayType<StringType>;
+                readonly text: StringType;
+            }>;
+        }>;
+        /** Fact value kinds (shared with Library dimensions). */
+        readonly FactValue: import("@elaraai/east").VariantType<{
+            readonly meter: StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+                readonly text: OptionType<StringType>;
+            }>;
+            readonly chips: ArrayType<StringType>;
+            readonly text: StringType;
+        }>;
+        /** Layout mode. */
+        readonly Layout: import("@elaraai/east").VariantType<{
+            readonly grid: NullType;
+            readonly list: NullType;
+        }>;
+        /** Container style. */
+        readonly Style: StructType<{
+            readonly height: OptionType<StringType>;
+            readonly maxHeight: OptionType<StringType>;
+            readonly minCardWidth: OptionType<StringType>;
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map