@yuuvis/client-framework 3.17.1 → 3.19.0

package/lib/assets/i18n/de.json

@@ -92,6 +92,7 @@
   "yuv.object-metadata.tabs.indexdata.title": "Metadaten",
   "yuv.object-flavor.apply-flavor.button.apply": "Anwenden",
   "yuv.object-flavor.apply-flavor.button.cancel": "Abbrechen",
+  "yuv.object-flavor.apply-flavor.error": "Der Typ konnte nicht hinzugefügt werden.",
   "yuv.object-flavor.apply-flavor.headline": "Typ '{{name}}' hinzufügen",
   "yuv.object-flavor.button.add": "Typ hinzufügen",
   "yuv.object-flavor.button.clear-selection": "Auswahl aufheben",

package/lib/assets/i18n/en.json

@@ -92,6 +92,7 @@
   "yuv.object-metadata.tabs.indexdata.title": "Metadata",
   "yuv.object-flavor.apply-flavor.button.apply": "Apply",
   "yuv.object-flavor.apply-flavor.button.cancel": "Cancel",
+  "yuv.object-flavor.apply-flavor.error": "The type could not be added.",
   "yuv.object-flavor.apply-flavor.headline": "Add type '{{name}}'",
   "yuv.object-flavor.button.add": "Add type",
   "yuv.object-flavor.button.clear-selection": "Unselect",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuuvis/client-framework",
