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 `` 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; /** ObjectTypeField IDs to exclude from the field-step autocomplete suggestions. */ skipProperties: _angular_core.WritableSignal; fieldCtrl: FormControl; operatorCtrl: FormControl; valueCtrl: FormControl; /** Current input step */ step: _angular_core.WritableSignal; /** The owning top-level block (drives field suggestions for the active edit) */ activeBlock: _angular_core.WritableSignal; /** The immediate parent container the new condition will land in */ activeContainer: _angular_core.WritableSignal; /** Field selected waiting for operator/value */ pendingField: _angular_core.WritableSignal; /** Operator label for the pending operator (displayed as a pill) */ pendingOperatorLabel: _angular_core.WritableSignal; /** The accumulated search blocks */ blocks: _angular_core.WritableSignal; /** Types staged in the multi-select before the block is committed (type step). */ draftTypes: _angular_core.WritableSignal; /** Index of the condition being edited (-1 = new condition) */ editingConditionIndex: _angular_core.WritableSignal; /** * 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; /** The current filter term for autocomplete suggestions */ inputTerm: _angular_core.WritableSignal; /** The whole-object full-text search unit (independent of the condition blocks). */ fulltext: _angular_core.WritableSignal; /** Whether the dynamic-conditions feature is enabled (mirrors the host `supportDynamicConditions` input). */ supportDynamic: _angular_core.WritableSignal; /** * 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; /** The dynamic conditions surfaced as form rows; rebuilt on each {@link enterFormMode}. */ formFields: _angular_core.WritableSignal; /** * 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; /** Whether any condition is marked dynamic (gates the form-mode toggle). */ hasDynamicConditions: _angular_core.Signal; objectTypes: _angular_core.Signal; /** Fields for the active top-level block, used by the field-step suggestions. */ activeBlockFields: _angular_core.Signal; /** * 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; /** * 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; suggestions: _angular_core.Signal; /** Number of top-level query units: the full-text unit (when it has a term) plus each block. */ unitCount: _angular_core.Signal; showCombinator: _angular_core.Signal; cmisQuery: _angular_core.Signal; /** The active input control for the current step. */ activeCtrl: _angular_core.Signal>; /** 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * 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 * * * ``` * * @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; /** * 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; /** * 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; /** * 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; auto: _angular_core.Signal; /** 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; /** Term control for the full-text bar (independent of the build-step controls). */ fulltextTermCtrl: FormControl; /** 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; readonly draftTypes: _angular_core.WritableSignal<_yuuvis_client_framework_smart_search.SearchBlockType[]>; readonly combinator: _angular_core.WritableSignal; readonly step: _angular_core.WritableSignal<_yuuvis_client_framework_smart_search.BuildStep>; readonly activeBlock: _angular_core.WritableSignal; readonly activeContainer: _angular_core.WritableSignal; readonly pendingField: _angular_core.WritableSignal; readonly pendingOperatorLabel: _angular_core.WritableSignal; readonly editingConditionIndex: _angular_core.WritableSignal; readonly inputTerm: _angular_core.WritableSignal; readonly cmisQuery: _angular_core.Signal; readonly showCombinator: _angular_core.Signal; readonly suggestions: _angular_core.Signal; 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; readonly formMode: _angular_core.WritableSignal; readonly formFields: _angular_core.WritableSignal; readonly formBlocks: _angular_core.WritableSignal; readonly hasDynamicConditions: _angular_core.Signal; /** 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; readonly fieldCtrl: FormControl; readonly operatorCtrl: FormControl; readonly valueCtrl: FormControl; /** * 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; 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class YuvSmartSearchModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } export { SmartSearchComponent, YuvSmartSearchModule, buildCmisQuery, buildFulltextClause, buildNodeClause, isConditionGroup, isFieldCondition, isTableCondition }; export type { BuildStep, Combinator, ConditionContainer, ConditionGroup, ConditionNode, FieldCondition, FulltextScope, FulltextSearch, SearchBlock, SearchBlockType, SmartSearchState, SuggestionItem, TableCondition };