@elaraai/east-ui 1.0.83 → 1.0.85

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

@@ -18,8 +18,866 @@ import { type IconName } from "../../display/icon/types.js";
 import { StatusTokenType, type StatusTokenLiteral } from "../../style/interaction.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";
+import { LibraryStatusType, LibraryGlyphType, LibraryLayoutType, type LibraryStyle, type LibraryVariantLiteral, type LibraryLayoutLiteral } from "./types.js";
+export { LibraryRootOf, LibraryItemOf, LibraryCardFaceOf, LibraryStatusType, LibraryGlyphType, LibraryNounType, LibraryDimValueType, LibraryGroupMetaType, LibraryDimMetaType, LibraryStyleType, LibraryVariantType, LibraryLayoutType, LibraryMediaPlacementType, type LibraryStyle, type LibraryVariantLiteral, type LibraryLayoutLiteral, type LibraryMediaPlacementLiteral, } from "./types.js";
+/** The Library component's value ({@link LibraryRootOf} over `UIComponentType`). */
+export declare const LibraryRootType: StructType<{
+    readonly id: StringType;
+    readonly hint: OptionType<StringType>;
+    readonly items: ArrayType<StructType<{
+        readonly search: OptionType<StringType>;
+        readonly groups: DictType<StringType, StringType>;
+        readonly facets: DictType<StringType, ArrayType<StringType>>;
+        readonly dims: DictType<StringType, 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 key: StringType;
+        readonly label: StringType;
+        readonly sublabel: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: import("@elaraai/east").VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly trailing: OptionType<StructType<{
+            readonly icon: StringType;
+            readonly label: StringType;
+            readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+        }>>;
+        readonly draggable: BooleanType;
+        readonly filtered: BooleanType;
+        readonly placed: BooleanType;
+        readonly media: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+        readonly avatar: OptionType<StringType>;
+        readonly byline: OptionType<StringType>;
+        readonly action: OptionType<StringType>;
+    }>>;
+    readonly groupOptions: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+    }>>;
+    readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
+    readonly dimOptions: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+    }>>;
+    readonly defaultDimensions: ArrayType<StringType>;
+    readonly filterOptions: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+    }>>;
+    readonly searchable: BooleanType;
+    readonly noun: OptionType<StructType<{
+        readonly singular: StringType;
+        readonly plural: StringType;
+    }>>;
+    readonly addLabel: OptionType<StringType>;
+    readonly onAdd: OptionType<FunctionType<[], NullType>>;
+    readonly onCardClick: OptionType<FunctionType<[StringType], 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 group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>>;
+            readonly write: FunctionType<[StructType<{
+                readonly range: OptionType<import("@elaraai/east").VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: import("@elaraai/east").DateTimeType;
+                        readonly to: import("@elaraai/east").DateTimeType;
+                    }>;
+                    readonly datetimePreset: import("@elaraai/east").VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: 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 group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly resolution: OptionType<import("@elaraai/east").VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>], NullType>;
+            readonly setRange: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: import("@elaraai/east").DateTimeType;
+                    readonly to: import("@elaraai/east").DateTimeType;
+                }>;
+                readonly datetimePreset: import("@elaraai/east").VariantType<{
+                    readonly today: NullType;
+                    readonly last7d: NullType;
+                    readonly last30d: NullType;
+                    readonly last90d: NullType;
+                    readonly ytd: NullType;
+                }>;
+                readonly integer: StructType<{
+                    readonly from: import("@elaraai/east").IntegerType;
+                    readonly to: import("@elaraai/east").IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: 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;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly updateCohort: FunctionType<[StringType, StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly eq: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: import("@elaraai/east").VariantType<{
+                            readonly lt: 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 group: OptionType<StringType>;
+            }>], NullType>;
+            readonly removeCohort: FunctionType<[StringType], NullType>;
+            readonly toggleCohort: FunctionType<[StringType], NullType>;
+            readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+            }>>], NullType>;
+            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+            readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+            readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
+            readonly isActive: FunctionType<[], BooleanType>;
+            readonly activeCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+            }>>>;
+            readonly fields: FunctionType<[], ArrayType<StructType<{
+                readonly fieldId: StringType;
+                readonly label: StringType;
+                readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
+                readonly format: OptionType<import("@elaraai/east").VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+            }>>>;
+            readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+            readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+            readonly totalCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly groups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly color: StringType;
+                readonly points: ArrayType<StructType<{
+                    readonly x: import("@elaraai/east").VariantType<{
+                        readonly category: StringType;
+                        readonly number: 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 setResolution: FunctionType<[OptionType<import("@elaraai/east").VariantType<{
+                readonly auto: NullType;
+                readonly hour: NullType;
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>>], NullType>;
+        }>;
+        readonly 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 resolution: NullType;
+            readonly summary: NullType;
+        }>>;
+    }>>;
+    readonly style: OptionType<StructType<{
+        readonly height: OptionType<StringType>;
+        readonly maxHeight: OptionType<StringType>;
+        readonly virtualization: OptionType<BooleanType>;
+        readonly columns: OptionType<import("@elaraai/east").IntegerType>;
+        readonly mediaPlacement: OptionType<import("@elaraai/east").VariantType<{
+            readonly top: NullType;
+            readonly start: NullType;
+        }>>;
+        readonly mediaSize: OptionType<StringType>;
+    }>>;
+    readonly variant: OptionType<import("@elaraai/east").VariantType<{
+        readonly compact: NullType;
+        readonly gallery: NullType;
+    }>>;
+    readonly layout: OptionType<import("@elaraai/east").VariantType<{
+        readonly grid: NullType;
+        readonly list: NullType;
+    }>>;
+    readonly toolbar: BooleanType;
+}>;
+/**
+ * Type representing the Library component.
+ */
+export type LibraryRootType = typeof LibraryRootType;
+/** A resolved Library card ({@link LibraryItemOf} over `UIComponentType`). */
+export declare const LibraryItemType: StructType<{
+    readonly search: OptionType<StringType>;
+    readonly groups: DictType<StringType, StringType>;
+    readonly facets: DictType<StringType, ArrayType<StringType>>;
+    readonly dims: DictType<StringType, 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 key: StringType;
+    readonly label: StringType;
+    readonly sublabel: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
+    readonly status: OptionType<StructType<{
+        readonly label: StringType;
+        readonly tone: import("@elaraai/east").VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly ring: BooleanType;
+    }>>;
+    readonly trailing: OptionType<StructType<{
+        readonly icon: StringType;
+        readonly label: StringType;
+        readonly tone: OptionType<import("@elaraai/east").VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+    }>>;
+    readonly draggable: BooleanType;
+    readonly filtered: BooleanType;
+    readonly placed: BooleanType;
+    readonly media: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    readonly avatar: OptionType<StringType>;
+    readonly byline: OptionType<StringType>;
+    readonly action: OptionType<StringType>;
+}>;
+/**
+ * Type representing resolved Library cards.
+ */
+export type LibraryItemType = typeof LibraryItemType;
+/** The card face the `item` accessor produces ({@link LibraryCardFaceOf} over `UIComponentType`). */
+export declare const LibraryCardFaceType: StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly sublabel: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
+    readonly status: OptionType<StructType<{
+        readonly label: StringType;
+        readonly tone: import("@elaraai/east").VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly ring: BooleanType;
+    }>>;
+    readonly trailing: OptionType<StructType<{
+        readonly icon: StringType;
+        readonly label: StringType;
+        readonly tone: OptionType<import("@elaraai/east").VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+    }>>;
+    readonly draggable: BooleanType;
+    readonly filtered: BooleanType;
+    readonly placed: BooleanType;
+    readonly media: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    readonly avatar: OptionType<StringType>;
+    readonly byline: OptionType<StringType>;
+    readonly action: OptionType<StringType>;
+}>;
+/**
+ * Type representing card face values.
+ */
+export type LibraryCardFaceType = typeof LibraryCardFaceType;
 /**
  * The struct element type of a `SubtypeExprOrValue<ArrayType<StructType>>`.
  */