-  "version": "3.17.1",
+  "version": "3.19.0",
   "author": "OPTIMAL SYSTEMS GmbH <npm@optimal-systems.de>",
   "license": "MIT",
   "peerDependencies": {
@@ -8,16 +8,16 @@
     "@angular/common": "^21.2.19",
     "@angular/core": "^21.2.19",
     "angular-gridster2": "^21.0.1",
-    "@yuuvis/client-core": "^3.17.1",
-    "@yuuvis/client-shell-core": "^3.17.1",
-    "@yuuvis/client-components": "^3.17.1",
+    "@yuuvis/client-core": "^3.19.0",
+    "@yuuvis/client-shell-core": "^3.19.0",
+    "@yuuvis/client-components": "^3.19.0",
     "ng-dynamic-component": "^10.8.2",
     "modern-normalize": "^3.0.1"
   },
   "dependencies": {
     "@angular/material": "^21.2.14",
     "@ngrx/signals": "^21.1.0",
-    "@yuuvis/material": "^3.17.1",
+    "@yuuvis/material": "^3.19.0",
     "@yuuvis/media-viewer": "^4.0.0",
     "angular-split": "^20.0.0",
     "vis-network": "^10.0.2",

package/smart-search/README.md

@@ -46,16 +46,66 @@ export class SearchComponent {
 
 ### Inputs
 
-| Input            | Type       | Default | Description                                                                                   |
-| ---------------- | ---------- | ------- | --------------------------------------------------------------------------------------------- |
-| `types`          | `string[]` | `[]`    | Object-type ids that may be searched. Set at least one to enable building blocks.             |
-| `skipProperties` | `string[]` | `[]`    | Field ids to hide from the field picker (e.g. internal/system properties).                    |
+| Input                      | Type       | Default | Description                                                                                                                  |
+| -------------------------- | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `types`                    | `string[]` | `[]`    | Object-type ids that may be searched. Set at least one to enable building blocks.                                            |
+| `skipProperties`           | `string[]` | `[]`    | Field ids to hide from the field picker (e.g. internal/system properties).                                                   |
+| `fulltextOnly`             | `boolean`  | `false` | Renders only the full-text bar — no condition builder. See [Full-text only](#full-text-only).                                |
+| `supportDynamicConditions` | `boolean`  | `false` | Enables marking conditions as *dynamic* and the form-mode toggle that swaps the builder for a fill-out form of those fields. |
 
 ### Outputs
 
-| Output        | Type     | Description                                                                                 |
-| ------------- | -------- | ------------------------------------------------------------------------------------------- |
-| `queryChange` | `string` | The current CMIS query. Emitted on every change; `''` means an empty search ("no query").   |
+| Output        | Type     | Description                                                                                                    |
+| ------------- | -------- | ---------------------------------------------------------------------------------------------------------------- |
+| `queryChange` | `string` | The current CMIS query. Emitted on **every** change; `''` means an empty search ("no query").                  |
+| `querySubmit` | `string` | The current CMIS query, emitted when the user presses <kbd>Enter</kbd> to submit. Same `''` convention.        |
+
+### Full-text only
+
+`fulltextOnly` reduces the component to a plain full-text search: the term box, the scope
+select and the object-type filter stay, everything else — type blocks, the add-type row, the
+inline condition editor and the form-mode toggle — is not rendered.
+
+```html
+<yuv-smart-search [types]="['document', 'invoice']" [fulltextOnly]="true" (querySubmit)="runSearch($event)" />
+```
+
+`types` keeps its meaning, so the emitted query is still scoped to the allowed types:
+
+```sql
+-- types=['document','invoice'], full-text "acme", type filter left on "All types"
+SELECT * FROM system:object WHERE (objectTypeId IN ('document','invoice') AND CONTAINS('acme'))
+```
+
+Because the blocks are not rendered, they are not queried either: a state restored via
+`loadState()` keeps its blocks (they come back when the flag is cleared) but only its full-text
+unit contributes to the emitted query while the flag is set.
+
+### Submitting with Enter
+
+`queryChange` is a live preview — it fires on every keystroke and every edit. To run a
+search only when the user is *done*, bind `querySubmit` instead: it behaves like an HTML
+form, emitting when <kbd>Enter</kbd> reaches the component without an inner widget having
+claimed the key.
+
+Widgets that own <kbd>Enter</kbd> for their own purpose keep it, so a submit never
+happens by surprise:
+
+| Where <kbd>Enter</kbd> is pressed                | What happens                                     |
+| ------------------------------------------------ | ------------------------------------------------ |
+| Suggestion list open (type / field / operator)   | Picks the highlighted suggestion                 |
+| Catalog, date or other value widget with a panel | Opens the panel / picks the value                |
+| Inline editor with a condition in progress       | Commits the condition — the *next* Enter submits |
+| Add-type input with staged types                 | Confirms the type block                          |
+| Focus on a button (remove, confirm, …)           | Activates the button                             |
+| Anywhere else (full-text bar, fill-out form, …)  | **Submits** — `querySubmit` emits                |
+
+<kbd>Shift</kbd>+<kbd>Enter</kbd> and <kbd>Enter</kbd> inside a multi-line value never
+submit, so long text entry keeps working.
+
+```html
+<yuv-smart-search [types]="types" (queryChange)="preview.set($event)" (querySubmit)="runSearch($event)" />
+```
 
 ### Saving and restoring state
 

package/types/yuuvis-client-framework-badges.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { Signal } from '@angular/core';
-import { DmsObject, YuvUser, LockState } from '@yuuvis/client-core';
+import { DmsObject, YuvUser, LockState, VirtualObjectType } from '@yuuvis/client-core';
 import { Severity } from '@yuuvis/material/badge';
 
 type BadgeSeverity = Severity;
@@ -14,6 +14,23 @@ interface BadgeRule {
     op: 'isSet' | 'equals' | 'tagPresent';
     value?: unknown;
 }
+/**
+ * Restricts the object types a badge may be configured for. Mirrors
+ * `ActionSupport`: an entry matches when the object type id is listed in
+ * `types` or `sots`, or matches `pattern`.
+ *
+ * This scopes *configurability* (which types offer the badge in selection UIs
+ * such as the tile config), not rendering — whether a badge actually shows on
+ * a given object stays governed by {@link Badge.applies} / {@link Badge.rule}.
+ */
+interface BadgeSupport {
+    /** Object types the badge can be configured for (e.g. `system:document`). */
+    types?: string[];
+    /** Secondary object types the badge can be configured for. */
+    sots?: string[];
+    /** Pattern matched against the object type id. */
+    pattern?: string;
+}
 interface Badge {
     id: string;
     labelKey: string;
@@ -29,6 +46,12 @@ interface Badge {
      * the id filter. Variants are hidden from selection UIs.
      */
     variantOf?: string;
+    /**
+     * Object types this badge may be configured for. When omitted, the badge is
+     * offered for every type. Variants inherit the support of their parent badge
+     * and are hidden from selection UIs anyway.
+     */
+    supports?: BadgeSupport;
     applies?: (dmsObject: DmsObject, ctx: BadgeContext) => boolean;
     rule?: BadgeRule;
 }
@@ -53,10 +76,15 @@ declare class BadgeSelectComponent {
     #private;
     selectedBadgeIds: _angular_core.InputSignal<string[]>;
     bucket: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Type currently being configured. Badges that declare `supports` are only
+     * offered for the types they support. Omitting it offers every badge.
+     */
+    objectType: _angular_core.InputSignal<VirtualObjectType | undefined>;
     badgeSelect: _angular_core.OutputEmitterRef<Badge>;
     readonly badges: Signal<Badge[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeSelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeSelectComponent, "yuv-tile-badge-select", never, { "selectedBadgeIds": { "alias": "selectedBadgeIds"; "required": false; "isSignal": true; }; "bucket": { "alias": "bucket"; "required": false; "isSignal": true; }; }, { "badgeSelect": "badgeSelect"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeSelectComponent, "yuv-tile-badge-select", never, { "selectedBadgeIds": { "alias": "selectedBadgeIds"; "required": false; "isSignal": true; }; "bucket": { "alias": "bucket"; "required": false; "isSignal": true; }; "objectType": { "alias": "objectType"; "required": false; "isSignal": true; }; }, { "badgeSelect": "badgeSelect"; }, never, never, true, never>;
 }
 
 /**
@@ -84,6 +112,10 @@ declare const LOCK_SELF_BADGE: Badge;
  * @remarks
  * - `severity` is set to `'danger'` to visually emphasize the retention constraint.
  * - `priority` is `20`, which controls the display order relative to other badges.
+ * - `supports` limits the badge to documents, so selection UIs such as the tile
+ *   config do not offer it for folder types. It only scopes configurability -
+ *   `applies` still governs rendering, so an object under retention keeps its
+ *   badge regardless.
  */ declare const RETENTION_BADGE: Badge;
 
 declare class BadgeRegistryService {
@@ -196,6 +228,21 @@ declare class TileBadgesComponent {
  * @returns `true` if the rule matches; otherwise `false`.
  */
 declare function evaluateRule(rule: BadgeRule, dmsObject: DmsObject): boolean;
+/**
+ * Checks whether a badge may be configured for the given object type.
+ *
+ * A badge without {@link Badge.supports} is unrestricted and matches every
+ * type. Otherwise the type's `objectType` and its `sots` are matched against
+ * the badge's `types` / `sots` lists and its `pattern`; a single hit is enough.
+ *
+ * Called without an object type (no type context available) the badge is kept,
+ * so callers that do not know the type never lose badges.
+ *
+ * @param badge Badge to check.
+ * @param objectType Type the selection UI is currently configuring.
+ * @returns `true` if the badge may be offered for that type; otherwise `false`.
+ */
+declare function badgeSupportsType(badge: Badge, objectType?: VirtualObjectType): boolean;
 
-export { BadgeChipComponent, BadgeRegistryService, BadgeSelectComponent, LOCK_BADGE, LOCK_SELF_BADGE, RETENTION_BADGE, TileBadgesComponent, evaluateRule };
-export type { Badge, BadgeContext, BadgeRule, BadgeSeverity };
+export { BadgeChipComponent, BadgeRegistryService, BadgeSelectComponent, LOCK_BADGE, LOCK_SELF_BADGE, RETENTION_BADGE, TileBadgesComponent, badgeSupportsType, evaluateRule };
+export type { Badge, BadgeContext, BadgeRule, BadgeSeverity, BadgeSupport };

package/types/yuuvis-client-framework-object-preview.d.ts

@@ -61,7 +61,20 @@ declare class ObjectPreviewService {
     dmsObject: _angular_core.Signal<DmsObject | undefined>;
     setDmsObject(object: DmsObject): void;
     getDmsObject(id: string): Observable<DmsObject>;
-    getMediaViewerSrc(id: string, mimeType: string | undefined, version?: number): string;
+    /**
+     * Builds the media viewer source URL for an object's content.
+     *
+     * The URL of the *current* version is keyed on the content stream (`_cs=<contentStreamId>`) when one is
+     * given. The viewers only reload when their `src` input is a *different string*: `DynamicViewerDirective`
+     * `setInput`s the same viewer instance for a same-type update, `PdfComponent` skips `#loadPDF` for a src
+     * it has already loaded and `ImageComponent` derives its cache-busting URL from `src()` alone. Without
+     * the key a content replacement that keeps the mime type kept showing the previous file (the object id,
+     * and therefore the URL, never changed). `ObjectPreviewComponent` rebuilds the details exactly when the
+     * content stream changes, so the key changes exactly then — never on metadata-only saves.
+     *
+     * Versioned URLs (`/versions/{n}/…`) address immutable content and are returned unchanged.
+     */
+    getMediaViewerSrc(id: string, mimeType: string | undefined, version?: number, contentStreamId?: string): string;
     getEmailViewerDetails(object: DmsObject, version?: number, MAIL_APP_ID?: string): ViewerDataEmail;
     getEmailMetadata(object: DmsObject, MAIL_APP_ID?: string): EmailMetadata;
     getViewerDetails(object: DmsObject, version: number | undefined): ViewerDataEmail | ViewerDataDefault | undefined;

package/types/yuuvis-client-framework-renderer.d.ts

@@ -82,6 +82,11 @@ declare class BooleanRendererComponent extends AbstractRendererComponent {
 }
 
 declare class DateTimeRendererComponent extends AbstractRendererComponent<Date> {
+    /**
+     * Fields declared with `resolution: 'date'` hold a calendar day, so rendering them with the
+     * default `short` format would invent a time that is not stored anywhere.
+     */
+    protected dateOnly: i0.Signal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeRendererComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeRendererComponent, "yuv-datetime-renderer", never, {}, {}, never, never, true, never>;
 }
@@ -91,6 +96,22 @@ declare class DecimalRendererComponent extends AbstractRendererComponent<number>
     static ɵcmp: i0.ɵɵComponentDeclaration<DecimalRendererComponent, "yuv-decimal-renderer", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Renders the value(s) of a dynamic catalog field (schema field carrying a `catalog` reference).
+ *
+ * Those fields store the technical entry name, so the label has to be resolved from the catalog
+ * entry's localizations — the same resolution `yuv-dynamic-catalog` does for the form element.
+ * The entries are fetched and cached by `CatalogLabelService` (once per catalog, not once per
+ * renderer instance — a summary or tile list mounts many rows of the same catalog).
+ * Values without a matching entry fall back to the technical value.
+ */
+declare class DynamicCatalogRendererComponent extends AbstractRendererComponent<string | string[]> {
+    #private;
+    readonly label: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicCatalogRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicCatalogRendererComponent, "yuv-dynamic-catalog-renderer", never, {}, {}, never, never, true, never>;
+}
+
 declare class FileSizeRendererComponent extends AbstractRendererComponent {
     parsedValue: i0.Signal<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FileSizeRendererComponent, never>;
@@ -162,7 +183,7 @@ declare class UnknownRendererComponent extends AbstractRendererComponent<any> {
     static ɵcmp: i0.ɵɵComponentDeclaration<UnknownRendererComponent, "yuv-unknown-renderer", never, {}, {}, never, never, true, never>;
 }
 
-type RendererComponent = IntegerRendererComponent | DecimalRendererComponent | DateTimeRendererComponent | IconRendererComponent | StringRendererComponent | BooleanRendererComponent | TableRendererComponent | I18nCatalogRendererComponent;
+type RendererComponent = IntegerRendererComponent | DecimalRendererComponent | DateTimeRendererComponent | IconRendererComponent | StringRendererComponent | BooleanRendererComponent | TableRendererComponent | I18nCatalogRendererComponent | DynamicCatalogRendererComponent;
 type RendererDirectiveInput = ResolvedObjectConfigItem;
 
 /**
@@ -207,5 +228,5 @@ declare class RendererDirective {
     static ɵdir: i0.ɵɵDirectiveDeclaration<RendererDirective, "[yuvRenderer]", never, { "yuvRenderer": { "alias": "yuvRenderer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { AbstractAuditRendererComponent, AbstractRendererComponent, AuditRendererDirective, AuditRendererService, BooleanRendererComponent, DateTimeRendererComponent, DecimalRendererComponent, DefaultAuditRendererComponent, FileSizeRendererComponent, I18nCatalogRendererComponent, IconRendererComponent, IntegerRendererComponent, OrganizationRendererComponent, RendererDirective, RendererService, StringRendererComponent, TableRendererComponent, UnknownRendererComponent };
+export { AbstractAuditRendererComponent, AbstractRendererComponent, AuditRendererDirective, AuditRendererService, BooleanRendererComponent, DateTimeRendererComponent, DecimalRendererComponent, DefaultAuditRendererComponent, DynamicCatalogRendererComponent, FileSizeRendererComponent, I18nCatalogRendererComponent, IconRendererComponent, IntegerRendererComponent, OrganizationRendererComponent, RendererDirective, RendererService, StringRendererComponent, TableRendererComponent, UnknownRendererComponent };
 export type { RendererComponent, RendererDirectiveInput };

package/types/yuuvis-client-framework-smart-search.d.ts

@@ -116,6 +116,12 @@ interface SuggestionItem {
  * Capture via {@link SmartSearchComponent.getState} and restore via
  * {@link SmartSearchComponent.loadState}. Safe for `JSON.stringify` /
  * `JSON.parse` roundtrips (plain data, no class instances or signals).
+ *
+ * The display labels it carries (`SearchBlockType.label`, `FieldCondition.fieldLabel` /
+ * `operatorLabel` / `conditionLabel` and `TableCondition.fieldLabel`) are a snapshot of the
+ * language the state was captured in. `loadState` re-resolves them from the live schema and the
+ * current language, so a state built by hand only needs the ids — the labels are a fallback for
+ * ids that can no longer be resolved.
  */
 interface SmartSearchState {
     blocks: SearchBlock[];
@@ -154,7 +160,10 @@ interface DynamicFormBlock {
  */
 declare class SmartSearchEditController {
     #private;
-    /** The set of object type IDs that can be used as search blocks. */
+    /**
+     * The set of object type IDs the search is scoped to. Empty = unscoped: every
+     * searchable type of the schema is a candidate and nothing is restricted.
+     */
     allowedTypes: _angular_core.WritableSignal<string[]>;
     /** ObjectTypeField IDs to exclude from the field-step autocomplete suggestions. */
     skipProperties: _angular_core.WritableSignal<string[]>;
@@ -189,6 +198,12 @@ declare class SmartSearchEditController {
     fulltext: _angular_core.WritableSignal<FulltextSearch>;
     /** Whether the dynamic-conditions feature is enabled (mirrors the host `supportDynamicConditions` input). */
     supportDynamic: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the host renders a plain full-text search (mirrors its `fulltextOnly` input).
+     * The condition builder is hidden and {@link cmisQuery} is built from {@link fulltext}
+     * alone, so blocks a loaded state carries can't contribute invisible clauses.
+     */
+    fulltextOnly: _angular_core.WritableSignal<boolean>;
     /**
      * Form mode: replace the builder with a generated form of the user-marked dynamic
      * conditions. View state only — the template ({@link blocks}) is never mutated; the
@@ -207,6 +222,17 @@ declare class SmartSearchEditController {
     /** Whether any condition is marked dynamic (gates the form-mode toggle). */
     hasDynamicConditions: _angular_core.Signal<boolean>;
     objectTypes: _angular_core.Signal<GenericObjectType[]>;
+    /**
+     * The types an "all types" pick resolves to. With a configured allow-list, "all types"
+     * means *any of the allowed types* — not every type of the system — so the restriction
+     * is still emitted. Without one the list is empty and "all types" restricts nothing.
+     *
+     * Resolved id-by-id against the schema (rather than from {@link objectTypes}) so an
+     * allowed id the current schema doesn't know still narrows the query instead of silently
+     * widening it; `isSot` decides whether the id lands in the primary or the secondary
+     * object-type clause.
+     */
+    scopeTypes: _angular_core.Signal<SearchBlockType[]>;
     /** Fields for the active top-level block, used by the field-step suggestions. */
     activeBlockFields: _angular_core.Signal<SuggestionItem[]>;
     /**
@@ -229,7 +255,16 @@ declare class SmartSearchEditController {
     activeCtrl: _angular_core.Signal<FormControl<unknown>>;
     /** Deep-clone the current blocks, combinator and full-text unit into a serializable {@link SmartSearchState}. */
     getState(): SmartSearchState;
-    /** Replace the current state with a saved one, normalizing legacy blocks and cancelling any in-progress edit. */
+    /**
+     * Replace the current state with a saved one, normalizing legacy blocks and cancelling any
+     * in-progress edit.
+     *
+     * Everything a persisted state carries for display only — type, field and operator labels and
+     * the composed condition label — is re-resolved against the live schema and the *current* UI
+     * language (see {@link #resolveType} / {@link #relabelNodes}), so a query saved in one language
+     * reads in the language it is restored in. The persisted strings act as the fallback for ids the
+     * schema or the translations can no longer resolve.
+     */
     loadState(state: SmartSearchState): void;
     /** Reset all search state back to its initial empty values. */
     reset(): void;
@@ -245,9 +280,19 @@ declare class SmartSearchEditController {
     exitFormMode(): void;
     /** Toggle form mode (rebuilds the form rows on each entry). */
     toggleFormMode(): void;
-    /** Record a value entered in the form for a dynamic condition (drives the overlaid {@link cmisQuery}). */
+    /**
+     * Record a value entered in the form for a dynamic condition (drives the overlaid
+     * {@link cmisQuery}). No-op when unchanged, so re-applying a row's current value —
+     * e.g. flushing the debounced controls on submit — can't churn the query.
+     */
     setFormValue(condition: FieldCondition, raw: unknown): void;
-    /** Set the full-text search term. */
+    /**
+     * Re-apply every generated form row's current control value. The row controls are
+     * debounced, so a submit fired immediately after typing would otherwise read a stale
+     * overlay. Rows whose value already matches are skipped by {@link setFormValue}.
+     */
+    flushFormValues(): void;
+    /** Set the full-text search term. No-op when unchanged, so re-setting it can't churn {@link cmisQuery}. */
     setFulltextTerm(term: string): void;
     /** Set the full-text search scope (`all` / `metadata` / `content`). */
     setFulltextScope(scope: FulltextScope): void;
@@ -312,7 +357,10 @@ declare class SmartSearchEditController {
     isConditionComplete(): boolean;
     /** The operators available for a field's internal type, as autocomplete items. */
     operatorsForField(field: SuggestionItem): SuggestionItem[];
-    /** Human-readable label for an operator id: a math symbol (`=`, `≠`, …), a translated key, or the id itself. */
+    /**
+     * Human-readable label for an operator id: a math symbol (`=`, `≠`, …), a translated
+     * key, a translated date-preset label (`date:thisMonth` → “This month”) or the id itself.
+     */
     operatorLabel(operator: string): string;
     /** Build a condition record from a date preset / boolean operator / value. */
     buildCommitCondition(field: SuggestionItem, operatorId: string, operatorLabelText: string, value: string | string[], internalTypeOverride?: string): FieldCondition;
@@ -350,8 +398,13 @@ declare function buildNodeClause(node: ConditionNode): string;
 /**
  * Build the whole-object full-text clause: a single `CONTAINS('term')` predicate, optionally scoped
  * to a column and AND-ed with a type restriction. Returns `''` when the term is blank.
+ *
+ * @param fulltext The full-text unit. An empty `types` list means "all types".
+ * @param scopeTypes The types the search is scoped to (the host's `types` allow-list). When
+ * the unit picks no concrete type, "all types" means *any of these* — so the restriction is
+ * still emitted. Pass an empty list for an unscoped search: then "all types" restricts nothing.
  */
-declare function buildFulltextClause(fulltext: FulltextSearch): string;
+declare function buildFulltextClause(fulltext: FulltextSearch, scopeTypes?: SearchBlockType[]): string;
 /**
  * Assemble the full CMIS statement from the search state. Each unit — the
  * full-text clause plus every type block (type restriction `AND`-ed with its
@@ -361,9 +414,12 @@ declare function buildFulltextClause(fulltext: FulltextSearch): string;
  * @param blocks The type blocks with their conditions.
  * @param combinator How the top-level units combine (`AND` / `OR`).
  * @param fulltext Optional whole-object full-text unit.
+ * @param scopeTypes The types the whole search is scoped to (the host's `types` allow-list).
+ * Applied to the full-text unit when it targets "all types"; the blocks always carry their own
+ * (already scoped) types. Empty = unscoped, i.e. "all types" restricts nothing.
  * @returns A `SELECT * FROM system:object WHERE …` statement, or `''`.
  */
-declare function buildCmisQuery(blocks: SearchBlock[], combinator: Combinator, fulltext?: FulltextSearch): string;
+declare function buildCmisQuery(blocks: SearchBlock[], combinator: Combinator, fulltext?: FulltextSearch, scopeTypes?: SearchBlockType[]): string;
 
 /**
  * Visual query builder that turns guided, chip-based user input into a CMIS query.
@@ -374,15 +430,26 @@ declare function buildCmisQuery(blocks: SearchBlock[], combinator: Combinator, f
  * - one or more **type blocks**, each targeting one or more object types and holding
  *   field conditions, nested groups and table-column conditions.
  *
+ * Set {@link fulltextOnly} to drop the second part entirely and render a plain full-text
+ * search bar.
+ *
  * Conditions are built step by step (type → field → operator → value) with an inline
  * autocomplete editor; the value step renders the field's real metadata widget
  * (datepicker, catalog select, organization picker, …). The resulting CMIS query is
  * emitted through {@link queryChange} on every change and can be saved/restored as a
- * plain-data {@link SmartSearchState} via {@link getState} / {@link loadState}.
+ * plain-data {@link SmartSearchState} via {@link getState} / {@link loadState}. A restored
+ * state is re-labelled in the current UI language (see {@link loadState}).
  *
  * State and mutators live in {@link SmartSearchEditController} (provided per instance);
  * this component owns only the UI concerns (focus, autocomplete plumbing, blur handling).
  *
+ * **Submitting.** {@link queryChange} is a live preview — it fires on every change. To run
+ * a search only when the user is done, bind {@link querySubmit}: it emits when ENTER
+ * reaches the component without an inner widget having claimed it, the way a plain HTML
+ * form submits on ENTER. Widgets that own ENTER for their own purpose keep it: the
+ * suggestion autocomplete picks an option, a catalog select picks a value, and the inline
+ * editor commits the condition it is building. Only the *next* ENTER then submits.
+ *
  * @example
  * ```html
  * <!-- Restrict the picker to two object types and skip a noisy property -->
@@ -417,9 +484,14 @@ declare class SmartSearchComponent {
     #private;
     ctrl: SmartSearchEditController;
     /**
-     * Object-type ids that may be searched. Restricts the type picker (both the
-     * full-text type filter and the type-block multi-select) to these types. When
-     * empty, no type is offered — set at least one id to enable building blocks.
+     * Object-type ids that may be searched — the scope of the whole search. Restricts
+     * the type picker (both the full-text type filter and the type-block multi-select)
+     * to these types, and narrows the emitted query: picking *All types* in the
+     * full-text filter then means "any of these types" (`objectTypeId IN (…)`), not
+     * every type the system knows.
+     *
+     * When empty the search is unscoped — *All types* restricts nothing — and no type
+     * is offered in the picker, so only a full-text search can be built.
      */
     types: _angular_core.InputSignal<string[]>;
     /**
@@ -428,6 +500,14 @@ declare class SmartSearchComponent {
      * table columns alike.
      */
     skipProperties: _angular_core.InputSignal<string[]>;
+    /**
+     * Renders the component as a plain full-text search: only the full-text bar (term, scope
+     * and the object-type filter) is shown — no type blocks, no condition builder, no
+     * form-mode toggle. The emitted query is built from the full-text unit alone, so a
+     * previously {@link loadState loaded} state's blocks do not contribute while this is set.
+     * {@link types} keeps its meaning: the search stays scoped to those types.
+     */
+    fulltextOnly: _angular_core.InputSignal<boolean>;
     /**
      * Enables the **dynamic conditions** feature. When `true`, each committed condition can
      * be marked dynamic and a form-mode toggle appears that swaps the builder for a generated
@@ -442,6 +522,14 @@ declare class SmartSearchComponent {
      * non-empty values.
      */
     queryChange: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Emits the current CMIS query when the user presses ENTER and no inner widget
+     * claimed that key — the smart-search equivalent of submitting a form. Bind this
+     * (rather than {@link queryChange}) to run the search only once the user is done
+     * building it. Like {@link queryChange}, `''` means "no query"; an empty search
+     * still submits.
+     */
+    querySubmit: _angular_core.OutputEmitterRef<string>;
     auto: _angular_core.Signal<MatAutocomplete>;
     /** Trigger of the currently-focused autocomplete input — used to re-open the
      * panel after a type pick so the multi-select stays open. */
@@ -450,6 +538,14 @@ declare class SmartSearchComponent {
     fulltextTermCtrl: FormControl<string | null>;
     /** Sentinel option value representing "no type restriction" in the type multi-select. */
     readonly ALL_TYPES = "__all__";
+    /**
+     * Empty `matChipInputSeparatorKeyCodes` for the add-type input. The directive defaults
+     * to `[ENTER]` and then calls `preventDefault()` on *every* Enter to end a chip — but
+     * we never bind `matChipInputTokenEnd`, so that only served to hide the key from
+     * {@link onHostEnter}. A stable reference: a `[]` literal in the template would be a
+     * new array on each change-detection run.
+     */
+    readonly NO_SEPARATOR_KEYS: number[];
     /**
      * Guard that prevents `onInlineBlur` from cancelling the pending condition
      * when we programmatically open the inline editor.
@@ -523,7 +619,15 @@ declare class SmartSearchComponent {
      * later restore it with {@link loadState}.
      */
     getState(): SmartSearchState;
-    /** Restore a previously {@link getState saved} search, replacing the current one. */
+    /**
+     * Restore a previously {@link getState saved} search, replacing the current one.
+     *
+     * The display labels a state carries (type, field and operator labels and the chip's composed
+     * condition label) are re-resolved against the live schema and the *current* UI language, so a
+     * search saved in one language reads in the language it is restored in. Ids the schema or the
+     * translations can no longer resolve keep the label the state carried. Nothing that drives the
+     * emitted query is affected.
+     */
     loadState(state: SmartSearchState): void;
     /** Clear the whole search: discard all blocks, conditions and the full-text term. */
     clear(): void;
@@ -579,14 +683,32 @@ declare class SmartSearchComponent {
      * pick, so Enter commits the staged types — even while the autocomplete panel
      * is open. While the user is typing a filter term, Enter is left to the
      * autocomplete so it can select the highlighted option.
+     *
+     * Unlike {@link onEnter} this deliberately lets an unusable Enter fall through:
+     * the add-type input is the resting state of an empty search, so Enter with
+     * nothing staged has to reach {@link onHostEnter} and submit.
      */
-    onTypeEnter(): void;
+    onTypeEnter(event: Event): void;
     /**
-     * Enter / confirm-button handler for the value step. Commits the in-progress
-     * condition when a value is present. No-op while the autocomplete panel is open
-     * (Enter selects the highlighted option there) or before the value step.
+     * Enter / confirm-button handler for the inline editor. Commits the in-progress
+     * condition once it has a field and an operator. No-op while the autocomplete
+     * panel is open (Enter selects the highlighted option there).
+     *
+     * Bound on the editor wrapper, so it covers every step — including the value
+     * step's real metadata widget — and runs after the widgets' own key handling.
+     * The `event` is optional because the confirm button calls this from a click.
      */
-    onEnter(): void;
+    onEnter(event?: Event): void;
+    /**
+     * Enter that bubbled all the way up to the component host without being claimed:
+     * submit the search, the way a plain HTML form does.
+     *
+     * Everything inside that owns Enter marks the event handled via `preventDefault()`
+     * — Material's autocomplete and select do, and so do {@link onEnter} /
+     * {@link onTypeEnter} — so this only sees the "nothing else wanted it" case. The
+     * remaining guards cover keys the browser itself is still acting on.
+     */
+    onHostEnter(event: KeyboardEvent | Event): void;
     /**
      * Called when the inline-input wrapper loses focus.
      * Commits the condition if complete, discards it if incomplete.
@@ -609,7 +731,11 @@ declare class SmartSearchComponent {
      * condition, mirroring the blur path.
      */
     onPickerClosed(): void;
-    /** Abandon the in-progress condition edit, discarding any partial input. */
+    /**
+     * Abandon the in-progress condition edit, discarding any partial input. When an
+     * existing condition was opened for editing it is put back verbatim rather than
+     * lost — cancelling an edit means "leave it as it was", the same as the blur path.
+     */
     cancelPending(): void;
     /** Jump the inline editor back to the field step so the user can re-pick the field. */
     editField(): void;
@@ -639,7 +765,7 @@ declare class SmartSearchComponent {
      */
     getObjectTypeField(item: SuggestionItem | null): ObjectTypeField | null;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartSearchComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartSearchComponent, "yuv-smart-search", never, { "types": { "alias": "types"; "required": false; "isSignal": true; }; "skipProperties": { "alias": "skipProperties"; "required": false; "isSignal": true; }; "supportDynamicConditions": { "alias": "supportDynamicConditions"; "required": false; "isSignal": true; }; }, { "queryChange": "queryChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartSearchComponent, "yuv-smart-search", never, { "types": { "alias": "types"; "required": false; "isSignal": true; }; "skipProperties": { "alias": "skipProperties"; "required": false; "isSignal": true; }; "fulltextOnly": { "alias": "fulltextOnly"; "required": false; "isSignal": true; }; "supportDynamicConditions": { "alias": "supportDynamicConditions"; "required": false; "isSignal": true; }; }, { "queryChange": "queryChange"; "querySubmit": "querySubmit"; }, never, never, true, never>;
 }
 
 declare class YuvSmartSearchModule {

package/types/yuuvis-client-framework-tile-list.d.ts

@@ -29,6 +29,11 @@ interface TileListConfigOptions {
     */
     configTypes: VirtualObjectType[];
     configFlavors?: ObjectFlavor[];
+    /**
+     * Property IDs that should not be offered for selection in the property
+     * slots. Added on top of the always-excluded system/base fields.
+     */
+    excludeProperties?: string[];
     actionContext?: ActionContext;
 }
 interface TileListHighlight {