@elaraai/east-ui 1.0.30 → 1.0.32

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

@@ -16,8 +16,10 @@ import { type ExprType, type SubtypeExprOrValue, type TypeOf, type FunctionType,
 import { UIComponentType } from "../../component.js";
 import { type IconName } from "../../display/icon/types.js";
 import { StatusTokenType, type StatusTokenLiteral } from "../../style/interaction.js";
-import { LibraryStatusType } from "./types.js";
-export { LibraryRootType, LibraryItemType, LibraryCardFaceType, LibraryStatusType, LibraryDimValueType, LibraryGroupPlacementType, LibraryGroupMetaType, LibraryDimMetaType, } from "./types.js";
+import { SliceBindType } from "../../platform/slice/index.js";
+import { type SliceAffordanceLiteral } from "../../contracts/slice-affordances.js";
+import { LibraryStatusType, type LibraryStyle } from "./types.js";
+export { LibraryRootType, LibraryItemType, LibraryCardFaceType, LibraryStatusType, LibraryDimValueType, LibraryGroupMetaType, LibraryDimMetaType, LibraryStyleType, type LibraryStyle, } from "./types.js";
 /**
  * The struct element type of a `SubtypeExprOrValue<ArrayType<StructType>>`.
  */
@@ -31,6 +33,7 @@ export type RowElement<T extends SubtypeExprOrValue<ArrayType<StructType>>> = Ty
  * @property icon - Optional Font Awesome solid icon name
  * @property status - Optional status pill (`some(Library.status(...))` or a conditional option expression)
  * @property draggable - Whether the card can start a drag (default `true`)
+ * @property filtered - Whether the card renders de-emphasised (default `false`) — map `Slice.partition`'s `matched.not()` here to keep filtered-out cards as dimmed context
  */
 export interface LibraryCardFields {
     /** Item identity; carried by `LibraryRef` when dragged */
@@ -45,6 +48,8 @@ export interface LibraryCardFields {
     status?: SubtypeExprOrValue<OptionType<LibraryStatusType>>;
     /** Whether the card can start a drag (default `true`) */
     draggable?: SubtypeExprOrValue<BooleanType>;
+    /** Whether the card renders de-emphasised — dimmed, drag disabled (default `false`) */
+    filtered?: SubtypeExprOrValue<BooleanType>;
 }
 /**
  * Creates a status pill value for a card face.
@@ -151,20 +156,23 @@ export interface LibraryGroupDef<R extends StructType> {
  * @typeParam R - The struct type of each data row
  * @property id - DnD source identity — targets list it in their `sources`
  * @property item - Item row mapper — returns card-face fields (or a resolved face expression)
- * @property hint - Optional header-right caption (defaults to the drag hint)
+ * @property hint - Optional header-right caption (absent ⇒ no header band)
  * @property dimensions - Secondary dimensions (toolbar-toggleable card facts)
  * @property defaultDimensions - Initially-visible dimension keys (default: the first two)
  * @property groupBy - GROUP BY options; omit for a flat list
- * @property search - Filter-text accessor; unmatched cards dim rather than disappear
+ * @property search - Filter-text accessor; unmatched cards hide (the footer shows the hidden count + Show all)
  * @property addLabel - Optional footer action label
  * @property onAdd - Optional footer action callback
+ * @property slice - Optional slice chrome: the bound handle; the Library renders the rail + count footer, never narrows data itself
+ * @property affordances - Rail affordances when `slice` is set (default `["filter", "search"]`)
+ * @property style - Optional layout style (height / maxHeight / virtualization)
  */
 export interface LibraryConfig<R extends StructType> {
     /** DnD source identity — targets list it in their `sources` */
     id: string;
     /** Item row mapper — returns card-face fields (or a resolved face expression). */
     item: (row: ExprType<R>) => LibraryCardFields;
-    /** Optional header-right caption (defaults to the drag hint) */
+    /** Optional header-right caption (absent ⇒ no header band) */
     hint?: SubtypeExprOrValue<StringType>;
     /** Secondary dimensions (toolbar-toggleable card facts) */
     dimensions?: LibraryDimensionDef<R>[];
@@ -172,12 +180,31 @@ export interface LibraryConfig<R extends StructType> {
     defaultDimensions?: string[];
     /** GROUP BY options; omit for a flat list */
     groupBy?: LibraryGroupDef<R>[];
-    /** Filter-text accessor; unmatched cards dim rather than disappear */
+    /** Filter-text accessor; unmatched cards hide (the footer shows the hidden count + Show all) */
     search?: (row: ExprType<R>) => SubtypeExprOrValue<StringType>;
     /** Optional footer action label */
     addLabel?: SubtypeExprOrValue<StringType>;
     /** Optional footer action callback */
     onAdd?: SubtypeExprOrValue<FunctionType<[], NullType>>;
+    /**
+     * Slice chrome — pass the bound handle and the Library renders the frame
+     * chassis itself: a rail mounting the `affordances` (default
+     * `["filter", "search"]`) and a derived-count footer. Chrome only: feed
+     * the narrowed data explicitly via `data={Slice.rows([RowType], slice)}`,
+     * or keep filtered-out cards as dimmed context by feeding
+     * `Slice.partition([RowType], slice)` and mapping `matched.not()` into the
+     * card face's `filtered`. `brush` / `legend` / `breakdown` are rejected —
+     * the Library has no continuous axis or series, and slice breakdown would
+     * fight the built-in GROUP BY toolbar. When the `search` affordance is
+     * active the built-in search input is suppressed (the rail's search
+     * narrows the fed rows; two search boxes with different semantics is a
+     * trap).
+     */
+    slice?: SubtypeExprOrValue<SliceBindType>;
+    /** Rail affordances when `slice` is set (default `["filter", "search"]`) */
+    affordances?: SliceAffordanceLiteral[];
+    /** Optional layout style (height / maxHeight / virtualization) */
+    style?: LibraryStyle;
 }
 /**
  * Creates a Library — a draggable palette of assignable items.
@@ -228,8 +255,9 @@ export declare const Library: {
      *
      * @remarks
      * Declares the DnD **source** role under `config.id`. Cards with
-     * `draggable: false` show no grip and never start a drag. Search text
-     * dims unmatched cards instead of removing them.
+     * `draggable: false` show no grip and never start a drag. The quick
+     * search hides unmatched cards (the footer shows the hidden count);
+     * the `filtered` face field dims a card instead.
      *
      * @example
      * ```ts
@@ -275,11 +303,14 @@ export declare const Library: {
          * @property hint - Optional header-right caption
          * @property items - The resolved cards
          * @property groupOptions - GROUP BY toolbar options
+         * @property groupSummaries - Group-head summary text per option key, per group value
          * @property dimOptions - SECONDARY dimension toggles
          * @property defaultDimensions - Initially-visible dimension keys
          * @property searchable - Whether the search input renders
          * @property addLabel - Optional footer action label
          * @property onAdd - Optional footer action callback
+         * @property slice - Optional slice chrome (bound handle + rail affordances)
+         * @property style - Optional layout style (height / maxHeight / virtualization)
          */
         readonly Library: StructType<{
             readonly id: StringType;
@@ -300,11 +331,9 @@ export declare const Library: {
                     }>;
                 }>>;
                 readonly draggable: BooleanType;
+                readonly filtered: BooleanType;
                 readonly search: OptionType<StringType>;
-                readonly groups: DictType<StringType, StructType<{
-                    readonly value: StringType;
-                    readonly summary: OptionType<StringType>;
-                }>>;
+                readonly groups: DictType<StringType, StringType>;
                 readonly dims: DictType<StringType, import("@elaraai/east").VariantType<{
                     readonly meter: StructType<{
                         readonly value: FloatType;
@@ -319,6 +348,7 @@ export declare const Library: {
                 readonly key: StringType;
                 readonly label: StringType;
             }>>;
+            readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
             readonly dimOptions: ArrayType<StructType<{
                 readonly key: StringType;
                 readonly label: StringType;
@@ -327,6 +357,646 @@ export declare const Library: {
             readonly searchable: BooleanType;
             readonly addLabel: OptionType<StringType>;
             readonly onAdd: OptionType<FunctionType<[], 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 virtualization: OptionType<BooleanType>;
+            }>>;
         }>;
         /**
          * A resolved Library card.
@@ -337,8 +1007,9 @@ export declare const Library: {
          * @property icon - Optional Font Awesome solid icon name
          * @property status - Optional status pill
          * @property draggable - Whether the card can start a drag
+         * @property filtered - Whether the card renders de-emphasised
          * @property search - Optional filter text
-         * @property groups - Group placement per group-by option key
+         * @property groups - Group value per group-by option key
          * @property dims - Secondary dimension value per dimension key
          */
         readonly Item: StructType<{
@@ -357,11 +1028,9 @@ export declare const Library: {
                 }>;
             }>>;
             readonly draggable: BooleanType;
+            readonly filtered: BooleanType;
             readonly search: OptionType<StringType>;
-            readonly groups: DictType<StringType, StructType<{
-                readonly value: StringType;
-                readonly summary: OptionType<StringType>;
-            }>>;
+            readonly groups: DictType<StringType, StringType>;
             readonly dims: DictType<StringType, import("@elaraai/east").VariantType<{
                 readonly meter: StructType<{
                     readonly value: FloatType;
@@ -381,6 +1050,7 @@ export declare const Library: {
          * @property icon - Optional Font Awesome solid icon name
          * @property status - Optional status pill
          * @property draggable - Whether the card can start a drag
+         * @property filtered - Whether the card renders de-emphasised
          */
         readonly CardFace: StructType<{
             readonly key: StringType;
@@ -398,6 +1068,7 @@ export declare const Library: {
                 }>;
             }>>;
             readonly draggable: BooleanType;
+            readonly filtered: BooleanType;
         }>;
         /**
          * Status pill on a Library card.
@@ -431,6 +1102,18 @@ export declare const Library: {
             readonly chips: ArrayType<StringType>;
             readonly text: StringType;
         }>;
+        /**
+         * East StructType for Library layout style.
+         *
+         * @property height - Optional CSS height; constraining it makes the card grid the Library's own scroll region
+         * @property maxHeight - Optional CSS max-height
+         * @property virtualization - Whether rows virtualize inside the scroll region (default `true`)
+         */
+        readonly Style: StructType<{
+            readonly height: OptionType<StringType>;
+            readonly maxHeight: OptionType<StringType>;
+            readonly virtualization: OptionType<BooleanType>;
+        }>;
     };
 };
 //# sourceMappingURL=index.d.ts.map