@sinequa/atomic-angular 2.10.0 → 2.12.0

package/types/sinequa-atomic-angular.d.ts

@@ -1075,7 +1075,7 @@ export declare class MetadataComponent {
   }>;
   class: import("@angular/core").InputSignal<string | undefined>;
   variant: import("@angular/core").InputSignal<"primary" | "secondary" | null | undefined>;
-  size: import("@angular/core").InputSignal<"small" | "medium" | "md" | "sm" | "xs" | "xsmall" | null | undefined>;
+  size: import("@angular/core").InputSignal<"small" | "medium" | "sm" | "md" | "xs" | "xsmall" | null | undefined>;
   scheme: import("@angular/core").InputSignal<"error" | "sage" | "almond" | "pink" | "grey" | "yellow" | "cherry" | "indigo" | "cyan" | "success" | "warning" | "info" | null | undefined>;
   metadata: import("@angular/core").InputSignal<(string & Record<never, never>) | KeyOf<Article>>;
   article: import("@angular/core").InputSignal<Partial<Article> | (string & Record<never, never>)>;
@@ -2046,6 +2046,21 @@ export declare class NavbarTabsComponent {
    * than "tabs" in that context (e.g. "result categories").
    */
   ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Look of the tab strip, from galactik's `TabList`.
+   *
+   * - `primary` (default): the tabs sit in a bordered pill strip, the selected one filled;
+   * - `secondary`: a flat row on a white background, the selected tab underlined;
+   * - `inner`: the same underline on a transparent background — for a strip that lives inside a
+   *   page rather than on a bar of its own, such as the result categories under a search field.
+   *
+   * The two underline variants also get the larger tab of the design (44px, 14px semibold).
+   *
+   * @default "primary"
+   */
+  variant: import("@angular/core").InputSignal<"primary" | "secondary" | "inner">;
+  /** The pill strip is the only variant whose tabs keep galactik's own, smaller size. */
+  protected readonly isPill: import("@angular/core").Signal<boolean>;
   showCount: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /**
    * When enabled (default), tab labels are never clipped: tabs that do not fit
@@ -2118,6 +2133,11 @@ export declare class NavbarTabsComponent {
       "required": false;
       "isSignal": true;
     };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
     "showCount": {
       "alias": "showCount";
       "required": false;
@@ -11952,8 +11972,8 @@ export declare class SignedOutComponent {
   static ɵcmp: i0.ɵɵComponentDeclaration<SignedOutComponent, "signed-out, SignedOut, signedout", never, {}, {}, never, never, true, never>;
 }
 export declare class BookmarkButtonComponent {
-  variant: import("@angular/core").InputSignal<"none" | "light-accent" | "accent" | "primary" | "secondary" | "tertiary" | null | undefined>;
-  size: import("@angular/core").InputSignal<"small" | "medium" | "large" | "md" | "sm" | "xs" | "xsmall" | "lg" | null | undefined>;
+  variant: import("@angular/core").InputSignal<"none" | "primary" | "secondary" | "light-accent" | "accent" | "tertiary" | null | undefined>;
+  size: import("@angular/core").InputSignal<"small" | "medium" | "large" | "sm" | "md" | "xs" | "xsmall" | "lg" | null | undefined>;
   /**
    * Tab index applied to the inner button.
    *
@@ -13044,7 +13064,11 @@ export declare class SearchFeedbackComponent {
   onClose: import("@angular/core").OutputEmitterRef<void>;
   private readonly injector;
   pages: import("@angular/core").InputSignal<any>;
-  variant: import("@angular/core").InputSignal<"none" | "light-accent" | "accent" | "primary" | "secondary" | "tertiary" | null | undefined>;
+  variant: import("@angular/core").InputSignal<"none" | "primary" | "secondary" | "light-accent" | "accent" | "tertiary" | null | undefined>;
+  /** Size of the trigger button. `sm` fits a row of result options. */
+  size: import("@angular/core").InputSignal<"small" | "medium" | "large" | "sm" | "md" | "xs" | "xsmall" | "lg" | null | undefined>;
+  /** Shows the close cross on the button. Turn it off where the button belongs to the page and is not a suggestion to dismiss. */
+  dismissible: import("@angular/core").InputSignal<boolean>;
   readonly auditService: AuditService;
   protected readonly queryParamsStore: {
     name?: import("@angular/core").Signal<string | undefined> | undefined;
@@ -13183,6 +13207,16 @@ export declare class SearchFeedbackComponent {
       "required": false;
       "isSignal": true;
     };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "dismissible": {
+      "alias": "dismissible";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "onClose": "onClose";
   }, never, never, true, never>;
@@ -15900,7 +15934,7 @@ export declare class AggregationComponent {
    *
    * @default "auto"
    */
-  type: import("@angular/core").InputSignal<"auto" | "list" | "tree" | "date">;
+  type: import("@angular/core").InputSignal<"list" | "date" | "auto" | "tree">;
   /**
    * Whether the host removes itself from the layout (Tailwind's `hidden`, i.e.
    * `display: none`) when it resolves to zero items. When `false` (default), the
@@ -15952,7 +15986,7 @@ export declare class AggregationComponent {
    * The sub-component to render: the explicit `type` input, or the current
    * date/tree/list heuristic when `type` is `"auto"`.
    */
-  protected resolvedType: import("@angular/core").Signal<"list" | "tree" | "date">;
+  protected resolvedType: import("@angular/core").Signal<"list" | "date" | "tree">;
   /** Whether a filter is currently applied on this aggregation. */
   private readonly hasFilters;
   /**
@@ -16125,7 +16159,7 @@ export declare class AggregationPanelComponent {
    * @default false
    */
   headless: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  /** How many items are checked (applied or not yet): the count in the tooltip of the select all checkbox of the bar under the search field. */
+  /** How many items are checked (applied or not yet): the count written at the end of the "select all" row, above the items. */
   selectedCount: import("@angular/core").InputSignal<number>;
   searchText: import("@angular/core").ModelSignal<string>;
   itemsLength: import("@angular/core").InputSignal<number>;
@@ -16139,9 +16173,28 @@ export declare class AggregationPanelComponent {
   isCollapsed: import("@angular/core").WritableSignal<boolean>;
   expanded: import("@angular/core").Signal<"" | null>;
   private readonly searchBox;
+  private readonly searchToggle;
+  private readonly injector;
   /** The galactik popover (`[popover]` / `[dropdown]`) this panel is shown in, if any — resolved through the injector tree. */
   protected readonly isInPopover: boolean;
-  constructor();
+  private static nextId;
+  protected readonly searchId: string;
+  private readonly searchRequested;
+  /**
+   * Whether the facet has a search field at all: the facet allows it (`searchable`, from the custom JSON or the
+   * `searchable` input of the facet) and there is something to search in.
+   */
+  protected readonly canSearch: import("@angular/core").Signal<boolean>;
+  /**
+   * The search field is out of the way until the user asks for it with the magnifier: a field that is always there costs a
+   * line per facet, and most of the time nobody searches. A text already in the field keeps it open — it is filtering the
+   * values, and a filter you cannot see is not a filter you can undo.
+   */
+  protected readonly showSearch: import("@angular/core").Signal<boolean>;
+  /** Opens the search field and puts the focus in it, or closes it, drops its text and gives the focus back to the magnifier. */
+  protected toggleSearch(event?: Event): void;
+  /** Escape in the field closes it, as it would a popover: the way back is the key the user already knows. */
+  protected onSearchEscape(event: Event): void;
   onHeaderClick(event: Event): void;
   onToggle(event: Event): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<AggregationPanelComponent, never>;
@@ -16322,6 +16375,19 @@ export declare function filterKey(leaf: LegacyFilter): string;
  */
 export declare class AppliedFiltersComponent {
   private readonly queryParamsStore;
+  private static nextId;
+  protected readonly listId: string;
+  private readonly list;
+  /** Whether the chips take more lines than `maxLines`: only then is there anything to fold. */
+  protected readonly foldable: import("@angular/core").WritableSignal<boolean>;
+  /** The list is unfolded. */
+  protected readonly expanded: import("@angular/core").WritableSignal<boolean>;
+  /** Height of `maxLines` lines of chips, and of all of them, in pixels — measured, as the chips wrap with the width. */
+  private readonly foldedHeight;
+  private readonly fullHeight;
+  /** The height the list is given: none (it is as tall as its chips) until there is something to fold. */
+  protected readonly listHeight: import("@angular/core").Signal<number | null>;
+  protected toggle(): void;
   /**
    * The filters to display. Omit it to read the current query's own — the common case.
    *
@@ -16351,9 +16417,22 @@ export declare class AppliedFiltersComponent {
   /** Chip colour scheme, passed to galactik's `tag`. */
   readonly scheme: import("@angular/core").InputSignal<"error" | "sage" | "almond" | "pink" | "grey" | "yellow" | "cherry" | "indigo" | "cyan" | "success" | "warning" | "info" | null | undefined>;
   /** Chip size, passed to galactik's `tag`. */
-  readonly size: import("@angular/core").InputSignal<"small" | "medium" | "md" | "sm" | "xs" | "xsmall" | null | undefined>;
+  readonly size: import("@angular/core").InputSignal<"small" | "medium" | "sm" | "md" | "xs" | "xsmall" | null | undefined>;
   /** Extra classes for each chip, merged by galactik's `tag`. */
   readonly chipClass: import("@angular/core").InputSignal<string>;
+  /**
+   * How many lines of chips are shown before the rest is folded behind a "show more" button. `0` never folds.
+   *
+   * @default 2
+   */
+  readonly maxLines: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Whether the "clear all" button ends the list of chips (shown from two chips on). Turn it off when the screen has a clear
+   * button of its own.
+   *
+   * @default true
+   */
+  readonly showClearAll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** A chip was removed. */
   readonly removed: import("@angular/core").OutputEmitterRef<AppliedFilterChip>;
   /** Every chip was removed. */
@@ -16362,6 +16441,12 @@ export declare class AppliedFiltersComponent {
   readonly filtersChange: import("@angular/core").OutputEmitterRef<LegacyFilter[]>;
   /** Something changed, whichever way. Re-run the search on this and ignore the rest. */
   readonly changed: import("@angular/core").OutputEmitterRef<void>;
+  constructor();
+  /**
+   * Reads how the chips wrap: the rows are the distinct tops of the chips, so the height of `maxLines` lines is the top of the
+   * next row less the gap, and the whole list is its `scrollHeight`. The chips below the folded height are made `inert`.
+   */
+  private measure;
   /** One chip per applied value, expanded from the stored entries through their leaves. */
   readonly chips: import("@angular/core").Signal<AppliedFilterChip[]>;
   /**
@@ -16410,6 +16495,16 @@ export declare class AppliedFiltersComponent {
       "required": false;
       "isSignal": true;
     };
+    "maxLines": {
+      "alias": "maxLines";
+      "required": false;
+      "isSignal": true;
+    };
+    "showClearAll": {
+      "alias": "showClearAll";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "removed": "removed";
     "cleared": "cleared";
@@ -16569,7 +16664,7 @@ export declare class FilterButtonComponent {
    * @default "sage"
    */
   scheme: import("@angular/core").InputSignal<FilterScheme>;
-  protected variant: import("@angular/core").WritableSignal<"none" | "light-accent" | "accent" | "primary" | "secondary" | "tertiary" | null | undefined>;
+  protected variant: import("@angular/core").WritableSignal<"none" | "primary" | "secondary" | "light-accent" | "accent" | "tertiary" | null | undefined>;
   protected filter: import("@angular/core").WritableSignal<CFilterEx>;
   /** Unique id wiring the trigger's `popovertarget` to the `<div popover>` `id`. */
   protected readonly popoverId: string;
@@ -18686,6 +18781,80 @@ export declare class FiltersBarComponent {
     "onClearBasket": "onClearBasket";
   }, never, ["[filtersBarStart]"], true, never>;
 }
+type FiltersTab = "all" | "quick";
+/**
+ * The filters panel: the facets of the search, and the quick filters of the user, in one card-sized column.
+ *
+ * "All" holds the facets (`<aside-filters>`, driven by the application's filters configuration) with a field that narrows them by
+ * name, the count of documents, and a button that saves the filters applied right now as a quick filter (a card under the button
+ * asks for its name). "Quick Filters" is the list of the `<quick-filters>` pill, inline (`<quick-filters-list>`): one line per quick filter, with the
+ * count of its filters — hovering it shows them as tags — and a cross that deletes it. A click on a quick filter replaces **all** the
+ * applied filters by its own and keeps the rest of the query, the text above all.
+ *
+ * The panel is the content only: it fills the height it is given and scrolls inside. Where it goes — a column next to the results, an
+ * overlay, a sheet — and what surrounds it are the host's. The host closes it on `closed`.
+ *
+ * ```html
+ * <filters-panel [documentCount]="result()?.rowCount ?? 0" (closed)="open.set(false)" />
+ * ```
+ */
+export declare class FiltersPanelComponent {
+  /**
+   * How many documents the search found: the count under the field, which is also what a quick filter would be saved over. The panel
+   * does not run the search, the page does.
+   */
+  readonly documentCount: import("@angular/core").InputSignal<number>;
+  /** The user closes the panel (the cross of its header). Closing is the host's: it decides how the panel is shown. */
+  readonly closed: import("@angular/core").OutputEmitterRef<void>;
+  private readonly appStore;
+  private readonly aggregationsStore;
+  private readonly queryParamsStore;
+  private readonly userSettingsStore;
+  private readonly transloco;
+  private readonly injector;
+  protected readonly nameId: string;
+  protected readonly tab: import("@angular/core").WritableSignal<FiltersTab>;
+  protected readonly query: import("@angular/core").WritableSignal<string>;
+  protected readonly saving: import("@angular/core").WritableSignal<boolean>;
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  protected readonly name: import("@angular/core").WritableSignal<string>;
+  /** How many values the query is filtered by: nothing to save as a quick filter when it is zero. */
+  protected readonly appliedCount: import("@angular/core").Signal<number>;
+  private readonly nameInput;
+  private readonly saveButton;
+  /**
+   * The facets whose name contains the query, as the names `<aside-filters [aggregations]>` takes.
+   * Empty query → the component's own configuration-driven list (the input is left empty).
+   *
+   * An explicit list bypasses the `position` and "hidden" rules of that configuration, so the same two
+   * rules are applied here first.
+   */
+  protected readonly matching: import("@angular/core").Signal<string[]>;
+  protected selectTab(values: readonly string[]): void;
+  /** The leaf filters of an entry, flattening a nested and/or tree. */
+  private leaves;
+  /** How many values a leaf holds: an `in` list holds several, anything else one. */
+  private valuesOf;
+  /** Opens the card under the button and puts the focus in its field: it appears at the user's request, so the next key is the name. */
+  protected startSaving(): void;
+  /** Closes the card without saving, and gives the focus back to the button that opened it. */
+  protected closeSaving(): void;
+  /** Escape closes the card, not the whole filters panel the card is in. */
+  protected onSaveEscape(event: Event): void;
+  protected saveQuickFilter(event: Event): Promise<void>;
+  /** The list applied a quick filter (it replaced the filters of the query by its own): the screen readers are told. */
+  protected onQuickFilterApplied(quickFilter: QuickFilter): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FiltersPanelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FiltersPanelComponent, "filters-panel, FiltersPanel, filterspanel", never, {
+    "documentCount": {
+      "alias": "documentCount";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closed": "closed";
+  }, never, never, true, never>;
+}
 /**
  * Injection token that indicates whether custom date ranges are allowed.
  *
@@ -19412,8 +19581,8 @@ export declare class HistoryPanelComponent {
  * The user's quick filters: named sets of filters that one click applies again. A pill, like the filters of the bar it is
  * meant to sit in front of (the `filtersBarStart` slot of `<filters-bar>`), that opens a popover with a search field and the
  * list. A click on a quick filter **replaces** the active filters by its own and closes the popover, and hovering its count of
- * filters shows what it holds. Quick filters are made, renamed and deleted elsewhere (the filters of the results page): this
- * is only where they are applied.
+ * filters shows what it holds, and the cross at the end of a row deletes it. Quick filters are made elsewhere (the filters of
+ * the results page): this is where they are applied and deleted.
  *
  * They live in the user settings (`UserSettingsStore.quickFilters`), so they follow the user from one page, and one device, to
  * the other.
@@ -19435,9 +19604,6 @@ export declare class QuickFiltersComponent {
   readonly offset: import("@angular/core").InputSignal<number>;
   /** Emitted with the quick filter a click has just applied. */
   readonly applied: import("@angular/core").OutputEmitterRef<QuickFilter>;
-  private readonly userSettingsStore;
-  private readonly queryParamsStore;
-  private readonly appStore;
   private readonly transloco;
   private readonly host;
   protected readonly popoverId: string;
@@ -19450,32 +19616,13 @@ export declare class QuickFiltersComponent {
   protected readonly resized: import("@angular/core").WritableSignal<boolean>;
   private readonly flippedAbove;
   protected readonly placement: import("@angular/core").Signal<Placement>;
-  /** The row whose hover card is showing: its quick filter, and the element the card hangs from. */
-  protected readonly details: import("@angular/core").WritableSignal<{
-    quickFilter: QuickFilter;
-    anchor: HTMLElement;
-  } | null>;
-  private readonly detailsCard;
-  private hideTimer;
   private readonly popover;
   protected readonly isOpen: import("@angular/core").Signal<boolean>;
   constructor();
-  protected readonly variant: import("@angular/core").Signal<"none" | "light-accent" | "accent" | "primary" | "secondary" | "tertiary" | null | undefined>;
+  protected readonly variant: import("@angular/core").Signal<"none" | "primary" | "secondary" | "light-accent" | "accent" | "tertiary" | null | undefined>;
   protected readonly triggerClass: import("@angular/core").Signal<string>;
-  protected readonly quickFilters: import("@angular/core").Signal<QuickFilter[]>;
-  protected readonly query: import("@angular/core").WritableSignal<string>;
-  protected readonly filtered: import("@angular/core").Signal<QuickFilter[]>;
-  /** What was just done, for the screen readers. */
+  /** What was just done, for the screen readers: kept here, as the list goes with the popover once a quick filter is applied. */
   protected readonly announcement: import("@angular/core").WritableSignal<string>;
-  /**
-   * What a quick filter holds, one chip per filter: the icon the application gave the aggregation of the filter in the
-   * "filters" custom JSON (the one its filter button shows) and the value. The icon says what is filtered on, so the name is
-   * left out; an aggregation without an icon keeps it (`Authors: John`), or the value alone would say nothing.
-   */
-  protected chips(quickFilter: QuickFilter): {
-    text: string;
-    icon?: string;
-  }[];
   protected onToggle(): void;
   /**
    * Gives the position back to Floating UI: a top edge that was moved is put back where the placement leaves it, and the
@@ -19484,21 +19631,9 @@ export declare class QuickFiltersComponent {
   private unpin;
   /** The user starts to resize: pins the popover, on the side Floating UI had put it. */
   protected onResizeStart(): void;
-  /** Shows what a quick filter holds, under its row. */
-  protected showDetails(quickFilter: QuickFilter, event: Event): void;
-  /** Hides the card a moment later, so the pointer can cross from the row to the card. */
-  protected scheduleHideDetails(): void;
-  protected cancelHideDetails(): void;
-  protected hideDetails(): void;
-  /** The popover is closed with nothing half done: no search, no name being typed. */
-  private reset;
   /** Closes the popover when the focus leaves the whole component. `null` (focus left the document) leaves it open. */
   protected closeOnFocusLeave(event: FocusEvent): void;
-  /** What the list holds as selected: nothing, ever — choosing a row applies it and the list starts again. */
-  protected readonly picked: import("@angular/core").WritableSignal<QuickFilter[]>;
-  /** A row was chosen in the list. */
-  protected pick(values: readonly QuickFilter[]): void;
-  /** A click on a quick filter: its filters replace the active ones. */
+  /** The list applied a quick filter: the popover closes, and the page is told. */
   protected apply(quickFilter: QuickFilter): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<QuickFiltersComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<QuickFiltersComponent, "QuickFilters, quick-filters", never, {
@@ -19526,16 +19661,187 @@ export declare class QuickFiltersComponent {
     "applied": "applied";
   }, never, never, true, never>;
 }
-/** Order of the categories of the suggestions, first to last. */
-export declare const SEARCH_BOX_CATEGORIES_SORT: InjectionToken<string[]>;
-/** The icon of each category of suggestion. */
-export declare const SEARCH_BOX_CATEGORY_ICONS: InjectionToken<Record<string, Type<unknown>>>;
-type Suggestion$1 = Partial<Suggestion> & {
+/**
+ * The list of the user's quick filters, to be placed where the host wants it: inline (a tab of the filters panel) or in a popover
+ * (the `<quick-filters>` pill). It is the content only; the host owns the container, and what happens once a quick filter is applied.
+ *
+ * One row per quick filter: its name and, under it, the count of its filters — hovering that line (or focusing the row) shows them as
+ * chips in a card, whose cut-off texts get a tooltip. A click on a row **replaces** the active filters by its own (the rest of the query stays, the text above all) and the host
+ * is told with `applied`. The cross at the end of the row (or `Del` when the row has the focus) deletes the quick filter from the
+ * user's settings. Quick filters are made elsewhere: where the filters are saved as one.
+ *
+ * ```html
+ * <quick-filters-list [searchable]="true" (applied)="popover.close()" />
+ * ```
+ */
+export declare class QuickFiltersListComponent {
+  /** Shows a field that narrows the list by name. It only appears once there is something to narrow. */
+  readonly searchable: import("@angular/core").InputSignal<boolean>;
+  /** Shows the cross that deletes a quick filter, and lets `Del` do the same. */
+  readonly deletable: import("@angular/core").InputSignal<boolean>;
+  /** What the empty state says under its title, when the default does not fit where the list is. */
+  readonly emptyHint: import("@angular/core").InputSignal<string | undefined>;
+  /** Emitted with the quick filter a click has just applied: the host decides what follows (close a popover…). */
+  readonly applied: import("@angular/core").OutputEmitterRef<QuickFilter>;
+  /** Emitted with the quick filter that has just been deleted. */
+  readonly deleted: import("@angular/core").OutputEmitterRef<QuickFilter>;
+  private readonly userSettingsStore;
+  private readonly queryParamsStore;
+  private readonly appStore;
+  private readonly transloco;
+  private readonly host;
+  private readonly injector;
+  protected readonly deleteKeys: string[];
+  protected readonly quickFilters: import("@angular/core").Signal<QuickFilter[]>;
+  protected readonly query: import("@angular/core").WritableSignal<string>;
+  protected readonly filtered: import("@angular/core").Signal<QuickFilter[]>;
+  /** What was just done, for the screen readers. */
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  /** The row whose hover card is showing: its quick filter, and the element the card hangs from. */
+  protected readonly details: import("@angular/core").WritableSignal<{
+    quickFilter: QuickFilter;
+    anchor: HTMLElement;
+  } | null>;
+  private readonly detailsCard;
+  private hideTimer;
+  private readonly deleting;
+  constructor();
+  /**
+   * What a quick filter holds, one chip per filter: the icon the application gave the aggregation of the filter in the
+   * "filters" custom JSON (the one its filter button shows) and the value. The icon says what is filtered on, so the name is
+   * left out; an aggregation without an icon keeps it (`Authors: John`), or the value alone would say nothing.
+   */
+  protected chips(quickFilter: QuickFilter): {
+    text: string;
+    icon?: string;
+  }[];
+  /** Shows what a quick filter holds, under the line of its count of filters. */
+  protected showDetails(quickFilter: QuickFilter, anchor: HTMLElement): void;
+  /** Hides the card a moment later, so the pointer can cross from the row to the card. */
+  protected scheduleHideDetails(): void;
+  protected cancelHideDetails(): void;
+  /** Escape takes the card away first (WCAG 1.4.13); only a second one reaches what the list is in (a panel, a popover). */
+  protected onEscape(event: Event): void;
+  /** What the list holds as selected: nothing, ever — choosing a row applies it and the list starts again. */
+  protected readonly picked: import("@angular/core").WritableSignal<QuickFilter[]>;
+  /** A row was chosen in the list. */
+  protected pick(values: readonly QuickFilter[]): void;
+  /**
+   * A click on a quick filter: its filters replace ALL the applied ones — the whole `filters` of the query, not a merge with them.
+   * Everything else the query holds stays, the text above all: `patch` only writes what it is given.
+   */
+  private apply;
+  /**
+   * Deletes a quick filter from the user's settings. The toast says it is done. A deleted row leaves the DOM with the focus: when the
+   * focus was in the list it goes to the row that took its place, or to the list itself when it was the last, so it is never dropped
+   * on the page.
+   */
+  protected remove(quickFilter: QuickFilter, index: number, event: Event): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<QuickFiltersListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<QuickFiltersListComponent, "QuickFiltersList, quick-filters-list", never, {
+    "searchable": {
+      "alias": "searchable";
+      "required": false;
+      "isSignal": true;
+    };
+    "deletable": {
+      "alias": "deletable";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyHint": {
+      "alias": "emptyHint";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "applied": "applied";
+    "deleted": "deleted";
+  }, never, never, true, never>;
+}
+/** A row of the suggestions popup: what the suggest queries return, or a title row ahead of a category. */
+export type SearchBoxSuggestion = Partial<Suggestion> & {
   $isDivider?: boolean;
   $isTitle?: boolean;
   /** The translated title of the category, on a title row. */
   $label?: string;
 };
+/**
+ * Where the suggestions come from, in place of the application's suggest queries. Receives the text of the field once it
+ * has settled (empty on an empty field) and returns the rows to show, in their final order: nothing is grouped or titled for it.
+ */
+export type SearchBoxSuggestionsProvider = (text: string) => SearchBoxSuggestion[] | Promise<SearchBoxSuggestion[]>;
+/**
+ * What `SearchBox` hands to a `searchBoxPopup` template. A single object, the same for the life of the component: the values
+ * that change are signals.
+ */
+export interface SearchBoxPopupContext {
+  /** The text the suggestions are fetched for: the text of the field, once it has settled. */
+  readonly text: Signal<string>;
+  /** The text as it is in the field, before the debounce. */
+  readonly typed: Signal<string>;
+  /** The suggestions for `text`. While a new list loads, the previous one stays. */
+  readonly suggestions: Signal<SearchBoxSuggestion[]>;
+  /** Whether a list of suggestions is being fetched. */
+  readonly loading: Signal<boolean>;
+  /** The searches the user has saved. */
+  readonly savedSearches: Signal<SearchItem[]>;
+  /** Whether the user pressed an arrow key since the last typed character (a preview is only for the keyboard). */
+  readonly navigatedSinceTyping: Signal<boolean>;
+  /** Writes `text` in the field, closes the popup and runs the search. */
+  commit(text: string): void;
+  /** Shows `text` in the field without fetching the suggestions again: the URL-bar preview of the active row. */
+  preview(text: string): void;
+  /** Runs a saved search as it was saved (text, filters, tab) and closes the popup. */
+  openSaved(saved: SearchItem): void;
+  /** Whether `text` is one of the saved searches. */
+  isSaved(text: string): boolean;
+  /** Saves `text`, or removes it from the saved searches. Never runs it. */
+  toggleSaved(text: string): void;
+  /** Closes the popup. */
+  collapse(): void;
+  /** Gives the focus back to the field, where the user is typing. */
+  focusField(): void;
+}
+/**
+ * Replaces what the popup of a `SearchBox` shows (the tabs and their list) with the application's own template. The popup
+ * itself — its placement, its `card` / `inline` look, its opening — stays the search box's.
+ *
+ * With `popupFitScreen` on the search box, the popup is capped by the room the screen leaves on the side it opens
+ * (`max-height`): give the template's own list `min-h-0` and let it scroll, rather than a fixed height that would run off the screen.
+ *
+ * The template must carry the combobox widget itself: an `ngComboboxWidget` + `ngListbox` element with
+ * `focusMode="activedescendant"`, so that the field keeps being announced as a combobox. The list is in the application's view, so the
+ * search box does not drive it, apart from scrolling the active option into view while the arrows walk it. Call
+ * `ctx.preview()` on `(valueChange)` while the keyboard navigates, and `ctx.commit()` on a click.
+ *
+ * ```html
+ * <search-box>
+ *   <ng-template searchBoxPopup let-ctx>
+ *     <ul ngComboboxWidget ngListbox #lb="ngListbox" focusMode="activedescendant" [activeDescendant]="lb.activeDescendant()">
+ *       @for (s of ctx.suggestions(); track $index) {
+ *         <li ngOption [value]="s" [label]="s.display ?? ''" (click)="ctx.commit(s.display ?? '')">{{ s.display }}</li>
+ *       }
+ *     </ul>
+ *   </ng-template>
+ * </search-box>
+ * ```
+ */
+export declare class SearchBoxPopupDirective {
+  readonly template: TemplateRef<{
+    $implicit: SearchBoxPopupContext;
+  }>;
+  static ngTemplateContextGuard(_dir: SearchBoxPopupDirective, _ctx: unknown): _ctx is {
+    $implicit: SearchBoxPopupContext;
+  };
+  static ɵfac: i0.ɵɵFactoryDeclaration<SearchBoxPopupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SearchBoxPopupDirective, "ng-template[searchBoxPopup]", never, {}, {}, never, never, true, never>;
+}
+/** Order of the categories of the suggestions, first to last. */
+export declare const SEARCH_BOX_CATEGORIES_SORT: InjectionToken<string[]>;
+/** The icon of each category of suggestion. */
+export declare const SEARCH_BOX_CATEGORY_ICONS: InjectionToken<Record<string, Type<unknown>>>;
+type Suggestion$1 = SearchBoxSuggestion;
 /** Which list the popup shows. */
 export type SearchBoxTab = "suggestions" | "saved";
 /**
@@ -19580,8 +19886,30 @@ export declare class SearchBoxComponent {
   readonly popup: import("@angular/core").InputSignal<"card" | "inline">;
   /** Distance, in pixels, between the field and the `card` popup. The card is placed with Floating UI, like the other popups. */
   readonly popupOffset: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Makes the popup fit the screen, like the facet popovers: its height is capped by the room left on the side it opens, its
+   * list scrolling inside (see `popupFlip` for the side). On by default for the `hero` size with an `inline` popup (a home page), off
+   * otherwise: the `card` then keeps its fixed list height, and the `inline` popup stays in the flow under the field, with no Floating UI
+   * at all (so no `popupFlip` either). Give it explicitly (`[popupFitScreen]="false"`) to override the default.
+   */
+  readonly popupFitScreen: import("@angular/core").InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+  /**
+   * Whether the popup goes above the field when there is no room under it. On by default, as the `card` always did, except for the
+   * `hero` size, where it is off. Off keeps the popup under the field: with `popupFitScreen`, its height then shrinks down to the
+   * edge of the screen instead.
+   * Ignored by an `inline` popup that is not `popupFitScreen`: it is in the flow and never flips.
+   */
+  readonly popupFlip: import("@angular/core").InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
   /** Replaces the translated placeholder. */
   readonly placeholderOverride: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Where the suggestions come from, in place of the application's suggest queries (and the user's recent searches, saved
+   * searches and bookmarks). Called with the text of the field once it has settled; the rows it returns are shown as they are,
+   * without categories or titles added. A rejected promise leaves an empty list.
+   */
+  readonly suggestionsProvider: import("@angular/core").InputSignal<SearchBoxSuggestionsProvider | undefined>;
+  /** The application's own popup content (`<ng-template searchBoxPopup>`), if any: it replaces the tabs and their lists. */
+  private readonly customPopup;
   /** Emitted with the text each time the user validates a search (Enter, the send button, a picked suggestion). */
   readonly searched: import("@angular/core").OutputEmitterRef<string>;
   /** Emitted once the text typed has settled (300ms), which is when the suggestions are fetched. */
@@ -20134,6 +20462,12 @@ export declare class SearchBoxComponent {
   protected readonly savedSearches: import("@angular/core").Signal<SearchItem[]>;
   private readonly savedTexts;
   private readonly inline;
+  /** Whether Floating UI places the popup: always the card, the inline block only when it must fit the screen. */
+  /** `popupFitScreen` as given, or its default: on for the `hero` size with an `inline` popup, off otherwise. */
+  private readonly fitScreen;
+  /** `popupFlip` as given, or its default: off for the `hero` size (the popup stays under the field and shrinks), on otherwise. */
+  private readonly flip;
+  private readonly floating;
   /** The bar keeps the room of its own padding on the `hero` size, whose send button sets it. */
   protected readonly barClass: import("@angular/core").Signal<"w-full" | "w-full gap-(--spacing-3xs)! pe-(--spacing-3xs)">;
   protected readonly popupClass: import("@angular/core").Signal<string>;
@@ -20153,7 +20487,11 @@ export declare class SearchBoxComponent {
   /** The suggestions: what the suggest queries return, with the user's recent searches, saved searches and bookmarks. */
   private readonly suggestionsResource;
   private previousSuggestions;
-  protected readonly suggestions: import("@angular/core").Signal<Suggestion$1[]>;
+  protected readonly suggestions: import("@angular/core").Signal<SearchBoxSuggestion[]>;
+  /** What a `searchBoxPopup` template receives: one object for the life of the component, whose changing values are signals. */
+  protected readonly popupTemplateContext: {
+    $implicit: SearchBoxPopupContext;
+  };
   private inputListenersAttached;
   constructor();
   /**
@@ -20167,6 +20505,8 @@ export declare class SearchBoxComponent {
    * leaves the popup alone, so an alt-tab does not discard what the user was reading.
    */
   protected collapseOnFocusLeave(event: FocusEvent): void;
+  /** Scrolls the option the field names as active (`aria-activedescendant`) into view, so a truncated row never stays cut. */
+  private revealActiveOption;
   /** Collapses the suggestions popup. */
   collapse(): void;
   /**
@@ -20192,6 +20532,8 @@ export declare class SearchBoxComponent {
   protected focusField(): void;
   /** Commits a clicked suggestion: writes it into the field and runs the search. */
   protected commitSuggestion(suggestion: Suggestion$1, event: Event): void;
+  /** Writes a text into the field, closes the popup and runs the search (the text searched may differ from the one shown, see `data-text`). */
+  private commitText;
   /**
    * Runs a saved search as it was saved: its text, its filters and its tab, not only its text. The popup closes first,
    * since the page it leads to replaces what sits under it.
@@ -20244,6 +20586,8 @@ export declare class SearchBoxComponent {
   protected getIconForCategory(category: string | undefined): Type<unknown>;
   /** The title of a category: the library's own string, then an application key of the same name, then the category itself. */
   private categoryLabel;
+  /** The suggestions of the application's own provider. A failure is logged and leaves an empty list. */
+  private fetchFromProvider;
   /**
    * Fetches the suggestions for a text: the user's own (recent and saved searches, bookmarks) with the suggest queries of
    * the application, ordered by category, with a title row ahead of each category.
@@ -20278,11 +20622,26 @@ export declare class SearchBoxComponent {
       "required": false;
       "isSignal": true;
     };
+    "popupFitScreen": {
+      "alias": "popupFitScreen";
+      "required": false;
+      "isSignal": true;
+    };
+    "popupFlip": {
+      "alias": "popupFlip";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholderOverride": {
       "alias": "placeholder";
       "required": false;
       "isSignal": true;
     };
+    "suggestionsProvider": {
+      "alias": "suggestionsProvider";
+      "required": false;
+      "isSignal": true;
+    };
     "searchInputText": {
       "alias": "searchInputText";
       "required": false;
@@ -20294,7 +20653,7 @@ export declare class SearchBoxComponent {
     "saved": "saved";
     "expandedChange": "expandedChange";
     "searchInputText": "searchInputTextChange";
-  }, never, ["[slot='trailing']"], true, never>;
+  }, ["customPopup"], ["[slot='trailing']"], true, never>;
 }
 export declare const RECENT_SEARCHES_OPTIONS: {
   itemsPerPage: number;
@@ -22016,6 +22375,22 @@ export declare class FileSizePipe implements PipeTransform {
   static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
   static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", true>;
 }
+/**
+ * Writes a number the way the interface language does: `1,060` in English, `1 060` in French, `1.060` in German.
+ *
+ * Not Angular's `number` pipe: that one follows `LOCALE_ID`, which an application fixes once for good, so it would keep grouping
+ * digits the same way in another language. The language here is the one transloco holds, read as a signal so a template using the
+ * pipe updates by itself when the user changes it (the pipe stays pure).
+ *
+ * `null` and `undefined` are written as `0`.
+ */
+export declare class LocalizedNumberPipe implements PipeTransform {
+  private readonly transloco;
+  private readonly lang;
+  transform(value: number | null | undefined): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedNumberPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedNumberPipe, "localizedNumber", true>;
+}
 /**
  * The `@sinequa/atomic` client the surrounding injector works with.
  *