@@ -32,8 +890,14 @@ export type RowElement<T extends SubtypeExprOrValue<ArrayType<StructType>>> = Ty
  * @property sublabel - Optional muted second line (role / class)
  * @property icon - Optional Font Awesome solid icon name
  * @property status - Optional status pill (`some(Library.status(...))` or a conditional option expression)
+ * @property trailing - Optional glyph at the card's right edge (`some(Library.glyph(...))` 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
+ * @property placed - Whether the card shows its placed state — the brand border and tint (default `false`)
+ * @property media - A gallery card's media: any UI component
+ * @property avatar - A gallery card's byline avatar: the name whose initials it shows
+ * @property byline - A gallery card's byline: the line in its foot, after the avatar
+ * @property action - A gallery card's action: a label in the link voice at its foot's end, which a click on the card follows
  */
 export interface LibraryCardFields {
     /** Item identity; carried by `LibraryRef` when dragged */
@@ -46,26 +910,59 @@ export interface LibraryCardFields {
     icon?: IconName | ExprType<StringType>;
     /** Optional status pill (`some(Library.status(...))` or a conditional option expression) */
     status?: SubtypeExprOrValue<OptionType<LibraryStatusType>>;
+    /** Optional glyph at the card's right edge (`some(Library.glyph(...))` or a conditional option expression) */
+    trailing?: SubtypeExprOrValue<OptionType<LibraryGlyphType>>;
     /** 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>;
+    /** Whether the card shows its placed state — the brand border and tint, as the item on the target (default `false`) */
+    placed?: SubtypeExprOrValue<BooleanType>;
+    /** A gallery card's media: any UI component — a page's wireframe, a chart, an image — drawn above the face or at its start */
+    media?: ExprType<UIComponentType>;
+    /** A gallery card's byline avatar: the name whose initials it shows */
+    avatar?: SubtypeExprOrValue<StringType>;
+    /** A gallery card's byline: the line in its foot, after the avatar */
+    byline?: SubtypeExprOrValue<StringType>;
+    /** A gallery card's action: a label in the link voice at its foot's end — "Open in builder →"; a click on the card follows it */
+    action?: SubtypeExprOrValue<StringType>;
 }
 /**
- * Creates a status pill value for a card face.
+ * Creates a status value for a card face.
  *
  * @param label - Pill text (rendered uppercase)
  * @param tone - Standard status tone
- * @returns An East expression of the status pill
+ * @param ring - Draw a gallery card's dot open, a state not reached yet (default `false`)
+ * @returns An East expression of the status
  *
  * @example
  * ```ts
  * import { Library } from "@elaraai/east-ui";
  *
  * // status: some(Library.status("On roster", "info"))
+ * // status: some(Library.status("Draft", "neutral", true))
+ * ```
+ */
+declare function createStatus(label: SubtypeExprOrValue<StringType>, tone: SubtypeExprOrValue<StatusTokenType> | StatusTokenLiteral, ring?: SubtypeExprOrValue<BooleanType>): ExprType<LibraryStatusType>;
+/**
+ * Creates a trailing glyph for a card face — a lock on something fixed, a dot
+ * for a status.
+ *
+ * @param icon - Font Awesome solid icon name
+ * @param label - What the glyph says, for assistive technology and the tooltip
+ * @param tone - Optional status tone that colours the glyph; without one it
+ *   takes the card's quiet ink, or the brand ink while the card is placed
+ * @returns An East expression of the glyph
+ *
+ * @example
+ * ```ts
+ * import { Library } from "@elaraai/east-ui";
+ *
+ * // trailing: some(Library.glyph("lock", "Logic fixed by the developer"))
+ * // trailing: some(Library.glyph("circle", "Live", "success"))
  * ```
  */
-declare function createStatus(label: SubtypeExprOrValue<StringType>, tone: SubtypeExprOrValue<StatusTokenType> | StatusTokenLiteral): ExprType<LibraryStatusType>;
+declare function createGlyph(icon: IconName | ExprType<StringType>, label: SubtypeExprOrValue<StringType>, tone?: SubtypeExprOrValue<StatusTokenType> | StatusTokenLiteral): ExprType<LibraryGlyphType>;
 /**
  * A meter dimension — utilisation bar with optional right-aligned text.
  *
@@ -130,6 +1027,24 @@ export interface LibraryTextDimDef<R extends StructType> {
  * A secondary dimension definition — one of the three render kinds.
  */
 export type LibraryDimensionDef<R extends StructType> = LibraryMeterDimDef<R> | LibraryChipsDimDef<R> | LibraryTextDimDef<R>;
+/**
+ * A facet of the Filter menu: the values each row holds, from which the menu
+ * lists the distinct ones.
+ *
+ * @typeParam R - The struct type of each data row
+ * @property key - Facet identity
+ * @property label - The facet's heading in the Filter menu
+ * @property values - The values a row holds — one for a single-valued facet
+ *   (a category), several for a multi-valued one (its tags)
+ */
+export interface LibraryFilterDef<R extends StructType> {
+    /** Facet identity */
+    key: string;
+    /** The facet's heading in the Filter menu */
+    label: string;
+    /** The values a row holds — one for a single-valued facet, several for a multi-valued one */
+    values: (row: ExprType<R>) => SubtypeExprOrValue<ArrayType<StringType>>;
+}
 /**
  * A group-by option: toolbar segment + per-row group value + optional
  * group-head summary computed over the group's members.
@@ -160,12 +1075,18 @@ export interface LibraryGroupDef<R extends StructType> {
  * @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 filters - The Filter menu's facets; unmatched cards hide, as the search's do
  * @property search - Filter-text accessor; unmatched cards hide (the footer shows the hidden count + Show all)
+ * @property noun - What the items are called — the search box counts them ("Search 47 components…")
  * @property addLabel - Optional footer action label
  * @property onAdd - Optional footer action callback
+ * @property onCardClick - Optional callback fired with a card's key when it is clicked
  * @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)
+ * @property style - Optional layout style (height / maxHeight / virtualization, and a gallery's columns and media)
+ * @property variant - How the cards are drawn: `"compact"` (the default) or `"gallery"`
+ * @property layout - How a gallery lays its cards out: `"grid"` (the default) or `"list"`
+ * @property toolbar - Whether the Library draws its toolbar row (default `true`)
  */
 export interface LibraryConfig<R extends StructType> {
     /** DnD source identity — targets list it in their `sources` */
@@ -180,12 +1101,29 @@ export interface LibraryConfig<R extends StructType> {
     defaultDimensions?: string[];
     /** GROUP BY options; omit for a flat list */
     groupBy?: LibraryGroupDef<R>[];
+    /**
+     * The Filter menu's facets. The menu lists each facet's distinct values;
+     * checking values keeps the cards that hold one of them, in every facet
+     * with a value checked. Unmatched cards hide, as the search's do, and the
+     * group counts follow.
+     */
+    filters?: LibraryFilterDef<R>[];
     /** Filter-text accessor; unmatched cards hide (the footer shows the hidden count + Show all) */
     search?: (row: ExprType<R>) => SubtypeExprOrValue<StringType>;
+    /** What the items are called — the search box counts them ("Search 47 components…"); default item / items */
+    noun?: {
+        singular: SubtypeExprOrValue<StringType>;
+        plural: SubtypeExprOrValue<StringType>;
+    };
     /** Optional footer action label */
     addLabel?: SubtypeExprOrValue<StringType>;
     /** Optional footer action callback */
     onAdd?: SubtypeExprOrValue<FunctionType<[], NullType>>;
+    /**
+     * Fired with a card's key when it is clicked. A drag never clicks, and a
+     * card that cannot be dragged is a button, so the keyboard clicks it too.
+     */
+    onCardClick?: SubtypeExprOrValue<FunctionType<[StringType], NullType>>;
     /**
      * Slice chrome — pass the bound handle and the Library renders the frame
      * chassis itself: a rail mounting the `affordances` (default
@@ -203,8 +1141,26 @@ export interface LibraryConfig<R extends StructType> {
     slice?: SubtypeExprOrValue<SliceBindType>;
     /** Rail affordances when `slice` is set (default `["filter", "search"]`) */
     affordances?: SliceAffordanceLiteral[];
-    /** Optional layout style (height / maxHeight / virtualization) */
+    /** Optional layout style (height / maxHeight / virtualization, and a gallery's columns and media) */
     style?: LibraryStyle;
+    /**
+     * How the cards are drawn: `"compact"` (the default), a line per card —
+     * the palette a surface drags from — or `"gallery"`, a large card per item
+     * with its `media`, a byline and an action — the library a person
+     * browses. A compact Library refuses the gallery's fields, naming each.
+     */
+    variant?: LibraryVariantLiteral;
+    /** How a gallery lays its cards out: `"grid"` (the default) or `"list"` — where it starts; the toolbar's switch changes it, and an expression that moves moves it. */
+    layout?: LibraryLayoutLiteral | SubtypeExprOrValue<LibraryLayoutType>;
+    /**
+     * Whether the Library draws its toolbar row (default `true`). `false`
+     * draws none, for a host whose one toolbar serves several libraries: the
+     * host narrows `data` itself and gives a gallery its `layout`. The
+     * options whose controls live in the toolbar — `search`, `groupBy`,
+     * `filters`, `dimensions`, `hint` and `slice` — are refused with it,
+     * naming each.
+     */
+    toolbar?: boolean;
 }
 /**
  * Creates a Library — a draggable palette of assignable items.
@@ -257,7 +1213,11 @@ export declare const Library: {
      * Declares the DnD **source** role under `config.id`. Cards with
      * `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.
+     * the `filtered` face field dims a card instead. `variant: "gallery"`
+     * draws the same cards large: each card's `media` — any UI component —
+     * above its face or at its start, its status as a dot and the word, and
+     * a foot holding its `avatar` and `byline` and its `action`; `onAdd`
+     * becomes a dashed last card.
      *
      * @example
      * ```ts
@@ -277,20 +1237,40 @@ export declare const Library: {
      */
     readonly Root: typeof createLibrary;
     /**
-     * Creates a status pill value for a card face.
+     * Creates a status value for a card face — a compact card's pill, a
+     * gallery card's dot and word.
      *
      * @param label - Pill text (rendered uppercase)
      * @param tone - Standard status tone (`success` / `warning` / `danger` / `info` / `neutral`)
-     * @returns An East expression of the status pill
+     * @param ring - Draw a gallery card's dot open, a state not reached yet (default `false`)
+     * @returns An East expression of the status
      *
      * @example
      * ```ts
      * import { Library } from "@elaraai/east-ui";
      *
      * // Library.status("At cap", "neutral")
+     * // Library.status("Draft", "neutral", true)
      * ```
      */
     readonly status: typeof createStatus;
+    /**
+     * Creates a trailing glyph for a card face — a lock on something fixed, a
+     * dot for a status.
+     *
+     * @param icon - Font Awesome solid icon name
+     * @param label - What the glyph says, for assistive technology and the tooltip
+     * @param tone - Optional status tone that colours the glyph
+     * @returns An East expression of the glyph
+     *
+     * @example
+     * ```ts
+     * import { Library } from "@elaraai/east-ui";
+     *
+     * // trailing: some(Library.glyph("lock", "Logic fixed by the developer"))
+     * ```
+     */
+    readonly glyph: typeof createGlyph;
     readonly Types: {
         /**
          * East StructType for the Library component.
@@ -306,16 +1286,34 @@ export declare const Library: {
          * @property groupSummaries - Group-head summary text per option key, per group value
          * @property dimOptions - SECONDARY dimension toggles
          * @property defaultDimensions - Initially-visible dimension keys
+         * @property filterOptions - The Filter menu's facets
          * @property searchable - Whether the search input renders
-         * @property addLabel - Optional footer action label
+         * @property noun - Optional name for the items
+         * @property addLabel - Optional footer action label — a gallery's dashed last card
          * @property onAdd - Optional footer action callback
+         * @property onCardClick - Optional callback fired with a clicked card's key
          * @property slice - Optional slice chrome (bound handle + rail affordances)
-         * @property style - Optional layout style (height / maxHeight / virtualization)
+         * @property style - Optional layout style (height / maxHeight / virtualization, and a gallery's columns and media)
+         * @property variant - How the cards are drawn; `none` is compact
+         * @property layout - How a gallery lays its cards out; `none` is the grid
+         * @property toolbar - Whether the Library draws its toolbar row
          */
         readonly Library: StructType<{
             readonly id: StringType;
             readonly hint: OptionType<StringType>;
             readonly items: ArrayType<StructType<{
+                readonly search: OptionType<StringType>;
+                readonly groups: DictType<StringType, StringType>;
+                readonly facets: DictType<StringType, ArrayType<StringType>>;
+                readonly dims: DictType<StringType, 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 key: StringType;
                 readonly label: StringType;
                 readonly sublabel: OptionType<StringType>;
@@ -329,20 +1327,26 @@ export declare const Library: {
                         readonly info: NullType;
                         readonly neutral: NullType;
                     }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly trailing: OptionType<StructType<{
+                    readonly icon: StringType;
+                    readonly label: StringType;
+                    readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>>;
                 }>>;
                 readonly draggable: BooleanType;
                 readonly filtered: BooleanType;
-                readonly search: OptionType<StringType>;
-                readonly groups: DictType<StringType, StringType>;
-                readonly dims: DictType<StringType, 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 placed: BooleanType;
+                readonly media: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+                readonly avatar: OptionType<StringType>;
+                readonly byline: OptionType<StringType>;
+                readonly action: OptionType<StringType>;
             }>>;
             readonly groupOptions: ArrayType<StructType<{
                 readonly key: StringType;
@@ -354,9 +1358,18 @@ export declare const Library: {
                 readonly label: StringType;
             }>>;
             readonly defaultDimensions: ArrayType<StringType>;
+            readonly filterOptions: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+            }>>;
             readonly searchable: BooleanType;
+            readonly noun: OptionType<StructType<{
+                readonly singular: StringType;
+                readonly plural: StringType;
+            }>>;
             readonly addLabel: OptionType<StringType>;
             readonly onAdd: OptionType<FunctionType<[], NullType>>;
+            readonly onCardClick: OptionType<FunctionType<[StringType], NullType>>;
             readonly slice: OptionType<StructType<{
                 readonly slice: StructType<{
                     readonly key: StringType;
@@ -1029,7 +2042,22 @@ export declare const Library: {
                 readonly height: OptionType<StringType>;
                 readonly maxHeight: OptionType<StringType>;
                 readonly virtualization: OptionType<BooleanType>;
+                readonly columns: OptionType<import("@elaraai/east").IntegerType>;
+                readonly mediaPlacement: OptionType<import("@elaraai/east").VariantType<{
+                    readonly top: NullType;
+                    readonly start: NullType;
+                }>>;
+                readonly mediaSize: OptionType<StringType>;
+            }>>;
+            readonly variant: OptionType<import("@elaraai/east").VariantType<{
+                readonly compact: NullType;
+                readonly gallery: NullType;
             }>>;
+            readonly layout: OptionType<import("@elaraai/east").VariantType<{
+                readonly grid: NullType;
+                readonly list: NullType;
+            }>>;
+            readonly toolbar: BooleanType;
         }>;
         /**
          * A resolved Library card.
@@ -1039,13 +2067,32 @@ export declare const Library: {
          * @property sublabel - Optional muted second line
          * @property icon - Optional Font Awesome solid icon name
          * @property status - Optional status pill
+         * @property trailing - Optional glyph at the card's right edge
          * @property draggable - Whether the card can start a drag
          * @property filtered - Whether the card renders de-emphasised
+         * @property placed - Whether the card shows its placed state
+         * @property media - A gallery card's media
+         * @property avatar - A gallery card's byline avatar
+         * @property byline - A gallery card's byline
+         * @property action - A gallery card's action
          * @property search - Optional filter text
          * @property groups - Group value per group-by option key
+         * @property facets - The values the card holds per filter key
          * @property dims - Secondary dimension value per dimension key
          */
         readonly Item: StructType<{
+            readonly search: OptionType<StringType>;
+            readonly groups: DictType<StringType, StringType>;
+            readonly facets: DictType<StringType, ArrayType<StringType>>;
+            readonly dims: DictType<StringType, 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 key: StringType;
             readonly label: StringType;
             readonly sublabel: OptionType<StringType>;
@@ -1059,20 +2106,26 @@ export declare const Library: {
                     readonly info: NullType;
                     readonly neutral: NullType;
                 }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly trailing: OptionType<StructType<{
+                readonly icon: StringType;
+                readonly label: StringType;
+                readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>>;
             }>>;
             readonly draggable: BooleanType;
             readonly filtered: BooleanType;
-            readonly search: OptionType<StringType>;
-            readonly groups: DictType<StringType, StringType>;
-            readonly dims: DictType<StringType, 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 placed: BooleanType;
+            readonly media: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+            readonly avatar: OptionType<StringType>;
+            readonly byline: OptionType<StringType>;
+            readonly action: OptionType<StringType>;
         }>;
         /**
          * The card face produced by the `item` accessor.
@@ -1081,9 +2134,15 @@ export declare const Library: {
          * @property label - Primary identity line
          * @property sublabel - Optional muted second line
          * @property icon - Optional Font Awesome solid icon name
-         * @property status - Optional status pill
+         * @property status - Optional status
+         * @property trailing - Optional glyph at the card's right edge
          * @property draggable - Whether the card can start a drag
          * @property filtered - Whether the card renders de-emphasised
+         * @property placed - Whether the card shows its placed state
+         * @property media - A gallery card's media
+         * @property avatar - A gallery card's byline avatar
+         * @property byline - A gallery card's byline
+         * @property action - A gallery card's action
          */
         readonly CardFace: StructType<{
             readonly key: StringType;
@@ -1099,15 +2158,33 @@ export declare const Library: {
                     readonly info: NullType;
                     readonly neutral: NullType;
                 }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly trailing: OptionType<StructType<{
+                readonly icon: StringType;
+                readonly label: StringType;
+                readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>>;
             }>>;
             readonly draggable: BooleanType;
             readonly filtered: BooleanType;
+            readonly placed: BooleanType;
+            readonly media: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+            readonly avatar: OptionType<StringType>;
+            readonly byline: OptionType<StringType>;
+            readonly action: OptionType<StringType>;
         }>;
         /**
-         * Status pill on a Library card.
+         * A Library card's status.
          *
          * @property label - Pill text (rendered uppercase)
          * @property tone - Standard status tone
+         * @property ring - A gallery card's dot drawn open
          */
         readonly Status: StructType<{
             readonly label: StringType;
@@ -1118,6 +2195,65 @@ export declare const Library: {
                 readonly info: NullType;
                 readonly neutral: NullType;
             }>;
+            readonly ring: BooleanType;
+        }>;
+        /**
+         * How a Library draws its cards.
+         *
+         * @property compact - A line per card — the palette
+         * @property gallery - A large card per item, with its media
+         */
+        readonly Variant: import("@elaraai/east").VariantType<{
+            readonly compact: NullType;
+            readonly gallery: NullType;
+        }>;
+        /**
+         * How a gallery lays its cards out.
+         *
+         * @property grid - Cards across the columns
+         * @property list - A card per row, its media at the start
+         */
+        readonly Layout: import("@elaraai/east").VariantType<{
+            readonly grid: NullType;
+            readonly list: NullType;
+        }>;
+        /**
+         * Where a gallery card's media sits in the grid layout.
+         *
+         * @property top - Above the face
+         * @property start - At the face's start
+         */
+        readonly MediaPlacement: import("@elaraai/east").VariantType<{
+            readonly top: NullType;
+            readonly start: NullType;
+        }>;
+        /**
+         * A glyph at a card's right edge.
+         *
+         * @property icon - Font Awesome solid icon name
+         * @property label - What the glyph says
+         * @property tone - Optional status tone that colours the glyph
+         */
+        readonly Glyph: StructType<{
+            readonly icon: StringType;
+            readonly label: StringType;
+            readonly tone: OptionType<import("@elaraai/east").VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+        }>;
+        /**
+         * What the Library calls its items.
+         *
+         * @property singular - One item
+         * @property plural - Any other count
+         */
+        readonly Noun: StructType<{
+            readonly singular: StringType;
+            readonly plural: StringType;
         }>;
         /**
          * A secondary dimension's value on one card.
@@ -1140,12 +2276,21 @@ export declare const Library: {
          *
          * @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`)
+         * @property virtualization - Whether rows virtualize inside the scroll region (default `true`); a gallery mounts every card
+         * @property columns - A gallery's cards across, in the grid layout
+         * @property mediaPlacement - Where a gallery card's media sits in the grid layout
+         * @property mediaSize - A gallery card's media height, placed on top, or width, placed at the start
          */
         readonly Style: StructType<{
             readonly height: OptionType<StringType>;
             readonly maxHeight: OptionType<StringType>;
             readonly virtualization: OptionType<BooleanType>;
+            readonly columns: OptionType<import("@elaraai/east").IntegerType>;
+            readonly mediaPlacement: OptionType<import("@elaraai/east").VariantType<{
+                readonly top: NullType;
+                readonly start: NullType;
+            }>>;
+            readonly mediaSize: OptionType<StringType>;
         }>;
     };
 };