@yuuvis/client-framework 3.7.1 → 3.8.0

package/fesm2022/yuuvis-client-framework-smart-search.mjs

@@ -0,0 +1,1944 @@
+import * as i0 from '@angular/core';
+import { inject, signal, computed, Injectable, input, ChangeDetectionStrategy, Component, ElementRef, output, viewChild, effect, NgModule } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i1$1 from '@angular/forms';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import * as i2$1 from '@angular/material/autocomplete';
+import { MatAutocompleteTrigger, MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatButtonModule } from '@angular/material/button';
+import * as i4 from '@angular/material/chips';
+import { MatChipsModule } from '@angular/material/chips';
+import * as i1 from '@angular/material/icon';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import * as i5 from '@angular/material/select';
+import { MatSelectModule } from '@angular/material/select';
+import * as i2 from '@angular/material/tooltip';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { SystemService, TranslateService, BaseObjectTypeField, TranslatePipe } from '@yuuvis/client-core';
+import { MetadataFormFieldComponent } from '@yuuvis/client-framework/metadata-form';
+import { RendererDirective } from '@yuuvis/client-framework/renderer';
+import { YmtIconButtonDirective } from '@yuuvis/material';
+import { debounceTime } from 'rxjs/operators';
+import { NgTemplateOutlet } from '@angular/common';
+
+function isConditionGroup(node) {
+    return node.kind === 'group';
+}
+function isTableCondition(node) {
+    return node.kind === 'table';
+}
+function isFieldCondition(node) {
+    return !isConditionGroup(node) && !isTableCondition(node);
+}
+
+const DATE_PREFIX_LEN$2 = 5;
+function escapeCmis(value) {
+    return value.replace(/'/g, "''").replace(/\\/g, '\\\\');
+}
+/**
+ * Escape a value for use inside a CMIS `LIKE` pattern. The wildcard characters
+ * `%` and `_` are backslash-escaped so a user-typed `%`/`_` matches literally
+ * instead of acting as a wildcard. The backslash itself is escaped first (so an
+ * existing `\` can't turn the following character into an escape sequence), then
+ * single quotes are doubled as everywhere else.
+ */
+function escapeCmisLike(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/%/g, '\\%')
+        .replace(/_/g, '\\_')
+        .replace(/'/g, "''");
+}
+function isNumericType(internalType) {
+    return internalType === 'integer' || internalType === 'decimal';
+}
+function isBooleanType(internalType) {
+    return internalType === 'boolean' || internalType.startsWith('boolean:');
+}
+function isFiniteNumberLiteral(value) {
+    return value.trim() !== '' && Number.isFinite(Number(value));
+}
+/**
+ * Render a scalar value as a CMIS literal, driven by the field's internal type.
+ * Strings and datetimes are quoted and escaped. Numbers and booleans are emitted
+ * bare — but ONLY when the value really is a finite number / a `true|false`
+ * boolean; any other value for a non-string field is quoted-and-escaped as a
+ * fallback so a malformed or hostile value (e.g. `1 OR 1=1` on an integer field)
+ * can never break out of the literal.
+ */
+function renderScalarLiteral(value, internalType) {
+    if (internalType.startsWith('string') || internalType === 'datetime') {
+        return `'${escapeCmis(value)}'`;
+    }
+    if (isNumericType(internalType) && isFiniteNumberLiteral(value)) {
+        return value;
+    }
+    if (isBooleanType(internalType) && (value === 'true' || value === 'false')) {
+        return value;
+    }
+    // Unknown type, or a value that doesn't match its declared type: never emit it
+    // bare (injection / malformed-SQL guard).
+    return `'${escapeCmis(value)}'`;
+}
+/**
+ * Serialize a single raw form-control value to its CMIS string form.
+ * `Date` → ISO 8601; everything else → trimmed string.
+ */
+function serializeScalar(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value.trim();
+    if (value instanceof Date)
+        return value.toISOString();
+    return String(value);
+}
+/**
+ * Type-aware "the user actually entered something" check. The metadata value
+ * editor emits strings, numbers, dates and arrays depending on the field type,
+ * so a plain truthiness/`.trim()` test is wrong (`0` and `false` are valid).
+ */
+function isValuePresent(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === 'string')
+        return value.trim().length > 0;
+    if (typeof value === 'number')
+        return !Number.isNaN(value);
+    if (typeof value === 'boolean')
+        return true;
+    if (value instanceof Date)
+        return !Number.isNaN(value.getTime());
+    if (Array.isArray(value))
+        return value.some(isValuePresent);
+    return true; // objects (e.g. RangeValue) — present if non-null
+}
+/**
+ * Normalize a raw form-control value into what we store in `FieldCondition.value`.
+ * Arrays are kept as a cleaned `string[]` (drives IN-clauses); everything else
+ * collapses to a single string.
+ */
+function normalizeConditionValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => serializeScalar(entry)).filter((entry) => entry.length > 0);
+    }
+    return serializeScalar(value);
+}
+/* eslint-disable id-length */
+const CMIS_OPERATOR = {
+    eq: '=',
+    neq: '<>',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<='
+};
+/* eslint-enable id-length */
+/**
+ * Operators that carry their own meaning and need no value step: date presets,
+ * the boolean `= true/false` shortcuts, and the null checks (`empty`/`not_empty`).
+ * The build flow commits these immediately instead of advancing to the value editor.
+ */
+function isValuelessOperator(operator) {
+    return (operator.startsWith('date:') ||
+        operator === 'eq_true' ||
+        operator === 'eq_false' ||
+        operator === 'empty' ||
+        operator === 'not_empty');
+}
+/* eslint-disable id-length */
+/**
+ * Calendar-day arithmetic. Using `new Date(y, m, d ± n)` (rather than
+ * adding milliseconds) keeps boundaries aligned to local midnight across
+ * DST transitions where a day is not exactly 24h.
+ *
+ * Week starts on Monday (ISO 8601 / European default).
+ */
+function datePresetToRange(preset) {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth();
+    const date = now.getDate();
+    let from;
+    let to;
+    switch (preset) {
+        case 'today':
+            from = new Date(year, month, date);
+            to = new Date(year, month, date + 1);
+            break;
+        case 'thisWeek': {
+            // getDay(): 0=Sun, 1=Mon … 6=Sat. Shift so Mon=0 … Sun=6.
+            const dayFromMonday = (now.getDay() + 6) % 7;
+            from = new Date(year, month, date - dayFromMonday);
+            to = new Date(year, month, date - dayFromMonday + 7);
+            break;
+        }
+        case 'thisMonth':
+            from = new Date(year, month, 1);
+            to = new Date(year, month + 1, 1);
+            break;
+        case 'thisYear':
+        default:
+            from = new Date(year, 0, 1);
+            to = new Date(year + 1, 0, 1);
+            break;
+    }
+    return { from: from.toISOString(), to: to.toISOString() };
+}
+/* eslint-enable id-length */
+/**
+ * Render a single {@link FieldCondition} as a CMIS predicate. Handles the null
+ * checks (`IS NULL` / `IS NOT NULL`), multi-value `IN` / `NOT IN`, `LIKE`
+ * (with wildcard-escaped, `%`-wrapped pattern), date-preset ranges
+ * (`>= from AND < to`), and the comparison operators (`=`, `<>`, `>`, …).
+ */
+function buildConditionClause(cond) {
+    const operator = cond.operator;
+    // Valueless null checks short-circuit before any value handling.
+    if (operator === 'empty')
+        return `${cond.fieldId} IS NULL`;
+    if (operator === 'not_empty')
+        return `${cond.fieldId} IS NOT NULL`;
+    // Multi-value (e.g. multi-select catalog): `eq` → IN (...), `neq` → NOT IN (...).
+    if (Array.isArray(cond.value)) {
+        const list = cond.value.map((entry) => renderScalarLiteral(entry, cond.internalType)).join(', ');
+        const inOperator = operator === 'neq' ? 'NOT IN' : 'IN';
+        return `${cond.fieldId} ${inOperator} (${list})`;
+    }
+    const value = serializeScalar(cond.value);
+    if (operator === 'like') {
+        return `${cond.fieldId} LIKE '%${escapeCmisLike(value)}%'`;
+    }
+    if (operator.startsWith('date:')) {
+        // eslint-disable-next-line id-length
+        const { from, to } = datePresetToRange(operator.slice(DATE_PREFIX_LEN$2));
+        return `${cond.fieldId} >= '${from}' AND ${cond.fieldId} < '${to}'`;
+    }
+    const cmisOp = CMIS_OPERATOR[operator] ?? '=';
+    return `${cond.fieldId} ${cmisOp} ${renderScalarLiteral(value, cond.internalType)}`;
+}
+/**
+ * Render a queryable-table condition as `tableField[*].(col op val AND/OR …)`.
+ * `[*]` matches any row; the parenthesized column predicates join with the
+ * table's combinator. Empty tables contribute nothing.
+ *
+ * Column predicates reuse {@link buildConditionClause}: a column condition's
+ * `fieldId` is the bare column id (no table prefix), which is exactly what
+ * belongs inside the parentheses.
+ */
+function buildTableClause(table) {
+    const cols = table.conditions.map(buildNodeClause).filter((part) => part !== '');
+    if (cols.length === 0)
+        return '';
+    return `${table.fieldId}[*].(${cols.join(` ${table.combinator} `)})`;
+}
+/**
+ * Recursively render a condition node. Groups produce parenthesized
+ * sub-expressions; empty groups contribute nothing; single-child groups
+ * collapse their redundant parens. Table conditions delegate to
+ * {@link buildTableClause}.
+ */
+function buildNodeClause(node) {
+    if (isTableCondition(node)) {
+        return buildTableClause(node);
+    }
+    if (isConditionGroup(node)) {
+        const parts = node.conditions.map(buildNodeClause).filter((part) => part !== '');
+        if (parts.length === 0)
+            return '';
+        if (parts.length === 1)
+            return parts[0];
+        return `(${parts.join(` ${node.combinator} `)})`;
+    }
+    return buildConditionClause(node);
+}
+/**
+ * Build the type-matching clause for a block. Primary object types collapse to
+ * `objectTypeId = 'x'` (single) or `objectTypeId IN (...)` (multiple); secondary
+ * object types use `system:secondaryObjectTypeIds IN (...)`. A block mixing both
+ * flavors OR-combines the two clauses inside parentheses.
+ */
+function buildTypeClause(types) {
+    const quote = (id) => `'${escapeCmis(id)}'`;
+    const primaries = types.filter((type) => !type.isSot).map((type) => type.id);
+    const sots = types.filter((type) => type.isSot).map((type) => type.id);
+    const parts = [];
+    if (primaries.length > 0) {
+        parts.push(primaries.length === 1
+            ? `objectTypeId = ${quote(primaries[0])}`
+            : `objectTypeId IN (${primaries.map(quote).join(', ')})`);
+    }
+    if (sots.length > 0) {
+        parts.push(`system:secondaryObjectTypeIds IN (${sots.map(quote).join(', ')})`);
+    }
+    if (parts.length === 0)
+        return '';
+    return parts.length === 1 ? parts[0] : `(${parts.join(' OR ')})`;
+}
+/**
+ * The column qualifier that scopes a full-text CONTAINS. `all` searches metadata + content (no
+ * qualifier); `content` / `metadata` restrict to that virtual full-text column.
+ */
+const FULLTEXT_SCOPE_COLUMN = {
+    all: '',
+    content: 'system:content',
+    metadata: 'system:metadata'
+};
+/**
+ * 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.
+ */
+function buildFulltextClause(fulltext) {
+    const term = fulltext.term.trim();
+    if (!term)
+        return '';
+    const column = FULLTEXT_SCOPE_COLUMN[fulltext.scope];
+    const contains = column ? `${column} CONTAINS('${escapeCmis(term)}')` : `CONTAINS('${escapeCmis(term)}')`;
+    const typeCond = buildTypeClause(fulltext.types);
+    return typeCond ? `(${typeCond} AND ${contains})` : contains;
+}
+/**
+ * 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
+ * conditions) — is parenthesized and joined by `combinator`. Returns `''` when
+ * nothing contributes a clause, so an empty search yields no query.
+ *
+ * @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.
+ * @returns A `SELECT * FROM system:object WHERE …` statement, or `''`.
+ */
+function buildCmisQuery(blocks, combinator, fulltext) {
+    const units = [];
+    const fulltextClause = fulltext ? buildFulltextClause(fulltext) : '';
+    if (fulltextClause !== '')
+        units.push(fulltextClause);
+    for (const block of blocks) {
+        const condJoin = ` ${block.conditionCombinator} `;
+        const typeCond = buildTypeClause(block.types);
+        const condParts = [];
+        for (const node of block.conditions) {
+            const clause = buildNodeClause(node);
+            if (clause !== '')
+                condParts.push(clause);
+        }
+        // Conditions combine with the user-chosen combinator; the type restriction
+        // is always AND-ed with them so a block matches the chosen type(s) *and*
+        // satisfies the condition expression.
+        const condsClause = condParts.length === 0 ? '' : condParts.length === 1 ? condParts[0] : `(${condParts.join(condJoin)})`;
+        const blockParts = [];
+        if (typeCond !== '')
+            blockParts.push(typeCond);
+        if (condsClause !== '')
+            blockParts.push(condsClause);
+        if (blockParts.length === 0)
+            continue;
+        units.push(blockParts.length === 1 ? blockParts[0] : `(${blockParts.join(' AND ')})`);
+    }
+    if (units.length === 0)
+        return '';
+    const joined = units.length === 1 ? units[0] : units.join(` ${combinator} `);
+    return `SELECT * FROM system:object WHERE ${joined}`;
+}
+
+/**
+ * Walk the block tree and return a new `blocks` array where `target` has been
+ * replaced by `updater(target)`. Identity is by reference equality.
+ *
+ * Returns the original array reference if the target is not found, so callers
+ * can detect a no-op via reference equality.
+ */
+/**
+ * Rebuild a container with a new `conditions` array while preserving its
+ * discriminated kind (`SearchBlock` / `ConditionGroup` / `TableCondition`).
+ *
+ * The cast is sound: every caller only ever produces conditions that are valid
+ * for the container's kind (e.g. a table only receives row-groups). TypeScript
+ * cannot verify that across a union spread — `{ ...target, conditions }` widens
+ * a `TableCondition`'s `conditions` from `ConditionGroup[]` to `ConditionNode[]`
+ * and so fails to narrow back to the input type.
+ */
+function withConditions(container, conditions) {
+    return { ...container, conditions };
+}
+function updateContainer(blocks, target, updater) {
+    let changed = false;
+    const walk = (node) => {
+        if (node === target) {
+            changed = true;
+            return updater(node);
+        }
+        if (isConditionGroup(node) || isTableCondition(node)) {
+            const next = node.conditions.map(walk);
+            if (next.some((child, idx) => child !== node.conditions[idx])) {
+                return withConditions(node, next);
+            }
+        }
+        return node;
+    };
+    const nextBlocks = blocks.map((block) => {
+        if (block === target) {
+            changed = true;
+            return updater(block);
+        }
+        const nextConditions = block.conditions.map(walk);
+        if (nextConditions.some((child, idx) => child !== block.conditions[idx])) {
+            return { ...block, conditions: nextConditions };
+        }
+        return block;
+    });
+    return changed ? nextBlocks : blocks;
+}
+/**
+ * Remove `target` from its parent container. If the parent is a
+ * `ConditionGroup` and becomes empty as a result, the parent is also removed
+ * (recursively up the chain). Top-level `SearchBlock`s are never auto-pruned.
+ *
+ * Returns the original array reference if the target is not found.
+ */
+function removeNode(blocks, target) {
+    let changed = false;
+    // A group or table that loses its last child is pruned, cascading up the chain.
+    const pruneContainer = (container) => {
+        const kids = container.conditions;
+        const next = kids.map(walk).filter((node) => node !== null);
+        if (next.length === 0)
+            return null;
+        if (next.length === kids.length && next.every((child, idx) => child === kids[idx])) {
+            return container;
+        }
+        return withConditions(container, next);
+    };
+    const walk = (node) => {
+        if (node === target) {
+            changed = true;
+            return null;
+        }
+        if (isConditionGroup(node) || isTableCondition(node)) {
+            return pruneContainer(node);
+        }
+        return node;
+    };
+    const nextBlocks = blocks
+        .map((block) => {
+        if (block === target) {
+            changed = true;
+            return null;
+        }
+        const nextConditions = block.conditions.map(walk).filter((node) => node !== null);
+        if (nextConditions.length === block.conditions.length &&
+            nextConditions.every((child, idx) => child === block.conditions[idx])) {
+            return block;
+        }
+        return { ...block, conditions: nextConditions };
+    })
+        .filter((block) => block !== null);
+    return changed ? nextBlocks : blocks;
+}
+/**
+ * Find the top-level `SearchBlock` that contains `container` (directly or
+ * transitively). Returns `container` itself when it already is a `SearchBlock`.
+ * Returns `null` if not found in the tree.
+ */
+function findOwningBlock(blocks, container) {
+    // A SearchBlock is its own owner; only groups and tables need a tree walk.
+    if (!isConditionGroup(container) && !isTableCondition(container)) {
+        return blocks.includes(container) ? container : null;
+    }
+    const contains = (node, needle) => {
+        if (node === needle)
+            return true;
+        if (isConditionGroup(node) || isTableCondition(node)) {
+            return node.conditions.some((child) => contains(child, needle));
+        }
+        return false;
+    };
+    for (const block of blocks) {
+        if (block.conditions.some((child) => contains(child, container)))
+            return block;
+    }
+    return null;
+}
+
+const DATE_PREFIX_LEN$1 = 5;
+/* eslint-disable id-length */
+const OPERATOR_LABEL_KEYS = {
+    like: 'yuv.smart-search.operator.like',
+    empty: 'yuv.smart-search.operator.empty',
+    not_empty: 'yuv.smart-search.operator.not-empty'
+};
+const OPERATOR_SYMBOLS = {
+    eq: '=',
+    neq: '≠',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<='
+};
+/* eslint-enable id-length */
+const DATE_PRESETS = [
+    { id: 'today', labelKey: 'yuv.smart-search.date-preset.today' },
+    { id: 'thisWeek', labelKey: 'yuv.smart-search.date-preset.this-week' },
+    { id: 'thisMonth', labelKey: 'yuv.smart-search.date-preset.this-month' },
+    { id: 'thisYear', labelKey: 'yuv.smart-search.date-preset.this-year' }
+];
+/**
+ * State + mutators for SmartSearch, shared between the host component and the
+ * recursive `SmartSearchGroupComponent`. Provided at the host component level
+ * so each `<yuv-smart-search>` instance gets its own controller.
+ *
+ * UI concerns (focus management, autocomplete plumbing, blur suppression) stay
+ * in the host component; this controller is purely about data.
+ */
+class SmartSearchEditController {
+    constructor() {
+        this.#system = inject(SystemService);
+        this.#translate = inject(TranslateService);
+        /** The set of object type IDs that can be used as search blocks. */
+        this.allowedTypes = signal([], ...(ngDevMode ? [{ debugName: "allowedTypes" }] : /* istanbul ignore next */ []));
+        /** ObjectTypeField IDs to exclude from the field-step autocomplete suggestions. */
+        this.skipProperties = signal([], ...(ngDevMode ? [{ debugName: "skipProperties" }] : /* istanbul ignore next */ []));
+        // ── Persistent form controls (one per step) ──────────────────────────────
+        this.fieldCtrl = new FormControl('');
+        this.operatorCtrl = new FormControl('');
+        // Untyped value: the metadata renderer for the picked field may write a
+        // string, number, Date or string[] (see normalizeConditionValue).
+        this.valueCtrl = new FormControl('');
+        // ── State signals ─────────────────────────────────────────────────────────
+        /** Current input step */
+        this.step = signal('type', ...(ngDevMode ? [{ debugName: "step" }] : /* istanbul ignore next */ []));
+        /** The owning top-level block (drives field suggestions for the active edit) */
+        this.activeBlock = signal(null, ...(ngDevMode ? [{ debugName: "activeBlock" }] : /* istanbul ignore next */ []));
+        /** The immediate parent container the new condition will land in */
+        this.activeContainer = signal(null, ...(ngDevMode ? [{ debugName: "activeContainer" }] : /* istanbul ignore next */ []));
+        /** Field selected waiting for operator/value */
+        this.pendingField = signal(null, ...(ngDevMode ? [{ debugName: "pendingField" }] : /* istanbul ignore next */ []));
+        /** Operator label for the pending operator (displayed as a pill) */
+        this.pendingOperatorLabel = signal('', ...(ngDevMode ? [{ debugName: "pendingOperatorLabel" }] : /* istanbul ignore next */ []));
+        /** The accumulated search blocks */
+        this.blocks = signal([], ...(ngDevMode ? [{ debugName: "blocks" }] : /* istanbul ignore next */ []));
+        /** Types staged in the multi-select before the block is committed (type step). */
+        this.draftTypes = signal([], ...(ngDevMode ? [{ debugName: "draftTypes" }] : /* istanbul ignore next */ []));
+        /** Index of the condition being edited (-1 = new condition) */
+        this.editingConditionIndex = signal(-1, ...(ngDevMode ? [{ debugName: "editingConditionIndex" }] : /* istanbul ignore next */ []));
+        /** Snapshot of the condition under edit, used to restore on cancel */
+        this.#editingSnapshot = null;
+        /** Monotonic counter for generating stable block ids. */
+        this.#blockSeq = 0;
+        /**
+         * How to combine the top-level units (full-text unit + type blocks). These are
+         * type-scoped, so they always join with OR ("this as well as that"); the UI no
+         * longer exposes a toggle. Kept as a signal so saved states still round-trip.
+         */
+        this.combinator = signal('OR', ...(ngDevMode ? [{ debugName: "combinator" }] : /* istanbul ignore next */ []));
+        /** The current filter term for autocomplete suggestions */
+        this.inputTerm = signal('', ...(ngDevMode ? [{ debugName: "inputTerm" }] : /* istanbul ignore next */ []));
+        /** The whole-object full-text search unit (independent of the condition blocks). */
+        this.fulltext = signal({ term: '', scope: 'all', types: [] }, ...(ngDevMode ? [{ debugName: "fulltext" }] : /* istanbul ignore next */ []));
+        this.objectTypes = computed(() => this.#system.getObjectTypes(true, 'search').filter((type) => this.allowedTypes().includes(type.id)), ...(ngDevMode ? [{ debugName: "objectTypes" }] : /* istanbul ignore next */ []));
+        /** Fields for the active top-level block, used by the field-step suggestions. */
+        this.activeBlockFields = computed(() => this.#sharedFields(this.activeBlock()?.types ?? []), ...(ngDevMode ? [{ debugName: "activeBlockFields" }] : /* istanbul ignore next */ []));
+        /**
+         * When the active edit is scoped inside a table, the resolved column definitions
+         * of that table (as full `ObjectTypeField`s with `_internalType`). `null` when
+         * not editing inside a table.
+         */
+        this.activeTableColumns = computed(() => {
+            const container = this.activeContainer();
+            return container && isTableCondition(container) ? this.#tableColumns(container) : null;
+        }, ...(ngDevMode ? [{ debugName: "activeTableColumns" }] : /* istanbul ignore next */ []));
+        /**
+         * The fields offered at the field step: a table's **columns** when editing
+         * inside a table, otherwise the active block's shared fields.
+         */
+        this.activeFields = computed(() => {
+            const columns = this.activeTableColumns();
+            if (columns)
+                return this.#columnSuggestions(columns);
+            return this.activeBlockFields();
+        }, ...(ngDevMode ? [{ debugName: "activeFields" }] : /* istanbul ignore next */ []));
+        this.suggestions = computed(() => {
+            const step = this.step();
+            const term = this.inputTerm().toLowerCase();
+            if (step === 'type') {
+                // Only hide types already staged in the *current* draft block. Types used by
+                // other blocks stay available — a new block may target the same type again.
+                const stagedIds = new Set(this.draftTypes().map((type) => type.id));
+                const all = this.objectTypes()
+                    .filter((type) => !stagedIds.has(type.id))
+                    .map((type) => ({ kind: 'type', id: type.id, label: type.label ?? type.id }))
+                    .sort((a, b) => a.label.localeCompare(b.label));
+                return term ? all.filter((item) => item.label.toLowerCase().includes(term)) : all;
+            }
+            if (step === 'field') {
+                const all = [...this.activeFields()].sort((a, b) => a.label.localeCompare(b.label));
+                return term
+                    ? all.filter((item) => item.label.toLowerCase().includes(term) || item.id.toLowerCase().includes(term))
+                    : all;
+            }
+            if (step === 'operator') {
+                const field = this.pendingField();
+                if (!field)
+                    return [];
+                const all = this.#operatorsForInternalType(field.internalType ?? 'string');
+                return term ? all.filter((item) => item.label.toLowerCase().includes(term)) : all;
+            }
+            return [];
+        }, ...(ngDevMode ? [{ debugName: "suggestions" }] : /* istanbul ignore next */ []));
+        /** Number of top-level query units: the full-text unit (when it has a term) plus each block. */
+        this.unitCount = computed(() => (this.fulltext().term.trim() ? 1 : 0) + this.blocks().length, ...(ngDevMode ? [{ debugName: "unitCount" }] : /* istanbul ignore next */ []));
+        this.showCombinator = computed(() => this.unitCount() >= 2, ...(ngDevMode ? [{ debugName: "showCombinator" }] : /* istanbul ignore next */ []));
+        this.cmisQuery = computed(() => buildCmisQuery(this.blocks(), this.combinator(), this.fulltext()), ...(ngDevMode ? [{ debugName: "cmisQuery" }] : /* istanbul ignore next */ []));
+        /** The active input control for the current step. */
+        this.activeCtrl = computed(() => {
+            switch (this.step()) {
+                case 'field':
+                    return this.fieldCtrl;
+                case 'operator':
+                    return this.operatorCtrl;
+                case 'value':
+                    return this.valueCtrl;
+                default:
+                    return this.fieldCtrl;
+            }
+        }, ...(ngDevMode ? [{ debugName: "activeCtrl" }] : /* istanbul ignore next */ []));
+    }
+    #system;
+    #translate;
+    /** Snapshot of the condition under edit, used to restore on cancel */
+    #editingSnapshot;
+    /** Monotonic counter for generating stable block ids. */
+    #blockSeq;
+    // ── State save / restore ──────────────────────────────────────────────────
+    /** Deep-clone the current blocks, combinator and full-text unit into a serializable {@link SmartSearchState}. */
+    getState() {
+        return {
+            blocks: JSON.parse(JSON.stringify(this.blocks())),
+            combinator: this.combinator(),
+            fulltext: JSON.parse(JSON.stringify(this.fulltext()))
+        };
+    }
+    /** Replace the current state with a saved one, normalizing legacy blocks and cancelling any in-progress edit. */
+    loadState(state) {
+        this.cancelPending();
+        this.blocks.set(state.blocks.map((block) => this.#normalizeBlock(block)));
+        this.combinator.set(state.combinator);
+        this.fulltext.set(state.fulltext ?? { term: '', scope: 'all', types: [] });
+    }
+    /** Reset all search state back to its initial empty values. */
+    reset() {
+        this.cancelPending();
+        this.blocks.set([]);
+        this.combinator.set('OR');
+        this.fulltext.set({ term: '', scope: 'all', types: [] });
+    }
+    // ── Full-text unit ────────────────────────────────────────────────────────
+    /** Set the full-text search term. */
+    setFulltextTerm(term) {
+        this.fulltext.update((current) => ({ ...current, term }));
+    }
+    /** Set the full-text search scope (`all` / `metadata` / `content`). */
+    setFulltextScope(scope) {
+        this.fulltext.update((current) => ({ ...current, scope }));
+    }
+    /** Add a target type to the full-text unit (no-op if already present). */
+    addFulltextType(type, label) {
+        this.fulltext.update((current) => current.types.some((picked) => picked.id === type.id)
+            ? current
+            : { ...current, types: [...current.types, { id: type.id, label, isSot: type.isSot }] });
+    }
+    /** Remove a target type from the full-text unit by id. */
+    removeFulltextType(id) {
+        this.fulltext.update((current) => ({ ...current, types: current.types.filter((type) => type.id !== id) }));
+    }
+    /** Replace the full-text target types from a list of object-type ids (unknown ids are dropped). */
+    setFulltextTypes(ids) {
+        const types = ids
+            .map((id) => this.objectTypes().find((objectType) => objectType.id === id))
+            .filter((objectType) => !!objectType)
+            .map((objectType) => ({ id: objectType.id, label: objectType.label ?? objectType.id, isSot: objectType.isSot }));
+        this.fulltext.update((current) => ({ ...current, types }));
+    }
+    // ── Type draft (multi-select) ─────────────────────────────────────────────
+    /** Stage a type in the draft multi-select (no-op if already staged). */
+    addDraftType(type, label) {
+        if (this.draftTypes().some((draft) => draft.id === type.id))
+            return;
+        this.draftTypes.update((draft) => [...draft, { id: type.id, label, isSot: type.isSot }]);
+    }
+    /** Remove a staged type from the draft multi-select. */
+    removeDraftType(id) {
+        this.draftTypes.update((draft) => draft.filter((type) => type.id !== id));
+    }
+    /**
+     * Commit the staged draft types into a new block and clear the draft.
+     * Returns the created block, or `null` when the draft is empty.
+     */
+    confirmDraftTypes() {
+        const types = this.draftTypes();
+        if (types.length === 0)
+            return null;
+        const newBlock = {
+            id: this.#nextId(),
+            types: [...types],
+            conditions: [],
+            conditionCombinator: 'AND'
+        };
+        this.blocks.update((blocks) => [...blocks, newBlock]);
+        this.draftTypes.set([]);
+        return newBlock;
+    }
+    // ── Block + group + condition mutators ───────────────────────────────────
+    /** Remove a whole block; cancels the in-progress edit if it belonged to that block. */
+    removeBlock(block) {
+        this.blocks.update((blocks) => blocks.filter((blk) => blk !== block));
+        if (this.activeBlock() === block) {
+            this.cancelPending();
+        }
+    }
+    /** Append an empty `ConditionGroup` to a container and start adding inside it. */
+    addGroup(parent) {
+        const newGroup = { kind: 'group', conditions: [], combinator: 'AND' };
+        this.blocks.update((blocks) => updateContainer(blocks, parent, (container) => withConditions(container, [...container.conditions, newGroup])));
+        // The new group's reference is stable across the update because we appended
+        // its literal — safe to use directly as the active container.
+        this.startAddCondition(newGroup);
+        return newGroup;
+    }
+    /**
+     * Remove a group from its parent container. If the parent group becomes
+     * empty, it is also removed (cascading up). Top-level blocks are preserved.
+     */
+    removeGroup(group) {
+        this.blocks.update((blocks) => removeNode(blocks, group));
+        if (this.activeContainer() === group) {
+            this.cancelPending();
+        }
+    }
+    /** Remove a condition from the tree; empty parent groups/tables are pruned by the cascade. */
+    removeCondition(_container, condition) {
+        // While an *existing* condition is being edited it is temporarily pulled out
+        // of the tree (see editCondition). Removing the last remaining sibling would
+        // empty — and thus prune — the shared container, losing the in-flight edit.
+        // Re-home the snapshot first so it survives, then end the edit cleanly.
+        if (this.editingConditionIndex() >= 0 && this.#editingSnapshot) {
+            this.restoreEditingSnapshot();
+            this.cancelPending();
+        }
+        this.blocks.update((blocks) => removeNode(blocks, condition));
+        // If the active container itself was pruned by the cascade, drop the edit.
+        const active = this.activeContainer();
+        if (active && !this.#containerExists(active)) {
+            this.cancelPending();
+        }
+    }
+    /** Set the top-level combinator joining the query units (full-text unit + blocks). */
+    setCombinator(value) {
+        this.combinator.set(value);
+    }
+    /** Set the AND/OR combinator of a single container (block, group or table). */
+    setContainerCombinator(container, value) {
+        this.blocks.update((blocks) => updateContainer(blocks, container, (target) => isConditionGroup(target) || isTableCondition(target)
+            ? { ...target, combinator: value }
+            : { ...target, conditionCombinator: value }));
+    }
+    /**
+     * The picked field resolves to a queryable `table` type. A table has no operator
+     * of its own; instead it holds column conditions directly. Insert an empty
+     * {@link TableCondition} and scope the edit into it so the user picks a column next.
+     */
+    addTableCondition(field) {
+        const container = this.activeContainer();
+        if (!container)
+            return;
+        const table = {
+            kind: 'table',
+            fieldId: field.id,
+            fieldLabel: field.label,
+            conditions: [],
+            // Columns are row-scoped and always join with OR ("a row that has colA as
+            // well as colB"); the UI shows a static "as well as" label, not a toggle.
+            combinator: 'OR'
+        };
+        this.blocks.update((blocks) => updateContainer(blocks, container, (target) => withConditions(target, [...target.conditions, table])));
+        // `table`'s reference is stable across the update (we appended its literal).
+        this.startAddCondition(table);
+    }
+    // ── Inline-edit flow ──────────────────────────────────────────────────────
+    /** Begin adding a condition inside `container`. */
+    startAddCondition(container) {
+        const owningBlock = findOwningBlock(this.blocks(), container);
+        if (!owningBlock)
+            return;
+        this.activeBlock.set(owningBlock);
+        this.activeContainer.set(container);
+        this.pendingField.set(null);
+        this.pendingOperatorLabel.set('');
+        this.editingConditionIndex.set(-1);
+        this.#editingSnapshot = null;
+        this.fieldCtrl.setValue('', { emitEvent: false });
+        this.operatorCtrl.setValue('', { emitEvent: false });
+        this.valueCtrl.setValue('', { emitEvent: false });
+        this.step.set('field');
+    }
+    /** Begin editing an existing condition inside `container`. */
+    editCondition(container, condition, index) {
+        this.#editingSnapshot = { ...condition };
+        // Remove the condition from the tree so the inline editor takes its slot,
+        // and capture the new container reference produced by the immutable update.
+        let refreshed = container;
+        this.blocks.update((blocks) => updateContainer(blocks, container, (target) => {
+            const next = withConditions(target, target.conditions.filter((node) => node !== condition));
+            refreshed = next;
+            return next;
+        }));
+        const owningBlock = findOwningBlock(this.blocks(), refreshed);
+        if (!owningBlock)
+            return;
+        this.activeBlock.set(owningBlock);
+        this.activeContainer.set(refreshed);
+        this.editingConditionIndex.set(index);
+        const fieldItem = {
+            kind: 'field',
+            id: condition.fieldId,
+            label: condition.fieldLabel,
+            internalType: condition.internalType,
+            operator: condition.operator
+        };
+        this.pendingField.set(fieldItem);
+        this.pendingOperatorLabel.set(this.operatorLabel(condition.operator));
+        this.fieldCtrl.setValue(condition.fieldLabel, { emitEvent: false });
+        this.operatorCtrl.setValue(this.operatorLabel(condition.operator), { emitEvent: false });
+        this.step.set(isValuelessOperator(condition.operator) ? 'operator' : 'value');
+    }
+    /** Jump back to the field step and clear the input so the user can re-type. */
+    editField() {
+        this.fieldCtrl.setValue('', { emitEvent: false });
+        this.step.set('field');
+        this.inputTerm.set('');
+    }
+    /** Jump back to the operator step and clear the input so the user can re-type. */
+    editOperator() {
+        this.operatorCtrl.setValue('', { emitEvent: false });
+        this.step.set('operator');
+        this.inputTerm.set('');
+    }
+    /** Abandon the in-progress edit, restoring state and pruning any empty container created for it. */
+    cancelPending() {
+        // Prune empty containers created via addGroup / addTableCondition and never
+        // committed into. removeNode cascades up, so an empty parent is removed too.
+        const container = this.activeContainer();
+        if (container &&
+            (isConditionGroup(container) || isTableCondition(container)) &&
+            container.conditions.length === 0) {
+            this.blocks.update((blocks) => removeNode(blocks, container));
+        }
+        this.activeBlock.set(null);
+        this.activeContainer.set(null);
+        this.pendingField.set(null);
+        this.pendingOperatorLabel.set('');
+        this.editingConditionIndex.set(-1);
+        this.#editingSnapshot = null;
+        this.draftTypes.set([]);
+        this.step.set('type');
+        this.fieldCtrl.setValue('', { emitEvent: false });
+        this.operatorCtrl.setValue('', { emitEvent: false });
+        this.valueCtrl.setValue('', { emitEvent: false });
+        this.inputTerm.set('');
+    }
+    /** Insert (or, when editing, re-insert at its original index) the finished condition into the active container. */
+    commitCondition(condition) {
+        const container = this.activeContainer();
+        if (!container)
+            return;
+        const idx = this.editingConditionIndex();
+        this.blocks.update((blocks) => updateContainer(blocks, container, (target) => {
+            const conditions = [...target.conditions];
+            if (idx >= 0 && idx <= conditions.length) {
+                conditions.splice(idx, 0, condition);
+            }
+            else {
+                conditions.push(condition);
+            }
+            return withConditions(target, conditions);
+        }));
+        this.activeBlock.set(null);
+        this.activeContainer.set(null);
+        this.pendingField.set(null);
+        this.pendingOperatorLabel.set('');
+        this.editingConditionIndex.set(-1);
+        this.#editingSnapshot = null;
+        this.step.set('type');
+        this.fieldCtrl.setValue('', { emitEvent: false });
+        this.operatorCtrl.setValue('', { emitEvent: false });
+        this.valueCtrl.setValue('', { emitEvent: false });
+        this.inputTerm.set('');
+    }
+    /**
+     * On blur with an incomplete edit of an existing condition, reinsert the
+     * original verbatim at its original index.
+     */
+    restoreEditingSnapshot() {
+        const idx = this.editingConditionIndex();
+        const container = this.activeContainer();
+        const snapshot = this.#editingSnapshot;
+        if (idx < 0 || !container || !snapshot)
+            return;
+        this.blocks.update((blocks) => updateContainer(blocks, container, (target) => {
+            const conditions = [...target.conditions];
+            conditions.splice(idx, 0, snapshot);
+            return withConditions(target, conditions);
+        }));
+    }
+    /** Whether the in-progress condition has all parts needed to be committed. */
+    isConditionComplete() {
+        const field = this.pendingField();
+        if (!field)
+            return false;
+        const operator = field.operator ?? '';
+        if (!operator)
+            return false;
+        if (isValuelessOperator(operator))
+            return true;
+        return isValuePresent(this.valueCtrl.value);
+    }
+    /** The operators available for a field's internal type, as autocomplete items. */
+    operatorsForField(field) {
+        return this.#operatorsForInternalType(field.internalType ?? 'string');
+    }
+    /** Human-readable label for an operator id: a math symbol (`=`, `≠`, …), a translated key, or the id itself. */
+    operatorLabel(operator) {
+        const symbol = OPERATOR_SYMBOLS[operator];
+        if (symbol)
+            return symbol;
+        const key = OPERATOR_LABEL_KEYS[operator];
+        return key ? this.#translate.instant(key) : operator;
+    }
+    /** Build a condition record from a date preset / boolean operator / value. */
+    buildCommitCondition(field, operatorId, operatorLabelText, value, internalTypeOverride) {
+        if (operatorId.startsWith('date:')) {
+            return {
+                fieldId: field.id,
+                internalType: internalTypeOverride ?? field.internalType ?? 'datetime',
+                fieldLabel: field.label,
+                operator: operatorId,
+                operatorLabel: operatorLabelText,
+                value: operatorId.slice(DATE_PREFIX_LEN$1),
+                conditionLabel: `${field.label} ${operatorLabelText}`
+            };
+        }
+        if (operatorId === 'empty' || operatorId === 'not_empty') {
+            return {
+                fieldId: field.id,
+                internalType: internalTypeOverride ?? field.internalType ?? 'string',
+                fieldLabel: field.label,
+                operator: operatorId,
+                operatorLabel: operatorLabelText,
+                value: '',
+                conditionLabel: `${field.label} ${operatorLabelText}`
+            };
+        }
+        if (operatorId === 'eq_true' || operatorId === 'eq_false') {
+            const val = operatorId === 'eq_true' ? 'true' : 'false';
+            return {
+                fieldId: field.id,
+                internalType: internalTypeOverride ?? field.internalType ?? 'boolean',
+                fieldLabel: field.label,
+                operator: 'eq',
+                operatorLabel: '=',
+                value: val,
+                conditionLabel: `${field.label} = ${val}`
+            };
+        }
+        const valueLabel = Array.isArray(value) ? value.join(', ') : value;
+        return {
+            fieldId: field.id,
+            internalType: internalTypeOverride ?? field.internalType ?? 'string',
+            fieldLabel: field.label,
+            operator: operatorId,
+            operatorLabel: operatorLabelText,
+            value,
+            conditionLabel: `${field.label} ${operatorLabelText} ${valueLabel}`
+        };
+    }
+    /**
+     * Resolve a field definition by id across the given block types, falling back to
+     * the universal base fields. Used by the host to render the value editor for a
+     * picked field (including inherited base fields not present on any type).
+     */
+    resolveFieldDefinition(types, fieldId) {
+        // When editing inside a table row, the field is one of the table's columns.
+        const column = this.activeTableColumns()?.find((col) => col.id === fieldId);
+        if (column)
+            return column;
+        return this.#resolveTypeField(types, fieldId);
+    }
+    /** Resolve a field by id from the block types, falling back to base/system fields. */
+    #resolveTypeField(types, fieldId) {
+        for (const type of types) {
+            const objectType = this.objectTypes().find((candidate) => candidate.id === type.id);
+            const field = objectType?.fields.find((typeField) => typeField.id === fieldId);
+            if (field)
+                return this.#withInternalType(field);
+        }
+        const baseField = this.#baseFields().find((field) => field.id === fieldId);
+        return baseField ? this.#withInternalType(baseField) : null;
+    }
+    /**
+     * Re-derive `_internalType` from the field's full classification — including its
+     * `catalog` reference. The schema-baked `_internalType` omits `catalog`, so a
+     * dynamic catalog would otherwise be misrendered as a static (empty) catalog.
+     * Mirrors how object-form / renderer.service resolve the element type.
+     */
+    #withInternalType(field) {
+        return {
+            ...field,
+            _internalType: this.#system.getInternalFormElementType(field.propertyType, field.classifications, field.catalog)
+        };
+    }
+    // ── Internals ─────────────────────────────────────────────────────────────
+    #nextId() {
+        this.#blockSeq += 1;
+        return `blk-${this.#blockSeq}`;
+    }
+    /**
+     * Keep the id sequence ahead of any id already in the tree (e.g. ids carried in
+     * by a loaded state). Without this, `#blockSeq` stays at 0 after `loadState` and
+     * the next generated id (`blk-1`) collides with a restored `blk-1`, breaking the
+     * `@for` track-by on block id.
+     */
+    #trackSeq(id) {
+        const match = /^blk-(\d+)$/.exec(id);
+        if (match)
+            this.#blockSeq = Math.max(this.#blockSeq, Number(match[1]));
+    }
+    /**
+     * Normalize a block coming from a loaded state. Ensures an `id`, and migrates
+     * legacy single-type blocks (`typeId`/`typeLabel`/`isSot`) into the `types[]`
+     * shape so older saved states remain loadable.
+     */
+    #normalizeBlock(block) {
+        const legacy = block;
+        const types = Array.isArray(legacy.types)
+            ? legacy.types
+            : [{ id: legacy.typeId ?? '', label: legacy.typeLabel ?? legacy.typeId ?? '', isSot: legacy.isSot }];
+        const id = legacy.id ?? this.#nextId();
+        this.#trackSeq(id);
+        return {
+            id,
+            types,
+            conditions: legacy.conditions ?? [],
+            conditionCombinator: legacy.conditionCombinator ?? 'AND'
+        };
+    }
+    /**
+     * Fields shared by *all* given types (the intersection by field id), shaped as
+     * field suggestions. A field must be `queryable`, not in `skipProperties`, and
+     * present on every type. Field metadata (label, internalType) is taken from the
+     * first type that declares it.
+     *
+     * Each type's own fields are unioned with the universal base/system fields so
+     * inherited properties (e.g. `system:creationDate`) become selectable too.
+     */
+    #sharedFields(types) {
+        if (types.length === 0)
+            return [];
+        const objectTypes = types
+            .map((type) => this.objectTypes().find((objectType) => objectType.id === type.id))
+            .filter((objectType) => !!objectType);
+        if (objectTypes.length !== types.length)
+            return [];
+        const skip = new Set(this.skipProperties());
+        const [first, ...rest] = objectTypes;
+        const restFieldIds = rest.map((objectType) => new Set(this.#resolveFields(objectType).map((field) => field.id)));
+        return this.#resolveFields(first)
+            .filter((field) => field.queryable !== false && !skip.has(field.id))
+            .filter((field) => restFieldIds.every((ids) => ids.has(field.id)))
+            .map((field) => ({
+            kind: 'field',
+            id: field.id,
+            label: this.#system.getLocalizedLabel(field.id) || field.label || field.name || field.id,
+            internalType: this.#system.getInternalFormElementType(field.propertyType, field.classifications, field.catalog)
+        }));
+    }
+    /**
+     * The universal base/system fields (`system:creationDate`, `system:createdBy`, …)
+     * resolved from the global property definitions. These are inherited by every
+     * object type but are not part of any concrete type's resolved `fields`.
+     */
+    #baseFields() {
+        return Object.values(BaseObjectTypeField)
+            .map((id) => this.#system.getObjectTypeField(id))
+            .filter((field) => !!field);
+    }
+    /** A type's own fields unioned with the base fields, de-duplicated by id (own wins). */
+    #resolveFields(objectType) {
+        return this.#dedupeById([...objectType.fields, ...this.#baseFields()]);
+    }
+    #dedupeById(fields) {
+        const seen = new Set();
+        return fields.filter((field) => (seen.has(field.id) ? false : seen.add(field.id) && true));
+    }
+    // ── Table columns ──────────────────────────────────────────────────────────
+    /** Resolve a table field's `columnDefinitions` into full `ObjectTypeField`s. */
+    #tableColumns(table) {
+        const block = this.activeBlock();
+        if (!block)
+            return [];
+        const tableField = this.#resolveTypeField(block.types, table.fieldId);
+        return (tableField?.columnDefinitions ?? []).map((col) => this.#columnToField(col));
+    }
+    /**
+     * Map a table column definition to an `ObjectTypeField` with a re-derived
+     * `_internalType` (so the value editor renders the right widget). Column defs may
+     * carry `classification` (schema) or `classifications` (base shape) — accept both.
+     */
+    #columnToField(col) {
+        const classifications = col.classifications ?? col.classification;
+        return {
+            ...col,
+            name: col.name ?? col.id,
+            label: this.#system.getLocalizedLabel(col.id) || col.id,
+            classifications,
+            _internalType: this.#system.getInternalFormElementType(col.propertyType, classifications, col.catalog)
+        };
+    }
+    /** Shape resolved table columns as field-step suggestions. */
+    #columnSuggestions(columns) {
+        const skip = new Set(this.skipProperties());
+        return columns
+            .filter((col) => col.queryable !== false && !skip.has(col.id))
+            .map((col) => ({
+            kind: 'field',
+            id: col.id,
+            label: this.#system.getLocalizedLabel(col.id) || col.label || col.name || col.id,
+            internalType: col._internalType
+        }));
+    }
+    /** Check whether a container (block, group or table) still exists in the current tree by reference. */
+    #containerExists(container) {
+        if (!isConditionGroup(container) && !isTableCondition(container)) {
+            return this.blocks().includes(container);
+        }
+        return this.#containsRef(this.blocks().flatMap((block) => block.conditions), container);
+    }
+    #containsRef(nodes, needle) {
+        for (const node of nodes) {
+            if (node === needle)
+                return true;
+            if ((isConditionGroup(node) || isTableCondition(node)) && this.#containsRef(node.conditions, needle))
+                return true;
+        }
+        return false;
+    }
+    #operatorsForInternalType(internalType) {
+        const base = (ids) => ids.map((id) => ({ kind: 'operator', id, label: this.operatorLabel(id) }));
+        // Null checks are offered on every queryable type.
+        const empty = () => base(['empty', 'not_empty']);
+        switch (internalType) {
+            case 'integer':
+            case 'decimal':
+                return [...base(['eq', 'neq', 'gt', 'gte', 'lt', 'lte']), ...empty()];
+            case 'datetime':
+                return [
+                    ...base(['eq', 'neq', 'gt', 'gte', 'lt', 'lte']),
+                    ...DATE_PRESETS.map((preset) => ({
+                        kind: 'date-preset',
+                        id: `date:${preset.id}`,
+                        label: this.#translate.instant(preset.labelKey)
+                    })),
+                    ...empty()
+                ];
+            case 'boolean':
+            case 'boolean:switch':
+                return [
+                    { kind: 'operator', id: 'eq_true', label: this.#translate.instant('yuv.smart-search.operator.eq-true') },
+                    { kind: 'operator', id: 'eq_false', label: this.#translate.instant('yuv.smart-search.operator.eq-false') },
+                    ...empty()
+                ];
+            case 'string:catalog':
+            case 'string:catalog:i18n':
+            case 'string:catalog:dynamic':
+            case 'string:organization':
+            case 'string:organization:set':
+            case 'string:reference':
+                return [...base(['eq', 'neq']), ...empty()];
+            case 'table':
+                return [];
+            default:
+                return [...base(['like', 'eq', 'neq']), ...empty()];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchEditController, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchEditController }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchEditController, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Renders a single `ConditionContainer` (block body, nested group, or table).
+ *
+ * - When `bare=true`, the panel wrapper (combinator header + remove button) is
+ *   omitted; used by the host for the top-level `SearchBlock` body where the
+ *   block already has its own type header.
+ * - When `bare=false` (default), renders the full nested-group panel with a
+ *   group-scoped combinator toggle and an X to remove the group.
+ * - A `TableCondition` renders as a labelled panel whose children are column
+ *   conditions; like a block/group it offers "Add condition", but no "Add group".
+ *
+ * Chip and inline-editor markup is supplied by the host as `TemplateRef`s so
+ * Material plumbing (FormControls, autocomplete) stays in one place.
+ *
+ * This is an internal building block of {@link SmartSearchComponent} and is
+ * rendered recursively for nested groups and tables — it is not meant to be used
+ * standalone. The host shares its {@link SmartSearchEditController} instance with it.
+ *
+ * @example
+ * ```html
+ * <yuv-smart-search-group
+ *   [group]="block"
+ *   [bare]="true"
+ *   [chipTpl]="chipTpl"
+ *   [editorTpl]="editorTpl"
+ * />
+ * ```
+ */
+class SmartSearchGroupComponent {
+    constructor() {
+        /** The container to render: a top-level block body, a nested group, or a table condition. */
+        this.group = input.required(...(ngDevMode ? [{ debugName: "group" }] : /* istanbul ignore next */ []));
+        /**
+         * When `true`, omit the panel wrapper (combinator header + remove button) and
+         * render only the children. Used for the top-level block body, which already
+         * carries its own type header. Defaults to `false` (full nested-group panel).
+         */
+        this.bare = input(false, ...(ngDevMode ? [{ debugName: "bare" }] : /* istanbul ignore next */ []));
+        /** Host-supplied template for a committed condition chip. */
+        this.chipTpl = input.required(...(ngDevMode ? [{ debugName: "chipTpl" }] : /* istanbul ignore next */ []));
+        /** Host-supplied template for the inline condition editor. */
+        this.editorTpl = input.required(...(ngDevMode ? [{ debugName: "editorTpl" }] : /* istanbul ignore next */ []));
+        this.ctrl = inject(SmartSearchEditController);
+        this.isGroup = isConditionGroup;
+        this.isTable = isTableCondition;
+        /** True when this container is a `TableCondition` (its children are column conditions). */
+        this.isTableContainer = computed(() => isTableCondition(this.group()), ...(ngDevMode ? [{ debugName: "isTableContainer" }] : /* istanbul ignore next */ []));
+        /** Label shown in the table panel header. */
+        this.tableLabel = computed(() => {
+            const container = this.group();
+            return isTableCondition(container) ? container.fieldLabel : '';
+        }, ...(ngDevMode ? [{ debugName: "tableLabel" }] : /* istanbul ignore next */ []));
+        /** Combinator value irrespective of whether this is a block, group or table. */
+        this.containerCombinator = computed(() => {
+            const container = this.group();
+            if (isConditionGroup(container) || isTableCondition(container))
+                return container.combinator;
+            return container.conditionCombinator;
+        }, ...(ngDevMode ? [{ debugName: "containerCombinator" }] : /* istanbul ignore next */ []));
+        this.isActive = computed(() => this.ctrl.activeContainer() === this.group(), ...(ngDevMode ? [{ debugName: "isActive" }] : /* istanbul ignore next */ []));
+    }
+    /** Set this container's AND/OR combinator. */
+    setCombinator(value) {
+        this.ctrl.setContainerCombinator(this.group(), value);
+    }
+    /** Remove this container when it is a nested group (no-op for blocks and tables). */
+    removeGroup() {
+        const container = this.group();
+        if (isConditionGroup(container)) {
+            this.ctrl.removeGroup(container);
+        }
+    }
+    /** Begin adding a condition inside this container. */
+    startAddCondition() {
+        this.ctrl.startAddCondition(this.group());
+    }
+    /** Add a nested condition group inside this container. */
+    addGroup() {
+        this.ctrl.addGroup(this.group());
+    }
+    /** Narrow a child node to a {@link ConditionGroup} for the template (guarded by `isGroup`). */
+    asGroup(node) {
+        return node;
+    }
+    /** Narrow a child node to a {@link TableCondition} for the template (guarded by `isTable`). */
+    asTable(node) {
+        return node;
+    }
+    /** Narrow a child node to a {@link FieldCondition} for the template (the remaining case). */
+    asCondition(node) {
+        return node;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.12", type: SmartSearchGroupComponent, isStandalone: true, selector: "yuv-smart-search-group", inputs: { group: { classPropertyName: "group", publicName: "group", isSignal: true, isRequired: true, transformFunction: null }, bare: { classPropertyName: "bare", publicName: "bare", isSignal: true, isRequired: false, transformFunction: null }, chipTpl: { classPropertyName: "chipTpl", publicName: "chipTpl", isSignal: true, isRequired: true, transformFunction: null }, editorTpl: { classPropertyName: "editorTpl", publicName: "editorTpl", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: "@if (bare()) {\n  <ng-container *ngTemplateOutlet=\"body\" />\n} @else {\n  <div class=\"group\" [class.group--active]=\"isActive()\" [class.group--table]=\"isTableContainer()\">\n    @if (isTableContainer()) {\n      <div class=\"group__header\">\n        <span class=\"group__table-label\">{{ tableLabel() }}</span>\n        <!-- Pseudo-operator: a table reads like a normal condition \u2014 \"Agent has \u2026\".\n             It is the only operator a table offers, so it is applied implicitly. -->\n        <span class=\"group__table-op\">{{ 'yuv.smart-search.operator.has' | translate }}</span>\n      </div>\n    }\n    <div class=\"group__body\">\n      <ng-container *ngTemplateOutlet=\"body\" />\n    </div>\n  </div>\n}\n\n<ng-template #body>\n  @for (node of group().conditions; track node; let i = $index) {\n    @if (isTable(node)) {\n      <yuv-smart-search-group [group]=\"asTable(node)\" [chipTpl]=\"chipTpl()\" [editorTpl]=\"editorTpl()\" />\n    } @else if (isGroup(node)) {\n      <yuv-smart-search-group [group]=\"asGroup(node)\" [chipTpl]=\"chipTpl()\" [editorTpl]=\"editorTpl()\" />\n    } @else {\n      <ng-container\n        *ngTemplateOutlet=\"chipTpl(); context: { $implicit: asCondition(node), container: group(), index: i }\"\n      />\n    }\n    @if (!$last) {\n      <div class=\"condition-combinator\">\n        <!-- Table columns are row-scoped and always combine with OR (\"a row that\n             has this as well as that\"), so they show a static label instead of a\n             toggle. Groups and blocks keep their AND/OR toggle. -->\n        @if (isTableContainer()) {\n          <span class=\"combinator__label\">{{ 'yuv.smart-search.combinator.as-well-as' | translate }}</span>\n        } @else {\n          <button\n            class=\"combinator__btn\"\n            [class.combinator__btn--active]=\"containerCombinator() === 'AND'\"\n            (click)=\"setCombinator('AND')\"\n          >\n            {{ 'yuv.smart-search.combinator.and' | translate }}\n          </button>\n          <button\n            class=\"combinator__btn\"\n            [class.combinator__btn--active]=\"containerCombinator() === 'OR'\"\n            (click)=\"setCombinator('OR')\"\n          >\n            {{ 'yuv.smart-search.combinator.or' | translate }}\n          </button>\n        }\n      </div>\n    }\n  }\n\n  @if (isActive()) {\n    <ng-container *ngTemplateOutlet=\"editorTpl(); context: { $implicit: group() }\" />\n  } @else {\n    <div class=\"add-btns\">\n      <button\n        ymtIconButton\n        icon-button-size=\"small\"\n        class=\"add-condition-btn\"\n        [matTooltip]=\"'yuv.smart-search.add-condition' | translate\"\n        (click)=\"startAddCondition()\"\n      >\n        <mat-icon>add</mat-icon>\n      </button>\n      <!-- Tables hold column conditions directly \u2014 no grouping inside them. -->\n      @if (!isTableContainer()) {\n        <button\n          ymtIconButton\n          icon-button-size=\"small\"\n          class=\"add-condition-btn\"\n          [matTooltip]=\"'yuv.smart-search.add-group' | translate\"\n          (click)=\"addGroup()\"\n        >\n          <mat-icon>data_array</mat-icon>\n        </button>\n      }\n    </div>\n  }\n</ng-template>\n", styles: [":host{display:contents}.group{display:flex;flex-direction:column;gap:var(--ymt-spacing-3xs);padding:var(--ymt-spacing-2xs);margin:var(--ymt-spacing-2xs) 0;border-radius:var(--ymt-corner-xs);background:rgb(from var(--ymt-outline) r g b/.06);border:1px dashed var(--ymt-outline)}.group--active{border-color:var(--ymt-primary)}.group--table{border-style:solid}.group__header{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.group__table-label{font-weight:600;font-size:.85em;opacity:.85}.group__table-op{font:var(--ymt-font-body-subtle);color:var(--ymt-text-color-subtle)}.group__remove{margin-left:auto;opacity:.6}.group__remove:hover{opacity:1}.group__body{display:flex;flex-wrap:wrap;align-items:center;row-gap:var(--ymt-spacing-3xs);column-gap:var(--ymt-spacing-s)}.add-btns{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.add-condition-btn{color:var(--ymt-text-color-subtle)}.combinator{display:flex;justify-content:center;gap:0}.combinator__label{font:var(--ymt-font-body-subtle);text-transform:lowercase;color:var(--ymt-text-color-subtle);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs)}.combinator__btn{--bg: transparent;--fg: var(--ymt-text-color);--mdc-shape-small: var(--ymt-corner-xs);font-size:.82em;background-color:var(--bg);color:var(--fg);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs);border:0;outline:1px solid var(--ymt-inverse-surface);outline-offset:-1px}.combinator__btn:first-child{border-radius:var(--mdc-shape-small) 0 0 var(--mdc-shape-small)}.combinator__btn:last-child{border-radius:0 var(--mdc-shape-small) var(--mdc-shape-small) 0}.combinator__btn--active{--bg: var(--ymt-inverse-surface);--fg: var(--ymt-on-inverse-surface)}\n"], dependencies: [{ kind: "component", type: SmartSearchGroupComponent, selector: "yuv-smart-search-group", inputs: ["group", "bare", "chipTpl", "editorTpl"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "directive", type: YmtIconButtonDirective, selector: "button[ymtIconButton],button[ymt-icon-button],a[ymtIconButton],a[ymt-icon-button]", inputs: ["disabled", "disableRipple", "aria-disabled", "disabledInteractive", "icon-button-size"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-smart-search-group', imports: [
+                        NgTemplateOutlet,
+                        MatButtonModule,
+                        YmtIconButtonDirective,
+                        MatIconModule,
+                        MatTooltipModule,
+                        YmtIconButtonDirective,
+                        TranslatePipe
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "@if (bare()) {\n  <ng-container *ngTemplateOutlet=\"body\" />\n} @else {\n  <div class=\"group\" [class.group--active]=\"isActive()\" [class.group--table]=\"isTableContainer()\">\n    @if (isTableContainer()) {\n      <div class=\"group__header\">\n        <span class=\"group__table-label\">{{ tableLabel() }}</span>\n        <!-- Pseudo-operator: a table reads like a normal condition \u2014 \"Agent has \u2026\".\n             It is the only operator a table offers, so it is applied implicitly. -->\n        <span class=\"group__table-op\">{{ 'yuv.smart-search.operator.has' | translate }}</span>\n      </div>\n    }\n    <div class=\"group__body\">\n      <ng-container *ngTemplateOutlet=\"body\" />\n    </div>\n  </div>\n}\n\n<ng-template #body>\n  @for (node of group().conditions; track node; let i = $index) {\n    @if (isTable(node)) {\n      <yuv-smart-search-group [group]=\"asTable(node)\" [chipTpl]=\"chipTpl()\" [editorTpl]=\"editorTpl()\" />\n    } @else if (isGroup(node)) {\n      <yuv-smart-search-group [group]=\"asGroup(node)\" [chipTpl]=\"chipTpl()\" [editorTpl]=\"editorTpl()\" />\n    } @else {\n      <ng-container\n        *ngTemplateOutlet=\"chipTpl(); context: { $implicit: asCondition(node), container: group(), index: i }\"\n      />\n    }\n    @if (!$last) {\n      <div class=\"condition-combinator\">\n        <!-- Table columns are row-scoped and always combine with OR (\"a row that\n             has this as well as that\"), so they show a static label instead of a\n             toggle. Groups and blocks keep their AND/OR toggle. -->\n        @if (isTableContainer()) {\n          <span class=\"combinator__label\">{{ 'yuv.smart-search.combinator.as-well-as' | translate }}</span>\n        } @else {\n          <button\n            class=\"combinator__btn\"\n            [class.combinator__btn--active]=\"containerCombinator() === 'AND'\"\n            (click)=\"setCombinator('AND')\"\n          >\n            {{ 'yuv.smart-search.combinator.and' | translate }}\n          </button>\n          <button\n            class=\"combinator__btn\"\n            [class.combinator__btn--active]=\"containerCombinator() === 'OR'\"\n            (click)=\"setCombinator('OR')\"\n          >\n            {{ 'yuv.smart-search.combinator.or' | translate }}\n          </button>\n        }\n      </div>\n    }\n  }\n\n  @if (isActive()) {\n    <ng-container *ngTemplateOutlet=\"editorTpl(); context: { $implicit: group() }\" />\n  } @else {\n    <div class=\"add-btns\">\n      <button\n        ymtIconButton\n        icon-button-size=\"small\"\n        class=\"add-condition-btn\"\n        [matTooltip]=\"'yuv.smart-search.add-condition' | translate\"\n        (click)=\"startAddCondition()\"\n      >\n        <mat-icon>add</mat-icon>\n      </button>\n      <!-- Tables hold column conditions directly \u2014 no grouping inside them. -->\n      @if (!isTableContainer()) {\n        <button\n          ymtIconButton\n          icon-button-size=\"small\"\n          class=\"add-condition-btn\"\n          [matTooltip]=\"'yuv.smart-search.add-group' | translate\"\n          (click)=\"addGroup()\"\n        >\n          <mat-icon>data_array</mat-icon>\n        </button>\n      }\n    </div>\n  }\n</ng-template>\n", styles: [":host{display:contents}.group{display:flex;flex-direction:column;gap:var(--ymt-spacing-3xs);padding:var(--ymt-spacing-2xs);margin:var(--ymt-spacing-2xs) 0;border-radius:var(--ymt-corner-xs);background:rgb(from var(--ymt-outline) r g b/.06);border:1px dashed var(--ymt-outline)}.group--active{border-color:var(--ymt-primary)}.group--table{border-style:solid}.group__header{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.group__table-label{font-weight:600;font-size:.85em;opacity:.85}.group__table-op{font:var(--ymt-font-body-subtle);color:var(--ymt-text-color-subtle)}.group__remove{margin-left:auto;opacity:.6}.group__remove:hover{opacity:1}.group__body{display:flex;flex-wrap:wrap;align-items:center;row-gap:var(--ymt-spacing-3xs);column-gap:var(--ymt-spacing-s)}.add-btns{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.add-condition-btn{color:var(--ymt-text-color-subtle)}.combinator{display:flex;justify-content:center;gap:0}.combinator__label{font:var(--ymt-font-body-subtle);text-transform:lowercase;color:var(--ymt-text-color-subtle);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs)}.combinator__btn{--bg: transparent;--fg: var(--ymt-text-color);--mdc-shape-small: var(--ymt-corner-xs);font-size:.82em;background-color:var(--bg);color:var(--fg);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs);border:0;outline:1px solid var(--ymt-inverse-surface);outline-offset:-1px}.combinator__btn:first-child{border-radius:var(--mdc-shape-small) 0 0 var(--mdc-shape-small)}.combinator__btn:last-child{border-radius:0 var(--mdc-shape-small) var(--mdc-shape-small) 0}.combinator__btn--active{--bg: var(--ymt-inverse-surface);--fg: var(--ymt-on-inverse-surface)}\n"] }]
+        }], propDecorators: { group: [{ type: i0.Input, args: [{ isSignal: true, alias: "group", required: true }] }], bare: [{ type: i0.Input, args: [{ isSignal: true, alias: "bare", required: false }] }], chipTpl: [{ type: i0.Input, args: [{ isSignal: true, alias: "chipTpl", required: true }] }], editorTpl: [{ type: i0.Input, args: [{ isSignal: true, alias: "editorTpl", required: true }] }] } });
+
+const DEBOUNCE_MS = 150;
+const DATE_PREFIX_LEN = 5;
+/**
+ * Visual query builder that turns guided, chip-based user input into a CMIS query.
+ *
+ * The user composes a search in two independent parts:
+ * - a **full-text bar** (`CONTAINS`) with a scope (all / metadata / content) and an
+ *   optional object-type restriction, and
+ * - one or more **type blocks**, each targeting one or more object types and holding
+ *   field conditions, nested groups and table-column conditions.
+ *
+ * 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}.
+ *
+ * State and mutators live in {@link SmartSearchEditController} (provided per instance);
+ * this component owns only the UI concerns (focus, autocomplete plumbing, blur handling).
+ *
+ * @example
+ * ```html
+ * <!-- Restrict the picker to two object types and skip a noisy property -->
+ * <yuv-smart-search
+ *   [types]="['document', 'invoice']"
+ *   [skipProperties]="['system:traceId']"
+ *   (queryChange)="onQuery($event)"
+ * />
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Save and restore the builder state (e.g. a stored search)
+ * const search = viewChild.required(SmartSearchComponent);
+ *
+ * onQuery(cmisQuery: string) {
+ *   // empty string means "no query" — treat it as a cleared search
+ *   this.results.set(cmisQuery ? this.backend.search(cmisQuery) : []);
+ * }
+ *
+ * persist() {
+ *   localStorage.setItem('search', JSON.stringify(this.search().getState()));
+ * }
+ *
+ * restore() {
+ *   const state = localStorage.getItem('search');
+ *   if (state) this.search().loadState(JSON.parse(state));
+ * }
+ * ```
+ */
+class SmartSearchComponent {
+    #host;
+    /** Previous activeContainer value — used to detect transitions for focus management. */
+    #prevActiveContainer;
+    constructor() {
+        this.#host = inject((ElementRef));
+        this.ctrl = inject(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.
+         */
+        this.types = input([], ...(ngDevMode ? [{ debugName: "types" }] : /* istanbul ignore next */ []));
+        /**
+         * Field ids to hide from the field-step autocomplete (e.g. internal/system
+         * properties that should not be user-queryable). Applies to block fields and
+         * table columns alike.
+         */
+        this.skipProperties = input([], ...(ngDevMode ? [{ debugName: "skipProperties" }] : /* istanbul ignore next */ []));
+        /**
+         * Emits the current CMIS query string whenever the search changes. An empty
+         * string is emitted for an empty search (including the initial seed), so
+         * consumers should treat `''` as "no query" rather than expecting only
+         * non-empty values.
+         */
+        this.queryChange = output();
+        this.auto = viewChild.required('auto');
+        /** Trigger of the currently-focused autocomplete input — used to re-open the
+         * panel after a type pick so the multi-select stays open. */
+        this.trigger = viewChild(MatAutocompleteTrigger, ...(ngDevMode ? [{ debugName: "trigger" }] : /* istanbul ignore next */ []));
+        /** Term control for the full-text bar (independent of the build-step controls). */
+        this.fulltextTermCtrl = new FormControl('');
+        /** Sentinel option value representing "no type restriction" in the type multi-select. */
+        this.ALL_TYPES = '__all__';
+        /**
+         * Guard that prevents `onInlineBlur` from cancelling the pending condition
+         * when we programmatically open the inline editor.
+         */
+        this._suppressNextBlur = false;
+        /** Prevents the valueChanges subscriber from overwriting inputTerm during programmatic setValue */
+        this._suppressInputTerm = false;
+        /**
+         * Set when a type is staged via the autocomplete so the ENTER that triggered the
+         * selection does not also fall through to `confirmTypes()`. Cleared on the next
+         * tick. Needed because the chip-input directive changes the keydown listener order,
+         * so `onTypeEnter` can run *after* the autocomplete has already closed its panel.
+         */
+        this._suppressTypeConfirm = false;
+        /**
+         * Set while an autocomplete option is being applied so the panel's `closed`
+         * event (which Material emits synchronously right after `optionSelected`) is not
+         * mistaken for the user abandoning an empty property picker. Consumed
+         * synchronously in `onPickerClosed`.
+         */
+        this._pickerJustSelected = false;
+        /** Previous activeContainer value — used to detect transitions for focus management. */
+        this.#prevActiveContainer = null;
+        // ── Public API (proxies onto the controller) ─────────────────────────────
+        this.blocks = this.ctrl.blocks;
+        this.draftTypes = this.ctrl.draftTypes;
+        this.combinator = this.ctrl.combinator;
+        this.step = this.ctrl.step;
+        this.activeBlock = this.ctrl.activeBlock;
+        this.activeContainer = this.ctrl.activeContainer;
+        this.pendingField = this.ctrl.pendingField;
+        this.pendingOperatorLabel = this.ctrl.pendingOperatorLabel;
+        this.editingConditionIndex = this.ctrl.editingConditionIndex;
+        this.inputTerm = this.ctrl.inputTerm;
+        this.cmisQuery = this.ctrl.cmisQuery;
+        this.showCombinator = this.ctrl.showCombinator;
+        this.suggestions = this.ctrl.suggestions;
+        this.fulltext = this.ctrl.fulltext;
+        this.objectTypes = this.ctrl.objectTypes;
+        this.activeBlockFields = this.ctrl.activeBlockFields;
+        /**
+         * Selected ids for the type multi-select. Falls back to the `ALL_TYPES`
+         * sentinel when no concrete type is picked (empty selection = no restriction).
+         */
+        this.fulltextTypeSelection = computed(() => {
+            const ids = this.fulltext().types.map((type) => type.id);
+            return ids.length ? ids : [this.ALL_TYPES];
+        }, ...(ngDevMode ? [{ debugName: "fulltextTypeSelection" }] : /* istanbul ignore next */ []));
+        this.fieldCtrl = this.ctrl.fieldCtrl;
+        this.operatorCtrl = this.ctrl.operatorCtrl;
+        this.valueCtrl = this.ctrl.valueCtrl;
+        /**
+         * Field definition driving the value-step editor. Memoized so the `[field]`
+         * reference stays stable across change-detection cycles — re-resolving on every
+         * CD (via a template method call) would re-create the editor and reset widgets
+         * like the catalog select before their options render.
+         */
+        this.valueFieldDef = computed(() => this.getObjectTypeField(this.ctrl.pendingField()), ...(ngDevMode ? [{ debugName: "valueFieldDef" }] : /* istanbul ignore next */ []));
+        /**
+         * `displayWith` for the shared autocomplete. Suggestions are objects but the
+         * input text is driven by the form controls, so a picked option must not write
+         * a label back into the field — return the raw string, or empty otherwise.
+         */
+        this.displayFn = (item) => {
+            if (typeof item === 'string')
+                return item;
+            return '';
+        };
+        // Mirror the `types` input into the controller signal so it can compute
+        // available object types and filter the type suggestions.
+        effect(() => {
+            this.ctrl.allowedTypes.set(this.types());
+        });
+        effect(() => {
+            this.ctrl.skipProperties.set(this.skipProperties());
+        });
+        // Drive inputTerm from whichever control is active for the current step
+        this.ctrl.fieldCtrl.valueChanges.pipe(debounceTime(DEBOUNCE_MS), takeUntilDestroyed()).subscribe((val) => {
+            const step = this.ctrl.step();
+            if (step === 'field' || step === 'type') {
+                this.ctrl.inputTerm.set(typeof val === 'string' ? val : '');
+            }
+        });
+        this.ctrl.operatorCtrl.valueChanges.pipe(debounceTime(DEBOUNCE_MS), takeUntilDestroyed()).subscribe((val) => {
+            if (this.ctrl.step() === 'operator')
+                this.ctrl.inputTerm.set(typeof val === 'string' ? val : '');
+        });
+        this.ctrl.valueCtrl.valueChanges.pipe(debounceTime(DEBOUNCE_MS), takeUntilDestroyed()).subscribe((val) => {
+            if (this._suppressInputTerm)
+                return;
+            if (this.ctrl.step() === 'value')
+                this.ctrl.inputTerm.set(typeof val === 'string' ? val : '');
+        });
+        // Drive the full-text term (independent of the build steps).
+        this.fulltextTermCtrl.valueChanges.pipe(debounceTime(DEBOUNCE_MS), takeUntilDestroyed()).subscribe((val) => {
+            this.ctrl.setFulltextTerm(typeof val === 'string' ? val : '');
+        });
+        // Emits the seed empty query on first run too — consumers should treat
+        // an empty string as "no query" rather than expecting only non-empty values.
+        effect(() => {
+            this.queryChange.emit(this.ctrl.cmisQuery());
+        });
+        // Focus the inline editor whenever a new container becomes active. Covers
+        // "Add condition" / "Add group" clicks coming from any nesting depth —
+        // those go straight through the controller without touching the host.
+        effect(() => {
+            const container = this.ctrl.activeContainer();
+            if (!container) {
+                this.#prevActiveContainer = null;
+                return;
+            }
+            if (container === this.#prevActiveContainer)
+                return;
+            this.#prevActiveContainer = container;
+            this._suppressNextBlur = true;
+            setTimeout(() => {
+                this.#focusInput();
+                this._suppressNextBlur = false;
+            });
+        });
+    }
+    /** Set the AND/OR combinator that joins the conditions within a single container (block, group or table). */
+    setConditionCombinator(container, value) {
+        this.ctrl.setContainerCombinator(container, value);
+    }
+    /**
+     * Capture the current search as a serializable snapshot. Safe for
+     * `JSON.stringify`/`JSON.parse` roundtrips — use it to persist a search and
+     * later restore it with {@link loadState}.
+     */
+    getState() {
+        return this.ctrl.getState();
+    }
+    /** Restore a previously {@link getState saved} search, replacing the current one. */
+    loadState(state) {
+        this.ctrl.loadState(state);
+    }
+    /** Clear the whole search: discard all blocks, conditions and the full-text term. */
+    clear() {
+        this.fulltextTermCtrl.setValue('', { emitEvent: false });
+        this.trigger()?.closePanel();
+        this.ctrl.reset();
+    }
+    /**
+     * Set the top-level combinator joining the query units (the full-text unit and
+     * the type blocks). Kept for state round-tripping; the UI currently always
+     * joins units with `OR`.
+     */
+    setCombinator(value) {
+        this.ctrl.setCombinator(value);
+    }
+    /** Remove an entire type block and all of its conditions. */
+    removeBlock(block) {
+        this.ctrl.removeBlock(block);
+    }
+    /** Commit the staged draft types into a new block and reset the type input. */
+    confirmTypes() {
+        const block = this.ctrl.confirmDraftTypes();
+        if (!block)
+            return;
+        this.trigger()?.closePanel();
+        this.ctrl.fieldCtrl.setValue('', { emitEvent: false });
+        this.ctrl.inputTerm.set('');
+        setTimeout(() => this.#focusAddCondition(block.id));
+    }
+    /** Start adding a new condition inside the given container and focus the inline editor. */
+    startAddCondition(block) {
+        this.ctrl.startAddCondition(block);
+        this._suppressNextBlur = true;
+        setTimeout(() => {
+            this.#focusInput();
+            this._suppressNextBlur = false;
+        });
+    }
+    /** Add a nested condition group inside the given container and focus the inline editor. */
+    addGroup(block) {
+        this.ctrl.addGroup(block);
+        this._suppressNextBlur = true;
+        setTimeout(() => {
+            this.#focusInput();
+            this._suppressNextBlur = false;
+        });
+    }
+    // ── Full-text bar ───────────────────────────────────────────────────────────
+    /** Set where the full-text search looks: `all` (metadata + content), `metadata`, or `content`. */
+    setFulltextScope(scope) {
+        this.ctrl.setFulltextScope(scope);
+    }
+    /**
+     * Reconcile the type multi-select with the "All types" sentinel. Picking
+     * "All types" while concrete types are selected clears the restriction;
+     * picking any concrete type drops the sentinel.
+     */
+    onFulltextTypesChange(ids) {
+        const hadAll = this.fulltext().types.length === 0;
+        // User just clicked "All types" while specific types were selected → clear restriction.
+        if (ids.includes(this.ALL_TYPES) && !hadAll) {
+            this.ctrl.setFulltextTypes([]);
+            return;
+        }
+        // Otherwise keep only the concrete ids (an empty array also means "all").
+        this.ctrl.setFulltextTypes(ids.filter((id) => id !== this.ALL_TYPES));
+    }
+    // ── Inline-editor coordination ─────────────────────────────────────────────
+    /**
+     * Handle a pick from the shared autocomplete panel. Branches on the current
+     * build step: stages a type (keeping the panel open for more), advances a
+     * field to its operator (or opens a table container), or applies a chosen
+     * operator. Single-operator fields and valueless operators commit immediately.
+     */
+    onSuggestionSelected(event) {
+        const item = event.option.value;
+        // The panel closes (and emits `closed`) as a side effect of this selection.
+        // Flag it so `onPickerClosed` doesn't treat that close as an abandoned edit —
+        // matters for the table branch below, which leaves `step` at 'field'.
+        this._pickerJustSelected = true;
+        setTimeout(() => (this._pickerJustSelected = false));
+        switch (this.ctrl.step()) {
+            case 'type': {
+                const objectType = this.ctrl.objectTypes().find((type) => type.id === item.id);
+                if (!objectType)
+                    break;
+                // Stage the type and keep the panel open so more types can be picked.
+                this.ctrl.addDraftType(objectType, item.label);
+                this.ctrl.fieldCtrl.setValue('', { emitEvent: false });
+                this.ctrl.inputTerm.set('');
+                this._suppressNextBlur = true;
+                this._suppressTypeConfirm = true;
+                setTimeout(() => {
+                    this.#focusInput();
+                    this.trigger()?.openPanel();
+                    this._suppressNextBlur = false;
+                    this._suppressTypeConfirm = false;
+                });
+                break;
+            }
+            case 'field': {
+                // A table field has no operator of its own: open a table container with a
+                // first row and scope the edit into that row so the user picks a column next.
+                if ((item.internalType ?? '') === 'table') {
+                    this.ctrl.addTableCondition(item);
+                    this._suppressNextBlur = true;
+                    setTimeout(() => {
+                        this.#focusInput();
+                        this._suppressNextBlur = false;
+                    });
+                    break;
+                }
+                this.ctrl.pendingField.set(item);
+                this.ctrl.fieldCtrl.setValue(item.label, { emitEvent: false });
+                this.ctrl.operatorCtrl.setValue('', { emitEvent: false });
+                // Clear the field-step filter term so the operator suggestions aren't
+                // filtered by the text typed to find the field — otherwise the operator
+                // panel has no matching options and never opens.
+                this.ctrl.inputTerm.set('');
+                // If the field's type allows exactly one operator, skip the operator
+                // picker and apply it immediately.
+                const operators = this.ctrl.operatorsForField(item);
+                if (operators.length === 1) {
+                    this.#applyOperator(item, operators[0]);
+                    break;
+                }
+                this.ctrl.step.set('operator');
+                this._suppressNextBlur = true;
+                setTimeout(() => {
+                    this.#focusInput();
+                    this._suppressNextBlur = false;
+                });
+                break;
+            }
+            case 'operator': {
+                const field = this.ctrl.pendingField();
+                if (!field)
+                    break;
+                this.#applyOperator(field, item);
+                break;
+            }
+        }
+    }
+    /**
+     * Enter in the add-type input. When the input is empty there's no option to
+     * 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.
+     */
+    onTypeEnter() {
+        // The ENTER that selected an autocomplete option must not also confirm the
+        // block — regardless of whether this handler runs before or after the
+        // autocomplete closes its panel.
+        if (this._suppressTypeConfirm)
+            return;
+        const term = this.ctrl.fieldCtrl.value;
+        if (typeof term === 'string' && term.trim())
+            return;
+        if (this.ctrl.draftTypes().length === 0)
+            return;
+        this.confirmTypes();
+    }
+    /**
+     * 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.
+     */
+    onEnter() {
+        if (this.auto().isOpen)
+            return;
+        if (this.ctrl.step() !== 'value')
+            return;
+        const raw = this.ctrl.valueCtrl.value;
+        if (!isValuePresent(raw))
+            return;
+        const field = this.ctrl.pendingField();
+        const fieldOp = field?.operator ?? '';
+        if (!field || !fieldOp)
+            return;
+        this.ctrl.commitCondition(this.ctrl.buildCommitCondition(field, fieldOp, this.ctrl.operatorLabel(fieldOp), normalizeConditionValue(raw)));
+    }
+    /**
+     * Called when the inline-input wrapper loses focus.
+     * Commits the condition if complete, discards it if incomplete.
+     *
+     * Deferred via setTimeout(0): raw value renderers (datepicker dialog,
+     * mat-select panel, mat-autocomplete panel) mount their UI in the
+     * .cdk-overlay-container, which is OUTSIDE the wrapper. Reading
+     * document.activeElement on the next task lets us detect that focus
+     * is still in our logical scope.
+     */
+    onInlineBlur(event) {
+        if (this._suppressNextBlur)
+            return;
+        const wrapper = event.currentTarget;
+        setTimeout(() => {
+            if (this._suppressNextBlur)
+                return;
+            if (!this.ctrl.activeContainer())
+                return;
+            if (this.auto().isOpen)
+                return;
+            const active = document.activeElement;
+            if (active && wrapper.contains(active))
+                return;
+            if (active?.closest('.cdk-overlay-container'))
+                return;
+            // Backdrop dismissal: focus is briefly on <body> while an overlay pane is still mounted.
+            if (document.querySelector('.cdk-overlay-container .cdk-overlay-pane'))
+                return;
+            if (this.ctrl.isConditionComplete()) {
+                this.#commitFromBlur();
+            }
+            else {
+                this.ctrl.restoreEditingSnapshot();
+                this.ctrl.cancelPending();
+            }
+        });
+    }
+    /**
+     * Fired when the shared autocomplete panel closes. Starting a condition opens
+     * the property picker; if the user dismisses it (outside click, Escape) without
+     * choosing a field, there's an empty editor with nothing to commit — drop it.
+     *
+     * Only the field step is handled here: operator/value abandonment is already
+     * covered by `onInlineBlur` (those steps don't auto-open a picker the user can
+     * dismiss while keeping focus). Restores the original when editing an existing
+     * condition, mirroring the blur path.
+     */
+    onPickerClosed() {
+        // `closed` fires synchronously right after `optionSelected`, so consume the
+        // flag here (not in a deferred task) to stay ahead of the focus timers.
+        const justSelected = this._pickerJustSelected;
+        this._pickerJustSelected = false;
+        if (justSelected)
+            return;
+        setTimeout(() => {
+            if (this._suppressNextBlur)
+                return;
+            if (this.auto().isOpen)
+                return;
+            if (this.ctrl.step() !== 'field')
+                return;
+            if (!this.ctrl.activeContainer())
+                return;
+            // A non-empty filter term means the user is still picking a field.
+            const term = this.ctrl.fieldCtrl.value;
+            if (typeof term === 'string' && term.trim())
+                return;
+            this.ctrl.restoreEditingSnapshot();
+            this.ctrl.cancelPending();
+        });
+    }
+    /** Abandon the in-progress condition edit, discarding any partial input. */
+    cancelPending() {
+        this.ctrl.cancelPending();
+    }
+    /** Jump the inline editor back to the field step so the user can re-pick the field. */
+    editField() {
+        this.ctrl.editField();
+        setTimeout(() => this.#focusInput());
+    }
+    /** Jump the inline editor back to the operator step so the user can re-pick the operator. */
+    editOperator() {
+        this.ctrl.editOperator();
+        setTimeout(() => this.#focusInput());
+    }
+    /**
+     * Open an already-committed condition for editing in place. The condition is
+     * pulled out of the tree into the inline editor at its original index, pre-set
+     * to the appropriate step (value, or operator for valueless operators).
+     */
+    editCondition(container, condition, index) {
+        this.ctrl.editCondition(container, condition, index);
+        this._suppressNextBlur = true;
+        if (this.ctrl.step() === 'value') {
+            this._suppressInputTerm = true;
+            setTimeout(() => {
+                this.ctrl.valueCtrl.setValue(condition.value);
+                this._suppressInputTerm = false;
+                this.#focusInput();
+                this._suppressNextBlur = false;
+            });
+        }
+        else {
+            setTimeout(() => {
+                this.#focusInput();
+                this._suppressNextBlur = false;
+            });
+        }
+    }
+    /** Remove a committed condition from its container. */
+    removeCondition(container, condition) {
+        this.ctrl.removeCondition(container, condition);
+    }
+    /**
+     * Renderer input for a committed condition's value, or `null` when the value
+     * should render as plain text. id-based fields (e.g. organization) store an
+     * opaque id as the query value; routing it through the property renderer
+     * resolves it to a human-readable label for the chip. Valueless operators
+     * (empty/not_empty, date presets) and booleans keep their plain text: their
+     * stored value is synthetic/serialized, not the shape those renderers expect.
+     */
+    valueRendererInput(condition) {
+        if (isValuelessOperator(condition.operator))
+            return null;
+        const internalType = condition.internalType ?? '';
+        if (internalType.startsWith('boolean'))
+            return null;
+        if (!isValuePresent(condition.value))
+            return null;
+        return { propertyName: condition.fieldId, rendererType: internalType, value: condition.value };
+    }
+    /**
+     * Resolve the full {@link ObjectTypeField} definition for a suggestion item in
+     * the active block, or `null` when none applies. Drives the value-step metadata
+     * widget so the right editor (datepicker, catalog, …) is rendered.
+     */
+    getObjectTypeField(item) {
+        const block = this.ctrl.activeBlock();
+        if (!item || !block)
+            return null;
+        // The field is shared across all of the block's types — take the definition
+        // from the first type that declares it, falling back to the universal base fields.
+        return this.ctrl.resolveFieldDefinition(block.types, item.id);
+    }
+    // ── Internals ─────────────────────────────────────────────────────────────
+    /**
+     * Apply a chosen operator to the pending field: commit straight away for
+     * date-preset / boolean operators (which carry their own value), otherwise
+     * advance to the value step.
+     */
+    #applyOperator(field, item) {
+        if (item.kind === 'date-preset') {
+            this.ctrl.commitCondition({
+                fieldId: field.id,
+                internalType: field.internalType ?? 'datetime',
+                fieldLabel: field.label,
+                operator: item.id,
+                operatorLabel: item.label,
+                value: item.id.slice(DATE_PREFIX_LEN),
+                conditionLabel: `${field.label} ${item.label}`
+            });
+        }
+        else if (item.id === 'eq_true' || item.id === 'eq_false') {
+            const val = item.id === 'eq_true' ? 'true' : 'false';
+            this.ctrl.commitCondition({
+                fieldId: field.id,
+                internalType: field.internalType ?? 'boolean',
+                fieldLabel: field.label,
+                operator: 'eq',
+                operatorLabel: '=',
+                value: val,
+                conditionLabel: `${field.label} = ${val}`
+            });
+        }
+        else if (item.id === 'empty' || item.id === 'not_empty') {
+            this.ctrl.commitCondition(this.ctrl.buildCommitCondition(field, item.id, item.label, ''));
+        }
+        else {
+            this.ctrl.pendingField.set({ ...field, operator: item.id });
+            this.ctrl.pendingOperatorLabel.set(item.label);
+            this.ctrl.operatorCtrl.setValue(item.label, { emitEvent: false });
+            this.ctrl.inputTerm.set('');
+            this.ctrl.step.set('value');
+            this._suppressNextBlur = true;
+            setTimeout(() => {
+                this.#focusInput();
+                this._suppressNextBlur = false;
+            });
+        }
+    }
+    #commitFromBlur() {
+        const field = this.ctrl.pendingField();
+        if (!field)
+            return;
+        const operator = field.operator ?? '';
+        if (!operator)
+            return;
+        const raw = this.ctrl.valueCtrl.value;
+        this.ctrl.commitCondition(this.ctrl.buildCommitCondition(field, operator, this.ctrl.operatorLabel(operator), normalizeConditionValue(raw)));
+    }
+    #focusInput() {
+        this.#host.nativeElement.querySelector('.inline-input input')?.focus();
+    }
+    /** Focus the "Add condition" (+) button of a block — used after confirming its types. */
+    #focusAddCondition(blockId) {
+        this.#host.nativeElement.querySelector(`.block[data-block-id="${blockId}"] .add-condition-btn`)?.focus();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.12", type: SmartSearchComponent, isStandalone: true, selector: "yuv-smart-search", inputs: { types: { classPropertyName: "types", publicName: "types", isSignal: true, isRequired: false, transformFunction: null }, skipProperties: { classPropertyName: "skipProperties", publicName: "skipProperties", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { queryChange: "queryChange" }, providers: [SmartSearchEditController], viewQueries: [{ propertyName: "auto", first: true, predicate: ["auto"], descendants: true, isSignal: true }, { propertyName: "trigger", first: true, predicate: MatAutocompleteTrigger, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"smart-search\" halo-container halo-container-skip=\"true\">\n  <!-- Condition chip template \u2014 passed down into the recursive group component. -->\n  <ng-template #chipTpl let-condition let-container=\"container\" let-i=\"index\">\n    <div\n      class=\"condition-chip\"\n      tabindex=\"0\"\n      role=\"button\"\n      [attr.aria-label]=\"'yuv.smart-search.condition.edit-aria' | translate: { label: condition.conditionLabel }\"\n      (click)=\"editCondition(container, condition, i)\"\n      (keydown.space)=\"$event.preventDefault(); editCondition(container, condition, i)\"\n      (keydown.enter)=\"$event.preventDefault(); editCondition(container, condition, i)\"\n    >\n      <span class=\"condition-chip__part condition-chip__field\">\n        <!-- <mat-icon>tune</mat-icon> -->\n        {{ condition.fieldLabel }}\n      </span>\n      <span class=\"condition-chip__part condition-chip__op\">{{ condition.operatorLabel }}</span>\n      <span class=\"condition-chip__part condition-chip__value\">\n        @if (valueRendererInput(condition); as rendererInput) {\n          <ng-container *yuvRenderer=\"rendererInput\" />\n        } @else {\n          {{ condition.value }}\n        }\n      </span>\n      <button\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"condition-chip__remove\"\n        tabindex=\"-1\"\n        [attr.aria-label]=\"'yuv.smart-search.condition.remove' | translate\"\n        (click)=\"$event.stopPropagation(); removeCondition(container, condition)\"\n      >\n        <mat-icon>close</mat-icon>\n      </button>\n    </div>\n  </ng-template>\n\n  <!-- Inline editor template \u2014 rendered inside whichever container is active. -->\n  <ng-template #editorTpl>\n    <div class=\"inline-input\" tabindex=\"-1\" (focusout)=\"onInlineBlur($event)\" (keydown.escape)=\"cancelPending()\">\n      @if (ctrl.step() !== 'field' && ctrl.pendingField()) {\n        <button\n          class=\"part-pill\"\n          [class.part-pill--active]=\"ctrl.step() === 'field'\"\n          (click)=\"editField()\"\n          [matTooltip]=\"'yuv.smart-search.field.change' | translate\"\n        >\n          {{ ctrl.pendingField()?.label }}\n        </button>\n      }\n\n      @if (ctrl.step() === 'value' && ctrl.operatorCtrl.value) {\n        <button\n          class=\"part-pill\"\n          [class.part-pill--active]=\"ctrl.step() === 'operator'\"\n          (click)=\"editOperator()\"\n          [matTooltip]=\"'yuv.smart-search.operator.change' | translate\"\n        >\n          {{ ctrl.operatorCtrl.value }}\n        </button>\n      }\n\n      @if (ctrl.step() === 'field') {\n        <input\n          [formControl]=\"ctrl.fieldCtrl\"\n          [matAutocomplete]=\"auto\"\n          [placeholder]=\"'yuv.smart-search.field.pick' | translate\"\n          (keydown.enter)=\"onEnter()\"\n        />\n      } @else if (ctrl.step() === 'operator') {\n        <input\n          [formControl]=\"ctrl.operatorCtrl\"\n          [matAutocomplete]=\"auto\"\n          [placeholder]=\"'yuv.smart-search.operator.select' | translate\"\n          (keydown.enter)=\"onEnter()\"\n        />\n      } @else if (ctrl.step() === 'value') {\n        @let otf = valueFieldDef();\n        @if (otf) {\n          <yuv-metadata-form-field variant=\"raw\" [field]=\"otf\" situation=\"EDIT\" [formControl]=\"ctrl.valueCtrl\" />\n        } @else {\n          <input\n            [formControl]=\"ctrl.valueCtrl\"\n            [matAutocomplete]=\"auto\"\n            [placeholder]=\"'yuv.smart-search.value.enter' | translate\"\n            (keydown.enter)=\"onEnter()\"\n          />\n        }\n      }\n\n      <button\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"confirm-btn\"\n        [disabled]=\"!ctrl.isConditionComplete()\"\n        (click)=\"onEnter()\"\n        [matTooltip]=\"'yuv.smart-search.confirm' | translate\"\n      >\n        <mat-icon>check</mat-icon>\n      </button>\n      <button\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"cancel-btn\"\n        (click)=\"cancelPending()\"\n        [matTooltip]=\"'yuv.smart-search.cancel' | translate\"\n      >\n        <mat-icon>close</mat-icon>\n      </button>\n    </div>\n  </ng-template>\n\n  <!-- \u2500\u2500 Full-text search bar \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  <div class=\"fulltext\" [class.muted]=\"!fulltext().term.trim() && ctrl.blocks().length\">\n    <!-- Row 1: full-width term -->\n    <div class=\"fulltext__term\">\n      <mat-icon class=\"fulltext__icon\">search</mat-icon>\n      <input\n        class=\"fulltext__input\"\n        [formControl]=\"fulltextTermCtrl\"\n        [placeholder]=\"'yuv.smart-search.fulltext.placeholder' | translate\"\n      />\n    </div>\n\n    <!-- Row 2: scope (single) + types (multiple) -->\n    <div class=\"fulltext__filters\">\n      <mat-select\n        class=\"fulltext__scope\"\n        [panelWidth]=\"null\"\n        panelClass=\"smart-search-select-panel\"\n        [value]=\"fulltext().scope\"\n        (selectionChange)=\"setFulltextScope($event.value)\"\n        [aria-label]=\"'yuv.smart-search.fulltext.scope.label' | translate\"\n      >\n        <mat-option value=\"all\">{{ 'yuv.smart-search.fulltext.scope.all' | translate }}</mat-option>\n        <mat-option value=\"metadata\">{{ 'yuv.smart-search.fulltext.scope.metadata' | translate }}</mat-option>\n        <mat-option value=\"content\">{{ 'yuv.smart-search.fulltext.scope.content' | translate }}</mat-option>\n      </mat-select>\n\n      <mat-select\n        class=\"fulltext__types\"\n        multiple\n        [panelWidth]=\"null\"\n        panelClass=\"smart-search-select-panel\"\n        [value]=\"fulltextTypeSelection()\"\n        (selectionChange)=\"onFulltextTypesChange($event.value)\"\n        [aria-label]=\"'yuv.smart-search.fulltext.types.label' | translate\"\n      >\n        <mat-option [value]=\"ALL_TYPES\">{{ 'yuv.smart-search.fulltext.types.all' | translate }}</mat-option>\n        @for (t of objectTypes(); track t.id) {\n          <mat-option [value]=\"t.id\">{{ t.label ?? t.id }}</mat-option>\n        }\n      </mat-select>\n    </div>\n  </div>\n\n  <!-- Joiner between the full-text unit and the condition blocks. Top-level units\n       always combine with OR (\"looking for this as well as that\"), so this is a\n       static label rather than a toggle. -->\n  @if (fulltext().term.trim() && ctrl.blocks().length) {\n    <div class=\"combinator\">\n      <span class=\"combinator__label\">{{ 'yuv.smart-search.combinator.as-well-as' | translate }}</span>\n    </div>\n  }\n\n  <!-- \u2500\u2500 Step 1: Type blocks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  @for (block of ctrl.blocks(); track block.id) {\n    <div class=\"block\" [attr.data-block-id]=\"block.id\" [class.block--active]=\"ctrl.activeBlock() === block\">\n      <div class=\"block__header\">\n        <div class=\"block__types\">\n          @for (t of block.types; track t.id) {\n            @if (!$first) {\n              <span class=\"block__type-sep\">{{ 'yuv.smart-search.combinator.or' | translate }}</span>\n            }\n            <span class=\"block__type\">\n              <span class=\"block__type-label\">{{ t.label }}</span>\n            </span>\n          }\n        </div>\n        <button\n          ymtIconButton\n          icon-button-size=\"extra-small\"\n          class=\"block__remove\"\n          (click)=\"removeBlock(block)\"\n          [matTooltip]=\"'yuv.smart-search.type.remove' | translate\"\n        >\n          <mat-icon>close</mat-icon>\n        </button>\n      </div>\n\n      <div class=\"block__conditions\">\n        <yuv-smart-search-group [group]=\"block\" [bare]=\"true\" [chipTpl]=\"chipTpl\" [editorTpl]=\"editorTpl\" />\n      </div>\n    </div>\n\n    <!-- Static joiner between blocks \u2014 blocks are type-scoped, so they always\n         combine with OR (\"this type as well as that type\"). -->\n    @if (!$last && ctrl.showCombinator()) {\n      <div class=\"combinator\">\n        <span class=\"combinator__label\">{{ 'yuv.smart-search.combinator.as-well-as' | translate }}</span>\n      </div>\n    }\n  }\n\n  <!-- \u2500\u2500 Step 1 input: add a type block (multi-select) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  @if (ctrl.step() === 'type') {\n    <div class=\"add-type-row\">\n      <button\n        type=\"button\"\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"add-type-row__icon\"\n        (click)=\"typeInput.focus()\"\n        [attr.aria-label]=\"'yuv.smart-search.add-type' | translate\"\n      >\n        <mat-icon>add_circle_outline</mat-icon>\n      </button>\n\n      <!-- Staged draft types as removable Material chips -->\n      <mat-chip-grid\n        #typeChipGrid\n        class=\"add-type-row__chips\"\n        [attr.aria-label]=\"'yuv.smart-search.add-type' | translate\"\n      >\n        @for (t of ctrl.draftTypes(); track t.id) {\n          <mat-chip-row (removed)=\"ctrl.removeDraftType(t.id)\">\n            {{ t.label }}\n            <button matChipRemove [attr.aria-label]=\"'yuv.smart-search.type.remove-draft' | translate\">\n              <mat-icon>close</mat-icon>\n            </button>\n          </mat-chip-row>\n        }\n        <input\n          #typeInput\n          [formControl]=\"ctrl.fieldCtrl\"\n          [placeholder]=\"'yuv.smart-search.add-type' | translate\"\n          [matAutocomplete]=\"auto\"\n          [matChipInputFor]=\"typeChipGrid\"\n          (keydown.enter)=\"onTypeEnter()\"\n          (keydown.escape)=\"cancelPending()\"\n        />\n      </mat-chip-grid>\n\n      @if (ctrl.draftTypes().length) {\n        <button\n          ymtIconButton\n          icon-button-size=\"extra-small\"\n          class=\"add-type-row__confirm\"\n          (click)=\"confirmTypes()\"\n          [matTooltip]=\"'yuv.smart-search.type.confirm' | translate\"\n        >\n          <mat-icon>check</mat-icon>\n        </button>\n      }\n    </div>\n  }\n\n  <!-- \u2500\u2500 Shared autocomplete panel \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  <mat-autocomplete\n    #auto\n    panelWidth=\"auto\"\n    [displayWith]=\"displayFn\"\n    (optionSelected)=\"onSuggestionSelected($event)\"\n    (closed)=\"onPickerClosed()\"\n  >\n    @for (s of ctrl.suggestions(); track s.id) {\n      <mat-option [value]=\"s\">\n        <div class=\"suggestion\">\n          @if (s.kind !== 'type') {\n            <mat-icon class=\"suggestion__icon\">\n              @switch (s.kind) {\n                @case ('field') {\n                  tune\n                }\n                @case ('date-preset') {\n                  calendar_today\n                }\n                @default {\n                  manage_search\n                }\n              }\n            </mat-icon>\n          }\n          <span class=\"suggestion__label\">{{ s.label }}</span>\n        </div>\n      </mat-option>\n    }\n  </mat-autocomplete>\n</div>\n", styles: [":host{display:block;--outline: rgb(from var(--ymt-text-color) r g b / .5);--focus-visible-border-color: var(--ymt-primary);--focus-visible-border-shadow-color: rgb(from var(--ymt-primary) r g b / .3)}::ng-deep .smart-search-select-panel.mat-mdc-select-panel{min-width:max-content}::ng-deep .smart-search-select-panel.mat-mdc-select-panel .mat-mdc-option .mdc-list-item__primary-text{white-space:nowrap}.smart-search{display:flex;flex-direction:column;gap:var(--ymt-spacing-xs)}.fulltext{display:flex;flex-direction:column;gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);border:1px solid var(--outline);border-radius:var(--ymt-corner-s);transition:opacity .15s}.fulltext.muted{opacity:.7}.fulltext.muted:hover,.fulltext.muted:focus-within{opacity:1}.fulltext__term{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.fulltext__icon{color:var(--ymt-text-color-subtle)}.fulltext__input{flex:1;min-width:120px;border:none;outline:none;background:transparent;font:inherit;color:var(--ymt-text-color)}.fulltext__input::placeholder{color:var(--ymt-text-color-subtle);opacity:.7}.fulltext__filters{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:var(--ymt-spacing-s)}.fulltext__scope,.fulltext__types{width:auto;font-size:.9em;color:var(--ymt-text-color-subtle);border:1px solid var(--ymt-outline);border-radius:var(--ymt-corner-xs);padding-inline:var(--ymt-spacing-xs)}.fulltext__scope:focus-visible,.fulltext__types:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.block{border:1px solid var(--outline);border-radius:var(--ymt-corner-s);overflow:hidden;transition:border-color .15s;padding:var(--ymt-spacing-2xs)}.block:focus-within{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 3px var(--focus-visible-border-shadow-color)}.block__header{border-radius:var(--ymt-corner-xs);display:flex;flex-wrap:wrap;align-items:center;gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);background:var(--ymt-surface-container-high)}.block__types{flex:1;display:flex;align-items:center;flex-wrap:wrap}.block__type{display:inline-flex;align-items:center;gap:var(--ymt-spacing-2xs)}.block__type-sep{font:var(--ymt-font-body-subtle);text-transform:lowercase;color:var(--ymt-text-color-subtle);padding:0 var(--ymt-spacing-xs)}.block__remove{margin-inline-start:auto;opacity:.7}.block__conditions{display:flex;flex-wrap:wrap;align-items:center;row-gap:var(--ymt-spacing-2xs);column-gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);min-height:44px}.condition-chip{display:inline-flex;align-items:center;gap:0;border-radius:var(--ymt-corner-xs);border:1px solid var(--outline);cursor:pointer;overflow:hidden;outline:none;padding:var(--ymt-spacing-4xs) var(--ymt-spacing-3xs);gap:var(--ymt-spacing-4xs)}.condition-chip:hover{border-color:var(--ymt-outline)}.condition-chip:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.condition-chip__part{display:inline-flex;align-items:center;gap:var(--ymt-spacing-4xs);padding:0 var(--ymt-spacing-xs);height:100%;white-space:nowrap;color:var(--ymt-text-color)}.condition-chip__part:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.condition-chip__op{font:var(--ymt-font-body-subtle);color:var(--ymt-text-color-subtle);padding:0}.condition-chip__value{max-width:120px;overflow:hidden;text-overflow:ellipsis;--tile-slot-padding: 0;--yuv-renderer-display: inline-flex}.condition-chip__remove{color:var(--ymt-text-color-subtle)}.condition-chip__remove:hover{color:var(--ymt-text-color)}.inline-input{display:flex;align-items:center;gap:var(--ymt-spacing-3xs);flex:1;border:1px dashed var(--outline);border-radius:var(--ymt-corner-xs);padding:var(--ymt-spacing-4xs) var(--ymt-spacing-2xs);background:var(--ymt-surface)}.inline-input .part-pill{display:inline-flex;align-items:center;gap:var(--ymt-spacing-4xs);white-space:nowrap;font:inherit;font-size:var(--ymt-font-body-subtle-size);color:var(--ymt-text-color);background:var(--ymt-surface-container);border:1px solid transparent;border-radius:var(--ymt-corner-xs);padding:var(--ymt-spacing-4xs) var(--ymt-spacing-xs);cursor:pointer;transition:border-color .1s,background .1s}.inline-input .part-pill:hover{background:var(--ymt-surface-container-high)}.inline-input .part-pill:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.inline-input .part-pill--active{border-color:var(--ymt-primary);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.inline-input .part-pill mat-icon{font-size:var(--ymt-sizing-xs);width:var(--ymt-sizing-xs);height:var(--ymt-sizing-xs)}.inline-input yuv-metadata-form-field{flex:1;min-width:150px}.inline-input input{flex:1;border:none;outline:none;background:transparent}.inline-input .confirm-btn:not(:disabled){opacity:1;color:var(--ymt-color-accent)}.combinator{display:flex;justify-content:center;gap:0}.combinator__label{font:var(--ymt-font-body-subtle);text-transform:lowercase;color:var(--ymt-text-color-subtle);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs)}.combinator__btn{--bg: transparent;--fg: var(--ymt-text-color);--mdc-shape-small: var(--ymt-corner-xs);background-color:var(--bg);color:var(--fg);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs);border:0;outline:1px solid var(--ymt-inverse-surface);outline-offset:-1px}.combinator__btn:first-child{border-radius:var(--mdc-shape-small) 0 0 var(--mdc-shape-small)}.combinator__btn:last-child{border-radius:0 var(--mdc-shape-small) var(--mdc-shape-small) 0}.combinator__btn--active{--bg: var(--ymt-inverse-surface);--fg: var(--ymt-on-inverse-surface)}.add-type-row{display:flex;flex-wrap:wrap;align-items:center;gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);border:1px dashed var(--ymt-outline);border-radius:var(--ymt-corner-s);color:var(--ymt-text-color-subtle)}.add-type-row__icon{display:inline-flex;align-items:center;padding:0;border:0;background:transparent;color:inherit;cursor:pointer}.add-type-row__icon mat-icon{font-size:var(--ymt-sizing-m);width:var(--ymt-sizing-m);height:var(--ymt-sizing-m);opacity:.5}.add-type-row__icon:hover mat-icon{opacity:.8}.add-type-row__confirm{color:var(--ymt-primary)}.add-type-row__chips{flex:1;min-width:120px}.add-type-row input{flex:1;min-width:120px;border:none;outline:none;background:transparent;font:inherit;font-size:.9em;color:inherit}.add-type-row input::placeholder{color:var(--ymt-text-color-subtle);opacity:.7}.condition-combinator{display:flex;align-self:center}.suggestion{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.suggestion__icon{font-size:var(--ymt-sizing-s);width:var(--ymt-sizing-s);height:var(--ymt-sizing-s);--icon-size: var(--ymt-sizing-s);opacity:.6}.suggestion__label{flex:1}\n"], dependencies: [{ kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: MatAutocompleteModule }, { kind: "component", type: i2$1.MatAutocomplete, selector: "mat-autocomplete", inputs: ["aria-label", "aria-labelledby", "displayWith", "autoActiveFirstOption", "autoSelectActiveOption", "requireSelection", "panelWidth", "disableRipple", "class", "hideSingleSelectionIndicator"], outputs: ["optionSelected", "opened", "closed", "optionActivated"], exportAs: ["matAutocomplete"] }, { kind: "component", type: i2$1.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "directive", type: i2$1.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", inputs: ["matAutocomplete", "matAutocompletePosition", "matAutocompleteConnectedTo", "autocomplete", "matAutocompleteDisabled"], exportAs: ["matAutocompleteTrigger"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "ngmodule", type: MatChipsModule }, { kind: "component", type: i4.MatChipGrid, selector: "mat-chip-grid", inputs: ["disabled", "placeholder", "required", "value", "errorStateMatcher"], outputs: ["change", "valueChange"] }, { kind: "directive", type: i4.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled", "readonly", "matChipInputDisabledInteractive"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { kind: "directive", type: i4.MatChipRemove, selector: "[matChipRemove]" }, { kind: "component", type: i4.MatChipRow, selector: "mat-chip-row, [mat-chip-row], mat-basic-chip-row, [mat-basic-chip-row]", inputs: ["editable"], outputs: ["edited"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i5.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth", "canSelectNullableOptions"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "directive", type: YmtIconButtonDirective, selector: "button[ymtIconButton],button[ymt-icon-button],a[ymtIconButton],a[ymt-icon-button]", inputs: ["disabled", "disableRipple", "aria-disabled", "disabledInteractive", "icon-button-size"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "component", type: MetadataFormFieldComponent, selector: "yuv-metadata-form-field", inputs: ["formChangedSubject", "field", "variant", "situation"] }, { kind: "directive", type: RendererDirective, selector: "[yuvRenderer]", inputs: ["yuvRenderer"] }, { kind: "component", type: SmartSearchGroupComponent, selector: "yuv-smart-search-group", inputs: ["group", "bare", "chipTpl", "editorTpl"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: SmartSearchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-smart-search', imports: [
+                        ReactiveFormsModule,
+                        MatAutocompleteModule,
+                        MatInputModule,
+                        MatIconModule,
+                        MatButtonModule,
+                        MatChipsModule,
+                        MatSelectModule,
+                        YmtIconButtonDirective,
+                        MatTooltipModule,
+                        MetadataFormFieldComponent,
+                        RendererDirective,
+                        SmartSearchGroupComponent,
+                        TranslatePipe
+                    ], providers: [SmartSearchEditController], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"smart-search\" halo-container halo-container-skip=\"true\">\n  <!-- Condition chip template \u2014 passed down into the recursive group component. -->\n  <ng-template #chipTpl let-condition let-container=\"container\" let-i=\"index\">\n    <div\n      class=\"condition-chip\"\n      tabindex=\"0\"\n      role=\"button\"\n      [attr.aria-label]=\"'yuv.smart-search.condition.edit-aria' | translate: { label: condition.conditionLabel }\"\n      (click)=\"editCondition(container, condition, i)\"\n      (keydown.space)=\"$event.preventDefault(); editCondition(container, condition, i)\"\n      (keydown.enter)=\"$event.preventDefault(); editCondition(container, condition, i)\"\n    >\n      <span class=\"condition-chip__part condition-chip__field\">\n        <!-- <mat-icon>tune</mat-icon> -->\n        {{ condition.fieldLabel }}\n      </span>\n      <span class=\"condition-chip__part condition-chip__op\">{{ condition.operatorLabel }}</span>\n      <span class=\"condition-chip__part condition-chip__value\">\n        @if (valueRendererInput(condition); as rendererInput) {\n          <ng-container *yuvRenderer=\"rendererInput\" />\n        } @else {\n          {{ condition.value }}\n        }\n      </span>\n      <button\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"condition-chip__remove\"\n        tabindex=\"-1\"\n        [attr.aria-label]=\"'yuv.smart-search.condition.remove' | translate\"\n        (click)=\"$event.stopPropagation(); removeCondition(container, condition)\"\n      >\n        <mat-icon>close</mat-icon>\n      </button>\n    </div>\n  </ng-template>\n\n  <!-- Inline editor template \u2014 rendered inside whichever container is active. -->\n  <ng-template #editorTpl>\n    <div class=\"inline-input\" tabindex=\"-1\" (focusout)=\"onInlineBlur($event)\" (keydown.escape)=\"cancelPending()\">\n      @if (ctrl.step() !== 'field' && ctrl.pendingField()) {\n        <button\n          class=\"part-pill\"\n          [class.part-pill--active]=\"ctrl.step() === 'field'\"\n          (click)=\"editField()\"\n          [matTooltip]=\"'yuv.smart-search.field.change' | translate\"\n        >\n          {{ ctrl.pendingField()?.label }}\n        </button>\n      }\n\n      @if (ctrl.step() === 'value' && ctrl.operatorCtrl.value) {\n        <button\n          class=\"part-pill\"\n          [class.part-pill--active]=\"ctrl.step() === 'operator'\"\n          (click)=\"editOperator()\"\n          [matTooltip]=\"'yuv.smart-search.operator.change' | translate\"\n        >\n          {{ ctrl.operatorCtrl.value }}\n        </button>\n      }\n\n      @if (ctrl.step() === 'field') {\n        <input\n          [formControl]=\"ctrl.fieldCtrl\"\n          [matAutocomplete]=\"auto\"\n          [placeholder]=\"'yuv.smart-search.field.pick' | translate\"\n          (keydown.enter)=\"onEnter()\"\n        />\n      } @else if (ctrl.step() === 'operator') {\n        <input\n          [formControl]=\"ctrl.operatorCtrl\"\n          [matAutocomplete]=\"auto\"\n          [placeholder]=\"'yuv.smart-search.operator.select' | translate\"\n          (keydown.enter)=\"onEnter()\"\n        />\n      } @else if (ctrl.step() === 'value') {\n        @let otf = valueFieldDef();\n        @if (otf) {\n          <yuv-metadata-form-field variant=\"raw\" [field]=\"otf\" situation=\"EDIT\" [formControl]=\"ctrl.valueCtrl\" />\n        } @else {\n          <input\n            [formControl]=\"ctrl.valueCtrl\"\n            [matAutocomplete]=\"auto\"\n            [placeholder]=\"'yuv.smart-search.value.enter' | translate\"\n            (keydown.enter)=\"onEnter()\"\n          />\n        }\n      }\n\n      <button\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"confirm-btn\"\n        [disabled]=\"!ctrl.isConditionComplete()\"\n        (click)=\"onEnter()\"\n        [matTooltip]=\"'yuv.smart-search.confirm' | translate\"\n      >\n        <mat-icon>check</mat-icon>\n      </button>\n      <button\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"cancel-btn\"\n        (click)=\"cancelPending()\"\n        [matTooltip]=\"'yuv.smart-search.cancel' | translate\"\n      >\n        <mat-icon>close</mat-icon>\n      </button>\n    </div>\n  </ng-template>\n\n  <!-- \u2500\u2500 Full-text search bar \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  <div class=\"fulltext\" [class.muted]=\"!fulltext().term.trim() && ctrl.blocks().length\">\n    <!-- Row 1: full-width term -->\n    <div class=\"fulltext__term\">\n      <mat-icon class=\"fulltext__icon\">search</mat-icon>\n      <input\n        class=\"fulltext__input\"\n        [formControl]=\"fulltextTermCtrl\"\n        [placeholder]=\"'yuv.smart-search.fulltext.placeholder' | translate\"\n      />\n    </div>\n\n    <!-- Row 2: scope (single) + types (multiple) -->\n    <div class=\"fulltext__filters\">\n      <mat-select\n        class=\"fulltext__scope\"\n        [panelWidth]=\"null\"\n        panelClass=\"smart-search-select-panel\"\n        [value]=\"fulltext().scope\"\n        (selectionChange)=\"setFulltextScope($event.value)\"\n        [aria-label]=\"'yuv.smart-search.fulltext.scope.label' | translate\"\n      >\n        <mat-option value=\"all\">{{ 'yuv.smart-search.fulltext.scope.all' | translate }}</mat-option>\n        <mat-option value=\"metadata\">{{ 'yuv.smart-search.fulltext.scope.metadata' | translate }}</mat-option>\n        <mat-option value=\"content\">{{ 'yuv.smart-search.fulltext.scope.content' | translate }}</mat-option>\n      </mat-select>\n\n      <mat-select\n        class=\"fulltext__types\"\n        multiple\n        [panelWidth]=\"null\"\n        panelClass=\"smart-search-select-panel\"\n        [value]=\"fulltextTypeSelection()\"\n        (selectionChange)=\"onFulltextTypesChange($event.value)\"\n        [aria-label]=\"'yuv.smart-search.fulltext.types.label' | translate\"\n      >\n        <mat-option [value]=\"ALL_TYPES\">{{ 'yuv.smart-search.fulltext.types.all' | translate }}</mat-option>\n        @for (t of objectTypes(); track t.id) {\n          <mat-option [value]=\"t.id\">{{ t.label ?? t.id }}</mat-option>\n        }\n      </mat-select>\n    </div>\n  </div>\n\n  <!-- Joiner between the full-text unit and the condition blocks. Top-level units\n       always combine with OR (\"looking for this as well as that\"), so this is a\n       static label rather than a toggle. -->\n  @if (fulltext().term.trim() && ctrl.blocks().length) {\n    <div class=\"combinator\">\n      <span class=\"combinator__label\">{{ 'yuv.smart-search.combinator.as-well-as' | translate }}</span>\n    </div>\n  }\n\n  <!-- \u2500\u2500 Step 1: Type blocks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  @for (block of ctrl.blocks(); track block.id) {\n    <div class=\"block\" [attr.data-block-id]=\"block.id\" [class.block--active]=\"ctrl.activeBlock() === block\">\n      <div class=\"block__header\">\n        <div class=\"block__types\">\n          @for (t of block.types; track t.id) {\n            @if (!$first) {\n              <span class=\"block__type-sep\">{{ 'yuv.smart-search.combinator.or' | translate }}</span>\n            }\n            <span class=\"block__type\">\n              <span class=\"block__type-label\">{{ t.label }}</span>\n            </span>\n          }\n        </div>\n        <button\n          ymtIconButton\n          icon-button-size=\"extra-small\"\n          class=\"block__remove\"\n          (click)=\"removeBlock(block)\"\n          [matTooltip]=\"'yuv.smart-search.type.remove' | translate\"\n        >\n          <mat-icon>close</mat-icon>\n        </button>\n      </div>\n\n      <div class=\"block__conditions\">\n        <yuv-smart-search-group [group]=\"block\" [bare]=\"true\" [chipTpl]=\"chipTpl\" [editorTpl]=\"editorTpl\" />\n      </div>\n    </div>\n\n    <!-- Static joiner between blocks \u2014 blocks are type-scoped, so they always\n         combine with OR (\"this type as well as that type\"). -->\n    @if (!$last && ctrl.showCombinator()) {\n      <div class=\"combinator\">\n        <span class=\"combinator__label\">{{ 'yuv.smart-search.combinator.as-well-as' | translate }}</span>\n      </div>\n    }\n  }\n\n  <!-- \u2500\u2500 Step 1 input: add a type block (multi-select) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  @if (ctrl.step() === 'type') {\n    <div class=\"add-type-row\">\n      <button\n        type=\"button\"\n        ymtIconButton\n        icon-button-size=\"extra-small\"\n        class=\"add-type-row__icon\"\n        (click)=\"typeInput.focus()\"\n        [attr.aria-label]=\"'yuv.smart-search.add-type' | translate\"\n      >\n        <mat-icon>add_circle_outline</mat-icon>\n      </button>\n\n      <!-- Staged draft types as removable Material chips -->\n      <mat-chip-grid\n        #typeChipGrid\n        class=\"add-type-row__chips\"\n        [attr.aria-label]=\"'yuv.smart-search.add-type' | translate\"\n      >\n        @for (t of ctrl.draftTypes(); track t.id) {\n          <mat-chip-row (removed)=\"ctrl.removeDraftType(t.id)\">\n            {{ t.label }}\n            <button matChipRemove [attr.aria-label]=\"'yuv.smart-search.type.remove-draft' | translate\">\n              <mat-icon>close</mat-icon>\n            </button>\n          </mat-chip-row>\n        }\n        <input\n          #typeInput\n          [formControl]=\"ctrl.fieldCtrl\"\n          [placeholder]=\"'yuv.smart-search.add-type' | translate\"\n          [matAutocomplete]=\"auto\"\n          [matChipInputFor]=\"typeChipGrid\"\n          (keydown.enter)=\"onTypeEnter()\"\n          (keydown.escape)=\"cancelPending()\"\n        />\n      </mat-chip-grid>\n\n      @if (ctrl.draftTypes().length) {\n        <button\n          ymtIconButton\n          icon-button-size=\"extra-small\"\n          class=\"add-type-row__confirm\"\n          (click)=\"confirmTypes()\"\n          [matTooltip]=\"'yuv.smart-search.type.confirm' | translate\"\n        >\n          <mat-icon>check</mat-icon>\n        </button>\n      }\n    </div>\n  }\n\n  <!-- \u2500\u2500 Shared autocomplete panel \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 -->\n  <mat-autocomplete\n    #auto\n    panelWidth=\"auto\"\n    [displayWith]=\"displayFn\"\n    (optionSelected)=\"onSuggestionSelected($event)\"\n    (closed)=\"onPickerClosed()\"\n  >\n    @for (s of ctrl.suggestions(); track s.id) {\n      <mat-option [value]=\"s\">\n        <div class=\"suggestion\">\n          @if (s.kind !== 'type') {\n            <mat-icon class=\"suggestion__icon\">\n              @switch (s.kind) {\n                @case ('field') {\n                  tune\n                }\n                @case ('date-preset') {\n                  calendar_today\n                }\n                @default {\n                  manage_search\n                }\n              }\n            </mat-icon>\n          }\n          <span class=\"suggestion__label\">{{ s.label }}</span>\n        </div>\n      </mat-option>\n    }\n  </mat-autocomplete>\n</div>\n", styles: [":host{display:block;--outline: rgb(from var(--ymt-text-color) r g b / .5);--focus-visible-border-color: var(--ymt-primary);--focus-visible-border-shadow-color: rgb(from var(--ymt-primary) r g b / .3)}::ng-deep .smart-search-select-panel.mat-mdc-select-panel{min-width:max-content}::ng-deep .smart-search-select-panel.mat-mdc-select-panel .mat-mdc-option .mdc-list-item__primary-text{white-space:nowrap}.smart-search{display:flex;flex-direction:column;gap:var(--ymt-spacing-xs)}.fulltext{display:flex;flex-direction:column;gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);border:1px solid var(--outline);border-radius:var(--ymt-corner-s);transition:opacity .15s}.fulltext.muted{opacity:.7}.fulltext.muted:hover,.fulltext.muted:focus-within{opacity:1}.fulltext__term{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.fulltext__icon{color:var(--ymt-text-color-subtle)}.fulltext__input{flex:1;min-width:120px;border:none;outline:none;background:transparent;font:inherit;color:var(--ymt-text-color)}.fulltext__input::placeholder{color:var(--ymt-text-color-subtle);opacity:.7}.fulltext__filters{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:var(--ymt-spacing-s)}.fulltext__scope,.fulltext__types{width:auto;font-size:.9em;color:var(--ymt-text-color-subtle);border:1px solid var(--ymt-outline);border-radius:var(--ymt-corner-xs);padding-inline:var(--ymt-spacing-xs)}.fulltext__scope:focus-visible,.fulltext__types:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.block{border:1px solid var(--outline);border-radius:var(--ymt-corner-s);overflow:hidden;transition:border-color .15s;padding:var(--ymt-spacing-2xs)}.block:focus-within{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 3px var(--focus-visible-border-shadow-color)}.block__header{border-radius:var(--ymt-corner-xs);display:flex;flex-wrap:wrap;align-items:center;gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);background:var(--ymt-surface-container-high)}.block__types{flex:1;display:flex;align-items:center;flex-wrap:wrap}.block__type{display:inline-flex;align-items:center;gap:var(--ymt-spacing-2xs)}.block__type-sep{font:var(--ymt-font-body-subtle);text-transform:lowercase;color:var(--ymt-text-color-subtle);padding:0 var(--ymt-spacing-xs)}.block__remove{margin-inline-start:auto;opacity:.7}.block__conditions{display:flex;flex-wrap:wrap;align-items:center;row-gap:var(--ymt-spacing-2xs);column-gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);min-height:44px}.condition-chip{display:inline-flex;align-items:center;gap:0;border-radius:var(--ymt-corner-xs);border:1px solid var(--outline);cursor:pointer;overflow:hidden;outline:none;padding:var(--ymt-spacing-4xs) var(--ymt-spacing-3xs);gap:var(--ymt-spacing-4xs)}.condition-chip:hover{border-color:var(--ymt-outline)}.condition-chip:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.condition-chip__part{display:inline-flex;align-items:center;gap:var(--ymt-spacing-4xs);padding:0 var(--ymt-spacing-xs);height:100%;white-space:nowrap;color:var(--ymt-text-color)}.condition-chip__part:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.condition-chip__op{font:var(--ymt-font-body-subtle);color:var(--ymt-text-color-subtle);padding:0}.condition-chip__value{max-width:120px;overflow:hidden;text-overflow:ellipsis;--tile-slot-padding: 0;--yuv-renderer-display: inline-flex}.condition-chip__remove{color:var(--ymt-text-color-subtle)}.condition-chip__remove:hover{color:var(--ymt-text-color)}.inline-input{display:flex;align-items:center;gap:var(--ymt-spacing-3xs);flex:1;border:1px dashed var(--outline);border-radius:var(--ymt-corner-xs);padding:var(--ymt-spacing-4xs) var(--ymt-spacing-2xs);background:var(--ymt-surface)}.inline-input .part-pill{display:inline-flex;align-items:center;gap:var(--ymt-spacing-4xs);white-space:nowrap;font:inherit;font-size:var(--ymt-font-body-subtle-size);color:var(--ymt-text-color);background:var(--ymt-surface-container);border:1px solid transparent;border-radius:var(--ymt-corner-xs);padding:var(--ymt-spacing-4xs) var(--ymt-spacing-xs);cursor:pointer;transition:border-color .1s,background .1s}.inline-input .part-pill:hover{background:var(--ymt-surface-container-high)}.inline-input .part-pill:focus-visible{border-color:var(--focus-visible-border-color);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.inline-input .part-pill--active{border-color:var(--ymt-primary);box-shadow:0 0 0 2px var(--focus-visible-border-shadow-color)}.inline-input .part-pill mat-icon{font-size:var(--ymt-sizing-xs);width:var(--ymt-sizing-xs);height:var(--ymt-sizing-xs)}.inline-input yuv-metadata-form-field{flex:1;min-width:150px}.inline-input input{flex:1;border:none;outline:none;background:transparent}.inline-input .confirm-btn:not(:disabled){opacity:1;color:var(--ymt-color-accent)}.combinator{display:flex;justify-content:center;gap:0}.combinator__label{font:var(--ymt-font-body-subtle);text-transform:lowercase;color:var(--ymt-text-color-subtle);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs)}.combinator__btn{--bg: transparent;--fg: var(--ymt-text-color);--mdc-shape-small: var(--ymt-corner-xs);background-color:var(--bg);color:var(--fg);padding:var(--ymt-spacing-2xs) var(--ymt-spacing-xs);border:0;outline:1px solid var(--ymt-inverse-surface);outline-offset:-1px}.combinator__btn:first-child{border-radius:var(--mdc-shape-small) 0 0 var(--mdc-shape-small)}.combinator__btn:last-child{border-radius:0 var(--mdc-shape-small) var(--mdc-shape-small) 0}.combinator__btn--active{--bg: var(--ymt-inverse-surface);--fg: var(--ymt-on-inverse-surface)}.add-type-row{display:flex;flex-wrap:wrap;align-items:center;gap:var(--ymt-spacing-xs);padding:var(--ymt-spacing-xs) var(--ymt-spacing-s);border:1px dashed var(--ymt-outline);border-radius:var(--ymt-corner-s);color:var(--ymt-text-color-subtle)}.add-type-row__icon{display:inline-flex;align-items:center;padding:0;border:0;background:transparent;color:inherit;cursor:pointer}.add-type-row__icon mat-icon{font-size:var(--ymt-sizing-m);width:var(--ymt-sizing-m);height:var(--ymt-sizing-m);opacity:.5}.add-type-row__icon:hover mat-icon{opacity:.8}.add-type-row__confirm{color:var(--ymt-primary)}.add-type-row__chips{flex:1;min-width:120px}.add-type-row input{flex:1;min-width:120px;border:none;outline:none;background:transparent;font:inherit;font-size:.9em;color:inherit}.add-type-row input::placeholder{color:var(--ymt-text-color-subtle);opacity:.7}.condition-combinator{display:flex;align-self:center}.suggestion{display:flex;align-items:center;gap:var(--ymt-spacing-xs)}.suggestion__icon{font-size:var(--ymt-sizing-s);width:var(--ymt-sizing-s);height:var(--ymt-sizing-s);--icon-size: var(--ymt-sizing-s);opacity:.6}.suggestion__label{flex:1}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { types: [{ type: i0.Input, args: [{ isSignal: true, alias: "types", required: false }] }], skipProperties: [{ type: i0.Input, args: [{ isSignal: true, alias: "skipProperties", required: false }] }], queryChange: [{ type: i0.Output, args: ["queryChange"] }], auto: [{ type: i0.ViewChild, args: ['auto', { isSignal: true }] }], trigger: [{ type: i0.ViewChild, args: [i0.forwardRef(() => MatAutocompleteTrigger), { isSignal: true }] }] } });
+
+/**
+ * Convenience NgModule that imports and re-exports {@link SmartSearchComponent}.
+ *
+ * The component is standalone — prefer importing `SmartSearchComponent` directly.
+ * This module exists only for consumers still organized around NgModules.
+ */
+const cmp = [SmartSearchComponent];
+class YuvSmartSearchModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: YuvSmartSearchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.12", ngImport: i0, type: YuvSmartSearchModule, imports: [SmartSearchComponent], exports: [SmartSearchComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: YuvSmartSearchModule, imports: [cmp] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: YuvSmartSearchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: cmp,
+                    exports: cmp
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SmartSearchComponent, YuvSmartSearchModule, buildCmisQuery, buildFulltextClause, buildNodeClause, isConditionGroup, isFieldCondition, isTableCondition };
+//# sourceMappingURL=yuuvis-client-framework-smart-search.mjs.map