@yuuvis/client-framework 3.7.1 → 3.8.1

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

@@ -0,0 +1,652 @@
+import * as _angular_core from '@angular/core';
+import { FormControl } from '@angular/forms';
+import * as _yuuvis_client_core from '@yuuvis/client-core';
+import { ObjectTypeField, GenericObjectType } from '@yuuvis/client-core';
+import * as _yuuvis_client_framework_smart_search from '@yuuvis/client-framework/smart-search';
+import { MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { RendererDirectiveInput } from '@yuuvis/client-framework/renderer';
+
+/**
+ * A single committed `field operator value` condition (e.g. `name LIKE 'foo'`).
+ * The `*Label` fields are display strings for the chip; `fieldId`, `operator` and
+ * `value` are what actually drive the CMIS clause. `value` is a `string[]` for
+ * multi-value operators (which render as `IN (...)`), a string otherwise.
+ */
+interface FieldCondition {
+    /** The queryable property id (or bare column id inside a table). */
+    fieldId: string;
+    /** The field's internal form-element type (e.g. `string`, `datetime`, `string:catalog`). */
+    internalType: string;
+    /** Localized field label shown on the chip. */
+    fieldLabel: string;
+    /** Operator id (e.g. `eq`, `like`, `gt`, `empty`, `date:today`). */
+    operator: string;
+    /** Display label for the operator (symbol or translated text). */
+    operatorLabel: string;
+    /** The comparison value; an array for multi-value `IN`-style conditions. */
+    value: string | string[];
+    /** Full human-readable label for the chip (`"Name like foo"`). */
+    conditionLabel: string;
+    /**
+     * Marked by the user as a *dynamic* condition: it is surfaced in the generated
+     * fill-out form (see form mode) so its value can be supplied/overridden at run time
+     * without rebuilding the query. Purely a builder annotation — it does not affect the
+     * emitted query on its own.
+     */
+    dynamic?: boolean;
+}
+/**
+ * A parenthesized sub-expression with its own AND/OR combinator. Groups can
+ * hold conditions and further groups recursively, allowing deeply nested
+ * boolean expressions.
+ */
+interface ConditionGroup {
+    kind: 'group';
+    conditions: ConditionNode[];
+    combinator: Combinator;
+}
+/**
+ * A condition on a queryable `table`-type property. A table has no operator of its own;
+ * instead it holds column conditions directly — `FieldCondition`s targeting the table's
+ * columns, joined by `combinator` and matched against any row. Maps to
+ * `tableField[*].(col op val AND/OR …)` in CMIS (`[*]` = any row).
+ */
+interface TableCondition {
+    kind: 'table';
+    /** The table property id. */
+    fieldId: string;
+    fieldLabel: string;
+    /** Column conditions (`FieldCondition`s targeting the table's columns). */
+    conditions: ConditionNode[];
+    /** How the column conditions combine (AND/OR). */
+    combinator: Combinator;
+}
+/** A child of a `SearchBlock` or `ConditionGroup`. */
+type ConditionNode = FieldCondition | ConditionGroup | TableCondition;
+declare function isConditionGroup(node: ConditionNode | SearchBlock): node is ConditionGroup;
+declare function isTableCondition(node: ConditionNode | SearchBlock): node is TableCondition;
+declare function isFieldCondition(node: ConditionNode): node is FieldCondition;
+/** One target object type within a (potentially multi-type) search block. */
+interface SearchBlockType {
+    id: string;
+    label: string;
+    isSot?: boolean;
+}
+interface SearchBlock {
+    /** Stable key for `@for` tracking — generated, not derived from a type id. */
+    id: string;
+    /** The object types this block targets. Conditions apply to their shared fields. */
+    types: SearchBlockType[];
+    conditions: ConditionNode[];
+    conditionCombinator: Combinator;
+}
+/**
+ * A container whose `conditions` can be mutated by the edit flow. A `TableCondition` is a
+ * container too: its children are row-groups; each row-group's children are column conditions.
+ */
+type ConditionContainer = SearchBlock | ConditionGroup | TableCondition;
+/**
+ * Where a full-text search looks. Maps to the column-qualified CONTAINS forms:
+ * `all` → `CONTAINS('q')` (metadata + content), `content` → `system:content CONTAINS('q')`,
+ * `metadata` → `system:metadata CONTAINS('q')`.
+ */
+type FulltextScope = 'all' | 'content' | 'metadata';
+/**
+ * The whole-object full-text search unit. Independent of the condition blocks: it carries its own
+ * target types and renders a single `CONTAINS` predicate.
+ */
+interface FulltextSearch {
+    term: string;
+    scope: FulltextScope;
+    types: SearchBlockType[];
+}
+type Combinator = 'AND' | 'OR';
+type BuildStep = 'type' | 'field' | 'operator' | 'value';
+interface SuggestionItem {
+    kind: 'type' | 'field' | 'operator' | 'date-preset';
+    id: string;
+    label: string;
+    internalType?: string;
+    /** Set when a field has been paired with an operator while building a condition. */
+    operator?: string;
+}
+/**
+ * Serializable snapshot of a SmartSearch query.
+ *
+ * Capture via {@link SmartSearchComponent.getState} and restore via
+ * {@link SmartSearchComponent.loadState}. Safe for `JSON.stringify` /
+ * `JSON.parse` roundtrips (plain data, no class instances or signals).
+ */
+interface SmartSearchState {
+    blocks: SearchBlock[];
+    combinator: Combinator;
+    /** Optional so states saved before full-text support remain loadable. */
+    fulltext?: FulltextSearch;
+}
+
+/**
+ * A single row of the generated fill-out form: the dynamic condition it edits, its
+ * resolved value-editor field definition (or `null` to fall back to a plain text input)
+ * and the `FormControl` bound to the value widget.
+ */
+interface DynamicFormField {
+    condition: FieldCondition;
+    def: ObjectTypeField | null;
+    control: FormControl;
+}
+/**
+ * A block's worth of dynamic form rows. The generated fill-out form mirrors the builder's
+ * block layout: each block contributes a muted header listing its target types, followed by
+ * the dynamic conditions ({@link DynamicFormField}s) collected from anywhere within that block.
+ * Blocks with no dynamic conditions are omitted.
+ */
+interface DynamicFormBlock {
+    block: SearchBlock;
+    fields: DynamicFormField[];
+}
+/**
+ * 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.
+ */
+declare class SmartSearchEditController {
+    #private;
+    /** The set of object type IDs that can be used as search blocks. */
+    allowedTypes: _angular_core.WritableSignal<string[]>;
+    /** ObjectTypeField IDs to exclude from the field-step autocomplete suggestions. */
+    skipProperties: _angular_core.WritableSignal<string[]>;
+    fieldCtrl: FormControl<string | null>;
+    operatorCtrl: FormControl<string | null>;
+    valueCtrl: FormControl<unknown>;
+    /** Current input step */
+    step: _angular_core.WritableSignal<BuildStep>;
+    /** The owning top-level block (drives field suggestions for the active edit) */
+    activeBlock: _angular_core.WritableSignal<SearchBlock | null>;
+    /** The immediate parent container the new condition will land in */
+    activeContainer: _angular_core.WritableSignal<ConditionContainer | null>;
+    /** Field selected waiting for operator/value */
+    pendingField: _angular_core.WritableSignal<SuggestionItem | null>;
+    /** Operator label for the pending operator (displayed as a pill) */
+    pendingOperatorLabel: _angular_core.WritableSignal<string>;
+    /** The accumulated search blocks */
+    blocks: _angular_core.WritableSignal<SearchBlock[]>;
+    /** Types staged in the multi-select before the block is committed (type step). */
+    draftTypes: _angular_core.WritableSignal<SearchBlockType[]>;
+    /** Index of the condition being edited (-1 = new condition) */
+    editingConditionIndex: _angular_core.WritableSignal<number>;
+    /**
+     * 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.
+     */
+    combinator: _angular_core.WritableSignal<Combinator>;
+    /** The current filter term for autocomplete suggestions */
+    inputTerm: _angular_core.WritableSignal<string>;
+    /** The whole-object full-text search unit (independent of the condition blocks). */
+    fulltext: _angular_core.WritableSignal<FulltextSearch>;
+    /** Whether the dynamic-conditions feature is enabled (mirrors the host `supportDynamicConditions` input). */
+    supportDynamic: _angular_core.WritableSignal<boolean>;
+    /**
+     * Form mode: replace the builder with a generated form of the user-marked dynamic
+     * conditions. View state only — the template ({@link blocks}) is never mutated; the
+     * form's values are overlaid onto the dynamic conditions to drive {@link cmisQuery},
+     * so the template stays reusable.
+     */
+    formMode: _angular_core.WritableSignal<boolean>;
+    /** The dynamic conditions surfaced as form rows; rebuilt on each {@link enterFormMode}. */
+    formFields: _angular_core.WritableSignal<DynamicFormField[]>;
+    /**
+     * The dynamic form rows grouped by their owning block (each carrying a muted header of
+     * target types); rebuilt on each {@link enterFormMode}. Blocks combine with `OR`
+     * ("as well as"), matching the builder.
+     */
+    formBlocks: _angular_core.WritableSignal<DynamicFormBlock[]>;
+    /** Whether any condition is marked dynamic (gates the form-mode toggle). */
+    hasDynamicConditions: _angular_core.Signal<boolean>;
+    objectTypes: _angular_core.Signal<GenericObjectType[]>;
+    /** Fields for the active top-level block, used by the field-step suggestions. */
+    activeBlockFields: _angular_core.Signal<SuggestionItem[]>;
+    /**
+     * 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.
+     */
+    activeTableColumns: _angular_core.Signal<ObjectTypeField[] | null>;
+    /**
+     * The fields offered at the field step: a table's **columns** when editing
+     * inside a table, otherwise the active block's shared fields.
+     */
+    activeFields: _angular_core.Signal<SuggestionItem[]>;
+    suggestions: _angular_core.Signal<SuggestionItem[]>;
+    /** Number of top-level query units: the full-text unit (when it has a term) plus each block. */
+    unitCount: _angular_core.Signal<number>;
+    showCombinator: _angular_core.Signal<boolean>;
+    cmisQuery: _angular_core.Signal<string>;
+    /** The active input control for the current step. */
+    activeCtrl: _angular_core.Signal<FormControl<unknown>>;
+    /** Deep-clone the current blocks, combinator and full-text unit into a serializable {@link SmartSearchState}. */
+    getState(): SmartSearchState;
+    /** Replace the current state with a saved one, normalizing legacy blocks and cancelling any in-progress edit. */
+    loadState(state: SmartSearchState): void;
+    /** Reset all search state back to its initial empty values. */
+    reset(): void;
+    /** Mark or unmark a condition as dynamic (immutably replaces the node in its container). */
+    setConditionDynamic(container: ConditionContainer, condition: FieldCondition, dynamic: boolean): void;
+    /**
+     * Enter form mode: collect every dynamic condition, resolve its value editor and seed a
+     * `FormControl` with its current value. The blocks themselves are left untouched — the
+     * form's edits are overlaid via {@link setFormValue} / {@link cmisQuery}.
+     */
+    enterFormMode(): void;
+    /** Leave form mode and discard the transient form state (the template is untouched). */
+    exitFormMode(): void;
+    /** Toggle form mode (rebuilds the form rows on each entry). */
+    toggleFormMode(): void;
+    /** Record a value entered in the form for a dynamic condition (drives the overlaid {@link cmisQuery}). */
+    setFormValue(condition: FieldCondition, raw: unknown): void;
+    /** Set the full-text search term. */
+    setFulltextTerm(term: string): void;
+    /** Set the full-text search scope (`all` / `metadata` / `content`). */
+    setFulltextScope(scope: FulltextScope): void;
+    /** Add a target type to the full-text unit (no-op if already present). */
+    addFulltextType(type: GenericObjectType, label: string): void;
+    /** Remove a target type from the full-text unit by id. */
+    removeFulltextType(id: string): void;
+    /** Replace the full-text target types from a list of object-type ids (unknown ids are dropped). */
+    setFulltextTypes(ids: string[]): void;
+    /** Stage a type in the draft multi-select (no-op if already staged). */
+    addDraftType(type: GenericObjectType, label: string): void;
+    /** Remove a staged type from the draft multi-select. */
+    removeDraftType(id: string): void;
+    /**
+     * 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(): SearchBlock | null;
+    /** Remove a whole block; cancels the in-progress edit if it belonged to that block. */
+    removeBlock(block: SearchBlock): void;
+    /** Append an empty `ConditionGroup` to a container and start adding inside it. */
+    addGroup(parent: ConditionContainer): ConditionGroup;
+    /**
+     * 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: ConditionGroup): void;
+    /** Remove a condition from the tree; empty parent groups/tables are pruned by the cascade. */
+    removeCondition(_container: ConditionContainer, condition: FieldCondition): void;
+    /** Set the top-level combinator joining the query units (full-text unit + blocks). */
+    setCombinator(value: Combinator): void;
+    /** Set the AND/OR combinator of a single container (block, group or table). */
+    setContainerCombinator(container: ConditionContainer, value: Combinator): void;
+    /**
+     * 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: SuggestionItem): void;
+    /** Begin adding a condition inside `container`. */
+    startAddCondition(container: ConditionContainer): void;
+    /** Begin editing an existing condition inside `container`. */
+    editCondition(container: ConditionContainer, condition: FieldCondition, index: number): void;
+    /** Jump back to the field step and clear the input so the user can re-type. */
+    editField(): void;
+    /** Jump back to the operator step and clear the input so the user can re-type. */
+    editOperator(): void;
+    /** Abandon the in-progress edit, restoring state and pruning any empty container created for it. */
+    cancelPending(): void;
+    /** Insert (or, when editing, re-insert at its original index) the finished condition into the active container. */
+    commitCondition(condition: FieldCondition): void;
+    /**
+     * On blur with an incomplete edit of an existing condition, reinsert the
+     * original verbatim at its original index.
+     */
+    restoreEditingSnapshot(): void;
+    /**
+     * Whether the in-progress condition has all parts needed to be committed. A value
+     * is *not* required: a field + operator with a blank value commits as an unset
+     * placeholder (see {@link isConditionUnset}).
+     */
+    isConditionComplete(): boolean;
+    /** The operators available for a field's internal type, as autocomplete items. */
+    operatorsForField(field: SuggestionItem): SuggestionItem[];
+    /** Human-readable label for an operator id: a math symbol (`=`, `≠`, …), a translated key, or the id itself. */
+    operatorLabel(operator: string): string;
+    /** Build a condition record from a date preset / boolean operator / value. */
+    buildCommitCondition(field: SuggestionItem, operatorId: string, operatorLabelText: string, value: string | string[], internalTypeOverride?: string): FieldCondition;
+    /**
+     * 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: SearchBlockType[], fieldId: string): ObjectTypeField | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartSearchEditController, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmartSearchEditController>;
+}
+
+/**
+ * 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.
+ */
+declare function isValuelessOperator(operator: string): boolean;
+/**
+ * Whether a condition is an *unset placeholder*: it uses a value-requiring operator
+ * (eq / like / gt / …) but carries no value yet. Such conditions are kept in the tree
+ * — so a saved query can act as a fill-in template — but contribute nothing to the
+ * emitted CMIS query. An empty value is unambiguously "unset" here because null-checks
+ * have their own `empty` / `not_empty` operators (offered on every queryable type).
+ */
+declare function isConditionUnset(cond: FieldCondition): boolean;
+/**
+ * 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}.
+ */
+declare function buildNodeClause(node: ConditionNode): string;
+/**
+ * Build the whole-object full-text clause: a single `CONTAINS('term')` predicate, optionally scoped
+ * to a column and AND-ed with a type restriction. Returns `''` when the term is blank.
+ */
+declare function buildFulltextClause(fulltext: FulltextSearch): string;
+/**
+ * Assemble the full CMIS statement from the search state. Each unit — the
+ * full-text clause plus every type block (type restriction `AND`-ed with its
+ * 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 `''`.
+ */
+declare function buildCmisQuery(blocks: SearchBlock[], combinator: Combinator, fulltext?: FulltextSearch): string;
+
+/**
+ * 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));
+ * }
+ * ```
+ */
+declare class SmartSearchComponent {
+    #private;
+    ctrl: SmartSearchEditController;
+    /**
+     * Object-type ids that may be searched. Restricts the type picker (both the
+     * full-text type filter and the type-block multi-select) to these types. When
+     * empty, no type is offered — set at least one id to enable building blocks.
+     */
+    types: _angular_core.InputSignal<string[]>;
+    /**
+     * 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.
+     */
+    skipProperties: _angular_core.InputSignal<string[]>;
+    /**
+     * Enables the **dynamic conditions** feature. When `true`, each committed condition can
+     * be marked dynamic and a form-mode toggle appears that swaps the builder for a generated
+     * fill-out form of those conditions. Off by default — the builder then behaves exactly as
+     * it does without the feature.
+     */
+    supportDynamicConditions: _angular_core.InputSignal<boolean>;
+    /**
+     * 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.
+     */
+    queryChange: _angular_core.OutputEmitterRef<string>;
+    auto: _angular_core.Signal<MatAutocomplete>;
+    /** Trigger of the currently-focused autocomplete input — used to re-open the
+     * panel after a type pick so the multi-select stays open. */
+    trigger: _angular_core.Signal<MatAutocompleteTrigger | undefined>;
+    /** Term control for the full-text bar (independent of the build-step controls). */
+    fulltextTermCtrl: FormControl<string | null>;
+    /** Sentinel option value representing "no type restriction" in the type multi-select. */
+    readonly ALL_TYPES = "__all__";
+    /**
+     * Guard that prevents `onInlineBlur` from cancelling the pending condition
+     * when we programmatically open the inline editor.
+     */
+    _suppressNextBlur: boolean;
+    /** Prevents the valueChanges subscriber from overwriting inputTerm during programmatic setValue */
+    _suppressInputTerm: boolean;
+    /**
+     * 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.
+     */
+    _suppressTypeConfirm: boolean;
+    /**
+     * 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`.
+     */
+    _pickerJustSelected: boolean;
+    readonly blocks: _angular_core.WritableSignal<SearchBlock[]>;
+    readonly draftTypes: _angular_core.WritableSignal<_yuuvis_client_framework_smart_search.SearchBlockType[]>;
+    readonly combinator: _angular_core.WritableSignal<Combinator>;
+    readonly step: _angular_core.WritableSignal<_yuuvis_client_framework_smart_search.BuildStep>;
+    readonly activeBlock: _angular_core.WritableSignal<SearchBlock | null>;
+    readonly activeContainer: _angular_core.WritableSignal<ConditionContainer | null>;
+    readonly pendingField: _angular_core.WritableSignal<SuggestionItem | null>;
+    readonly pendingOperatorLabel: _angular_core.WritableSignal<string>;
+    readonly editingConditionIndex: _angular_core.WritableSignal<number>;
+    readonly inputTerm: _angular_core.WritableSignal<string>;
+    readonly cmisQuery: _angular_core.Signal<string>;
+    readonly showCombinator: _angular_core.Signal<boolean>;
+    readonly suggestions: _angular_core.Signal<SuggestionItem[]>;
+    readonly fulltext: _angular_core.WritableSignal<_yuuvis_client_framework_smart_search.FulltextSearch>;
+    readonly objectTypes: _angular_core.Signal<_yuuvis_client_core.GenericObjectType[]>;
+    readonly activeBlockFields: _angular_core.Signal<SuggestionItem[]>;
+    readonly formMode: _angular_core.WritableSignal<boolean>;
+    readonly formFields: _angular_core.WritableSignal<DynamicFormField[]>;
+    readonly formBlocks: _angular_core.WritableSignal<DynamicFormBlock[]>;
+    readonly hasDynamicConditions: _angular_core.Signal<boolean>;
+    /** Whether a committed condition is an unset placeholder (drives the chip's "fill me" affordance). */
+    isUnset: typeof isConditionUnset;
+    /**
+     * Whether an operator carries its own meaning and has no value input (`is empty`,
+     * `is not empty`, date presets). Such conditions can't be made dynamic — there is
+     * nothing to fill out in the form.
+     */
+    isValueless: typeof isValuelessOperator;
+    /**
+     * Selected ids for the type multi-select. Falls back to the `ALL_TYPES`
+     * sentinel when no concrete type is picked (empty selection = no restriction).
+     */
+    readonly fulltextTypeSelection: _angular_core.Signal<string[]>;
+    readonly fieldCtrl: FormControl<string | null>;
+    readonly operatorCtrl: FormControl<string | null>;
+    readonly valueCtrl: FormControl<unknown>;
+    /**
+     * 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.
+     */
+    readonly valueFieldDef: _angular_core.Signal<ObjectTypeField | null>;
+    constructor();
+    /** Set the AND/OR combinator that joins the conditions within a single container (block, group or table). */
+    setConditionCombinator(container: ConditionContainer, value: Combinator): void;
+    /**
+     * 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(): SmartSearchState;
+    /** Restore a previously {@link getState saved} search, replacing the current one. */
+    loadState(state: SmartSearchState): void;
+    /** Clear the whole search: discard all blocks, conditions and the full-text term. */
+    clear(): void;
+    /**
+     * Toggle form mode: swap the builder for a generated fill-out form of the user-marked
+     * dynamic conditions. The template is left intact — the form's values are overlaid onto
+     * the query. No-op unless {@link supportDynamicConditions} is set.
+     */
+    toggleFormMode(): void;
+    /** Enter form mode ("Essentials") — generated fill-out form of the dynamic conditions. */
+    enterFormMode(): void;
+    /** Leave form mode ("Full Form") — back to the full builder search. */
+    exitFormMode(): void;
+    /** Mark/unmark a committed condition as dynamic (surfaced in the fill-out form). */
+    toggleDynamic(container: ConditionContainer, condition: FieldCondition): void;
+    /**
+     * 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: Combinator): void;
+    /** Remove an entire type block and all of its conditions. */
+    removeBlock(block: SearchBlock): void;
+    /** Commit the staged draft types into a new block and reset the type input. */
+    confirmTypes(): void;
+    /** Start adding a new condition inside the given container and focus the inline editor. */
+    startAddCondition(block: SearchBlock): void;
+    /** Add a nested condition group inside the given container and focus the inline editor. */
+    addGroup(block: SearchBlock): void;
+    /**
+     * `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.
+     */
+    displayFn: (item: SuggestionItem | string | null) => string;
+    /** Set where the full-text search looks: `all` (metadata + content), `metadata`, or `content`. */
+    setFulltextScope(scope: FulltextScope): void;
+    /**
+     * 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: string[]): void;
+    /**
+     * 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: MatAutocompleteSelectedEvent): void;
+    /**
+     * 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(): void;
+    /**
+     * Enter / confirm-button handler for the value step. Commits the in-progress
+     * condition when a value is present. No-op while the autocomplete panel is open
+     * (Enter selects the highlighted option there) or before the value step.
+     */
+    onEnter(): void;
+    /**
+     * 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: FocusEvent): void;
+    /**
+     * 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(): void;
+    /** Abandon the in-progress condition edit, discarding any partial input. */
+    cancelPending(): void;
+    /** Jump the inline editor back to the field step so the user can re-pick the field. */
+    editField(): void;
+    /** Jump the inline editor back to the operator step so the user can re-pick the operator. */
+    editOperator(): void;
+    /**
+     * 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: ConditionContainer, condition: FieldCondition, index: number): void;
+    /** Remove a committed condition from its container. */
+    removeCondition(container: ConditionContainer, condition: FieldCondition): void;
+    /**
+     * 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: FieldCondition): RendererDirectiveInput | null;
+    /**
+     * 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: SuggestionItem | null): ObjectTypeField | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartSearchComponent, "yuv-smart-search", never, { "types": { "alias": "types"; "required": false; "isSignal": true; }; "skipProperties": { "alias": "skipProperties"; "required": false; "isSignal": true; }; "supportDynamicConditions": { "alias": "supportDynamicConditions"; "required": false; "isSignal": true; }; }, { "queryChange": "queryChange"; }, never, never, true, never>;
+}
+
+declare class YuvSmartSearchModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuvSmartSearchModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<YuvSmartSearchModule, never, [typeof SmartSearchComponent], [typeof SmartSearchComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<YuvSmartSearchModule>;
+}
+
+export { SmartSearchComponent, YuvSmartSearchModule, buildCmisQuery, buildFulltextClause, buildNodeClause, isConditionGroup, isFieldCondition, isTableCondition };
+export type { BuildStep, Combinator, ConditionContainer, ConditionGroup, ConditionNode, FieldCondition, FulltextScope, FulltextSearch, SearchBlock, SearchBlockType, SmartSearchState, SuggestionItem, TableCondition };