@yuuvis/client-framework 3.18.0 → 3.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuuvis/client-framework",
-  "version": "3.18.0",
+  "version": "3.20.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.18.0",
-    "@yuuvis/client-shell-core": "^3.18.0",
-    "@yuuvis/client-components": "^3.18.0",
+    "@yuuvis/client-core": "^3.20.0",
+    "@yuuvis/client-shell-core": "^3.20.0",
+    "@yuuvis/client-components": "^3.20.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.18.0",
+    "@yuuvis/material": "^3.20.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-object-form.d.ts

@@ -25,6 +25,12 @@ interface ObjectFormOptions {
      */
     data: Record<string, unknown>;
     objectId?: string;
+    /**
+     * ID of the object type (or secondary object type) the form model belongs to. Used to
+     * enrich form elements from the schema in the context of that type — a type may bind a
+     * shared property to its own dynamic catalog. Falls back to the form model's own id.
+     */
+    objectTypeId?: string;
     /**
      * whether or not to disable the complete form
      */

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

@@ -1,7 +1,6 @@
 import * as i0 from '@angular/core';
 import { ComponentRef, Type } from '@angular/core';
 import { AuditEntry, SchemaResponseFieldDefinition, TranslateService, ResolvedObjectConfigItem, RendererType } from '@yuuvis/client-core';
-import * as dist_libs_yuuvis_client_core_types_yuuvis_client_core from 'dist/libs/yuuvis/client-core/types/yuuvis-client-core';
 
 /**
  * Abstract class to be extended by audit-entry renderers. The renderer controls the
@@ -71,9 +70,15 @@ declare abstract class AbstractRendererComponent<T = string, U = null> {
     propertyName: i0.InputSignal<string>;
     value: i0.InputSignal<T | null>;
     meta: i0.InputSignal<U | Record<string, unknown> | undefined>;
+    /**
+     * ID of the object type (or secondary object type) the property is rendered for, when known.
+     * Some schema attributes — most notably the dynamic `catalog` a property is bound to — may be
+     * overridden per type, and can only be resolved with that context.
+     */
+    objectTypeId: i0.InputSignal<string | undefined>;
     protected getProperty(): SchemaResponseFieldDefinition | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractRendererComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractRendererComponent<any, any>, "yuv-abstract-renderer", never, { "propertyName": { "alias": "propertyName"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractRendererComponent<any, any>, "yuv-abstract-renderer", never, { "propertyName": { "alias": "propertyName"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "objectTypeId": { "alias": "objectTypeId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class BooleanRendererComponent extends AbstractRendererComponent {
@@ -82,6 +87,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 +101,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,8 +188,16 @@ 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 RendererDirectiveInput = ResolvedObjectConfigItem;
+type RendererComponent = IntegerRendererComponent | DecimalRendererComponent | DateTimeRendererComponent | IconRendererComponent | StringRendererComponent | BooleanRendererComponent | TableRendererComponent | I18nCatalogRendererComponent | DynamicCatalogRendererComponent;
+/**
+ * Input of the `yuvRenderer` directive. `objectTypeId` is optional type context: a type may bind
+ * a shared property to its own dynamic catalog, and that override can only be resolved when the
+ * type (or secondary object type) the property is rendered for is known. Without it the renderer
+ * falls back to the global property definition.
+ */
+type RendererDirectiveInput = ResolvedObjectConfigItem & {
+    objectTypeId?: string;
+};
 
 /**
  * Service for managing property type renderers. Renderers are components that will render certain
@@ -202,10 +236,10 @@ declare class RendererService {
 declare class RendererDirective {
     #private;
     component: ComponentRef<RendererComponent>;
-    yuvRenderer: i0.InputSignal<dist_libs_yuuvis_client_core_types_yuuvis_client_core.ResolvedObjectConfigItem | undefined>;
+    yuvRenderer: i0.InputSignal<RendererDirectiveInput | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<RendererDirective, never>;
     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[]>;
     /**
@@ -221,7 +247,13 @@ declare class SmartSearchEditController {
      */
     activeFields: _angular_core.Signal<SuggestionItem[]>;
     suggestions: _angular_core.Signal<SuggestionItem[]>;
-    /** Number of top-level query units: the full-text unit (when it has a term) plus each block. */
+    /**
+     * Whether the full-text unit contributes to the query — a term, a type restriction, or both.
+     * Drives its own muted styling and the joiner below it, so what reads as active matches what
+     * is actually queried (see {@link isFulltextActive}).
+     */
+    fulltextActive: _angular_core.Signal<boolean>;
+    /** Number of top-level query units: the full-text unit (when it contributes one) plus each block. */
     unitCount: _angular_core.Signal<number>;
     showCombinator: _angular_core.Signal<boolean>;
     cmisQuery: _angular_core.Signal<string>;
@@ -229,7 +261,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 +286,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 +363,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;
@@ -349,9 +403,30 @@ declare function isConditionUnset(cond: FieldCondition): boolean;
 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.
+ * to a column and AND-ed with a type restriction.
+ *
+ * A type restriction on its own — types picked in the full-text bar's type filter with nothing
+ * typed — is a query in its own right ("show me everything of this type"), exactly like a type
+ * block carrying no conditions. So the picked types are returned alone in that case; only a unit
+ * with neither a term nor a picked type contributes nothing and yields `''`.
+ *
+ * @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.
+ *
+ * The scope deliberately only narrows a *term* search. With nothing typed and no type picked the
+ * panel is simply untouched, and falling back to the scope there would turn it into a standing
+ * "everything in scope" query the moment it opens.
  */
-declare function buildFulltextClause(fulltext: FulltextSearch): string;
+declare function buildFulltextClause(fulltext: FulltextSearch, scopeTypes?: SearchBlockType[]): string;
+/**
+ * Whether the full-text unit contributes a clause to the query — a term, a type restriction, or
+ * both. Lives next to {@link buildFulltextClause} so the UI's notion of "this unit is active"
+ * (its muted styling, the joiner to the blocks below it, the unit count behind the AND/OR toggle)
+ * cannot drift from what actually ends up in the query.
+ */
+declare function isFulltextActive(fulltext: FulltextSearch): boolean;
 /**
  * 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 +436,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 +452,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 +506,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 +522,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 +544,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 +560,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.
@@ -485,6 +603,7 @@ declare class SmartSearchComponent {
     readonly showCombinator: _angular_core.Signal<boolean>;
     readonly suggestions: _angular_core.Signal<SuggestionItem[]>;
     readonly fulltext: _angular_core.WritableSignal<_yuuvis_client_framework_smart_search.FulltextSearch>;
+    readonly fulltextActive: _angular_core.Signal<boolean>;
     readonly objectTypes: _angular_core.Signal<_yuuvis_client_core.GenericObjectType[]>;
     readonly activeBlockFields: _angular_core.Signal<SuggestionItem[]>;
     readonly formMode: _angular_core.WritableSignal<boolean>;
@@ -523,7 +642,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 +706,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(event: Event): void;
+    /**
+     * 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.
      */
-    onTypeEnter(): void;
+    onEnter(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 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.
      */
-    onEnter(): void;
+    onHostEnter(event: KeyboardEvent | Event): void;
     /**
      * Called when the inline-input wrapper loses focus.
      * Commits the condition if complete, discards it if incomplete.
@@ -609,7 +754,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 +788,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 {
@@ -648,5 +797,5 @@ declare class YuvSmartSearchModule {
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<YuvSmartSearchModule>;
 }
 
-export { SmartSearchComponent, YuvSmartSearchModule, buildCmisQuery, buildFulltextClause, buildNodeClause, isConditionGroup, isFieldCondition, isTableCondition };
+export { SmartSearchComponent, YuvSmartSearchModule, buildCmisQuery, buildFulltextClause, buildNodeClause, isConditionGroup, isFieldCondition, isFulltextActive, isTableCondition };
 export type { BuildStep, Combinator, ConditionContainer, ConditionGroup, ConditionNode, FieldCondition, FulltextScope, FulltextSearch, SearchBlock, SearchBlockType, SmartSearchState, SuggestionItem, TableCondition };

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 {