@mintplayer/ng-spark 22.22.0 → 22.24.0

package/types/mintplayer-ng-spark-grid.d.ts

@@ -1,15 +1,14 @@
-import { DatatableSettings, BsDatatableFetch, DatatableDistincts, FilterChangeDetail } from '@mintplayer/ng-bootstrap/datatable';
-import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { SparkQuery, EntityType, EntityAttributeDefinition, SparkCellColumn, QueryResultItem, QueryColumn, LookupReference, CustomActionDefinition, PersistentObject } from '@mintplayer/ng-spark/models';
-import * as _angular_core from '@angular/core';
-import { Type, TemplateRef } from '@angular/core';
-import { HttpErrorResponse } from '@angular/common/http';
-import { Color } from '@mintplayer/ng-bootstrap';
-import { SparkLanguageService } from '@mintplayer/ng-spark/services';
-import { ReferenceChip } from '@mintplayer/ng-spark/pipes';
-
+import { BsDatatableFetch, BsDatatableRowEvent, DatatableDistincts, DatatableSettings, FilterChangeDetail } from "@mintplayer/ng-bootstrap/datatable";
+import { CustomActionDefinition, EntityAttributeDefinition, EntityPermissions, EntityType, LookupReference, PersistentObject, QueryColumn, QueryResultItem, SparkCellColumn, SparkDeletedFilter, SparkQuery, SparkSelectionModeSetting } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
+import { TemplateRef, Type } from "@angular/core";
+import { HttpErrorResponse } from "@angular/common/http";
+import { Color } from "@mintplayer/ng-bootstrap";
+import { ConnectedPosition } from "@angular/cdk/overlay";
+import { SparkLanguageService } from "@mintplayer/ng-spark/services";
+import { ReferenceChip } from "@mintplayer/ng-spark/pipes";
 /** Page sizes offered by every Spark grid. */
-declare const SPARK_GRID_PAGE_SIZES: number[];
+export declare const SPARK_GRID_PAGE_SIZES: number[];
 /**
  * The attributes a grid shows, in display order.
  *
@@ -17,17 +16,16 @@ declare const SPARK_GRID_PAGE_SIZES: number[];
  * copy of this expression, which is the kind of thing that stays identical right up until it
  * doesn't.
  */
-declare function visibleGridAttributes(entityType: EntityType | null): EntityAttributeDefinition[];
+export declare function visibleGridAttributes(entityType: EntityType | null): EntityAttributeDefinition[];
 /**
  * Initial datatable settings for a query, seeded with the query's declared sort.
  *
  * The datatable owns paging and sorting from here on and calls the fetch callback per page; this
  * only decides where it starts.
  */
-declare function initialGridSettings(query: SparkQuery | null): DatatableSettings;
+export declare function initialGridSettings(query: SparkQuery | null): DatatableSettings;
 /** Whether a query renders as a virtual-scrolling grid rather than a paged one. */
-declare function isVirtualScrollingQuery(query: SparkQuery | null): boolean;
-
+export declare function isVirtualScrollingQuery(query: SparkQuery | null): boolean;
 /**
  * Renderer lookup and lookup-reference loading for a Spark grid.
  *
@@ -41,38 +39,37 @@ declare function isVirtualScrollingQuery(query: SparkQuery | null): boolean;
  * separate because it is stateless service-shaped logic rather than view state, and because it is
  * what a custom grid would need in order to render Spark cells at all.
  */
-declare class SparkGridRenderers {
-    private readonly registry;
-    private readonly sparkService;
-    /** The registered column component for a column, or null to fall back to the default cell. */
-    columnComponentFor(column: SparkCellColumn): Type<any> | null;
-    /** The registered filter-label function for a column, or null to use the server-computed text. */
-    filterLabelFor(column: SparkCellColumn): ((value: unknown) => string) | null;
-    /**
-     * Inputs for a query-grid cell renderer, filtered to what the component actually declares —
-     * `NgComponentOutlet` throws on an input the target does not have, which is what lets every
-     * member of the renderer contract be optional.
-     */
-    columnInputsFor(component: Type<any>, item: QueryResultItem, column: QueryColumn): Record<string, any>;
-    /**
-     * The same contract for a row that is not a query result — an AsDetail sub-table row, which is
-     * a plain dictionary of embedded values with no id and no column metadata of its own, so its
-     * value cannot be read the way {@link columnInputsFor} reads one.
-     *
-     * Only the extraction differs; the renderer contract is identical, and stating it once is what
-     * stops the two from drifting the way the cell markup already had.
-     */
-    cellInputsFor(component: Type<any>, value: unknown, column: SparkCellColumn, item: unknown): Record<string, any>;
-    /**
-     * Loads every lookup reference the visible columns need, in one pass.
-     *
-     * Returns an empty map rather than throwing when there are none, so callers never branch on it.
-     */
-    loadLookupOptions(columns: readonly (SparkCellColumn | EntityAttributeDefinition)[]): Promise<Record<string, LookupReference>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkGridRenderers, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SparkGridRenderers>;
+export declare class SparkGridRenderers {
+  private readonly registry;
+  private readonly sparkService;
+  /** The registered column component for a column, or null to fall back to the default cell. */
+  columnComponentFor(column: SparkCellColumn): Type<any> | null;
+  /** The registered filter-label function for a column, or null to use the server-computed text. */
+  filterLabelFor(column: SparkCellColumn): ((value: unknown) => string) | null;
+  /**
+   * Inputs for a query-grid cell renderer, filtered to what the component actually declares —
+   * `NgComponentOutlet` throws on an input the target does not have, which is what lets every
+   * member of the renderer contract be optional.
+   */
+  columnInputsFor(component: Type<any>, item: QueryResultItem, column: QueryColumn): Record<string, any>;
+  /**
+   * The same contract for a row that is not a query result — an AsDetail sub-table row, which is
+   * a plain dictionary of embedded values with no id and no column metadata of its own, so its
+   * value cannot be read the way {@link columnInputsFor} reads one.
+   *
+   * Only the extraction differs; the renderer contract is identical, and stating it once is what
+   * stops the two from drifting the way the cell markup already had.
+   */
+  cellInputsFor(component: Type<any>, value: unknown, column: SparkCellColumn, item: unknown): Record<string, any>;
+  /**
+   * Loads every lookup reference the visible columns need, in one pass.
+   *
+   * Returns an empty map rather than throwing when there are none, so callers never branch on it.
+   */
+  loadLookupOptions(columns: readonly (SparkCellColumn | EntityAttributeDefinition)[]): Promise<Record<string, LookupReference>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkGridRenderers, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-
 /**
  * Header slots for `<spark-query-card>`.
  *
@@ -113,8 +110,8 @@ declare class SparkGridRenderers {
  * `contentChildren`.
  */
 /** Resolves a slot list to the one that applies to a query: targeted first, then untargeted. */
-declare function slotFor<T extends {
-    forQuery: () => string;
+export declare function slotFor<T extends {
+  forQuery: () => string;
 }>(slots: readonly T[], query: SparkQuery | null): T | null;
 /**
  * The icon at the header's leading edge. No default: nothing in the model describes one.
@@ -125,13 +122,19 @@ declare function slotFor<T extends {
  * </spark-query-card>
  * ```
  */
-declare class SparkQueryIconDirective {
-    readonly templateRef: TemplateRef<SparkQuerySlotContext>;
-    /** Query alias or id this slot applies to. Empty targets every query on the page. */
-    readonly forQuery: _angular_core.InputSignal<string>;
-    static ngTemplateContextGuard(_dir: SparkQueryIconDirective, ctx: unknown): ctx is SparkQuerySlotContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryIconDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SparkQueryIconDirective, "[sparkQueryIcon]", never, { "forQuery": { "alias": "sparkQueryIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class SparkQueryIconDirective {
+  readonly templateRef: TemplateRef<SparkQuerySlotContext>;
+  /** Query alias or id this slot applies to. Empty targets every query on the page. */
+  readonly forQuery: import("@angular/core").InputSignal<string>;
+  static ngTemplateContextGuard(_dir: SparkQueryIconDirective, ctx: unknown): ctx is SparkQuerySlotContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryIconDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SparkQueryIconDirective, "[sparkQueryIcon]", never, {
+    "forQuery": {
+      "alias": "sparkQueryIcon";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /**
  * The header caption. Defaults to the query's translated description, falling back to its name.
@@ -139,12 +142,18 @@ declare class SparkQueryIconDirective {
  * The context carries that resolved default as `$implicit`, so a host can decorate it — add a
  * count, a badge — without re-resolving the translation itself.
  */
-declare class SparkQueryCaptionDirective {
-    readonly templateRef: TemplateRef<SparkQueryCaptionContext>;
-    readonly forQuery: _angular_core.InputSignal<string>;
-    static ngTemplateContextGuard(_dir: SparkQueryCaptionDirective, ctx: unknown): ctx is SparkQueryCaptionContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryCaptionDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SparkQueryCaptionDirective, "[sparkQueryCaption]", never, { "forQuery": { "alias": "sparkQueryCaption"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class SparkQueryCaptionDirective {
+  readonly templateRef: TemplateRef<SparkQueryCaptionContext>;
+  readonly forQuery: import("@angular/core").InputSignal<string>;
+  static ngTemplateContextGuard(_dir: SparkQueryCaptionDirective, ctx: unknown): ctx is SparkQueryCaptionContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryCaptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SparkQueryCaptionDirective, "[sparkQueryCaption]", never, {
+    "forQuery": {
+      "alias": "sparkQueryCaption";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /**
  * The buttons at the header's trailing edge. Defaults to the server-declared custom actions.
@@ -160,30 +169,57 @@ declare class SparkQueryCaptionDirective {
  * </ng-container>
  * ```
  */
-declare class SparkQueryActionsDirective {
-    readonly templateRef: TemplateRef<SparkQueryActionsContext>;
-    readonly forQuery: _angular_core.InputSignal<string>;
-    static ngTemplateContextGuard(_dir: SparkQueryActionsDirective, ctx: unknown): ctx is SparkQueryActionsContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryActionsDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SparkQueryActionsDirective, "[sparkQueryActions]", never, { "forQuery": { "alias": "sparkQueryActions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class SparkQueryActionsDirective {
+  readonly templateRef: TemplateRef<SparkQueryActionsContext>;
+  readonly forQuery: import("@angular/core").InputSignal<string>;
+  static ngTemplateContextGuard(_dir: SparkQueryActionsDirective, ctx: unknown): ctx is SparkQueryActionsContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryActionsDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SparkQueryActionsDirective, "[sparkQueryActions]", never, {
+    "forQuery": {
+      "alias": "sparkQueryActions";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /** Context for the icon slot: the query whose card is being rendered. */
-declare class SparkQuerySlotContext {
-    $implicit: SparkQuery | null;
+export declare class SparkQuerySlotContext {
+  $implicit: SparkQuery | null;
 }
-declare class SparkQueryCaptionContext {
-    /** The caption the card would have rendered: description, or the query name. */
-    $implicit: string;
-    query: SparkQuery | null;
+export declare class SparkQueryCaptionContext {
+  /** The caption the card would have rendered: description, or the query name. */
+  $implicit: string;
+  query: SparkQuery | null;
 }
-declare class SparkQueryActionsContext {
-    /** The custom actions the card would have rendered, already filtered for this query. */
-    $implicit: CustomActionDefinition[];
-    /** Rows currently ticked. Empty unless an action is selection-gated. */
-    selection: PersistentObject[];
-    query: SparkQuery | null;
+export declare class SparkQueryActionsContext {
+  /** The custom actions the card would have rendered, already filtered for this query. */
+  $implicit: CustomActionDefinition[];
+  /** Rows currently ticked. Empty unless an action is selection-gated. */
+  selection: PersistentObject[];
+  query: SparkQuery | null;
 }
-
+/**
+ * One button of a query's toolbar (#460, M15): the built-in New or Delete, or a custom action.
+ *
+ * Built by `SparkQueryGridComponent.toolbarActions()` and rendered by every host of the grid — the
+ * query card's header and the query-list page's action bar — so both surfaces offer the same
+ * actions, enabled by the same rules.
+ */
+export interface SparkQueryToolbarAction {
+  kind: 'new' | 'delete' | 'custom';
+  /** The action's name, unique within the toolbar. */
+  name: string;
+  /** Its catalogue entry: label, icon, `selectionRule`, `variant`, confirmation. */
+  definition: CustomActionDefinition;
+  /** `*bsPriorityNavItem` priority: New first, then Delete, then custom actions by offset. */
+  priority: number;
+}
+/**
+ * The button classes for an action's `variant`: an allow-list, so a typo cannot inject a class, and
+ * the neutral outline default for anything else. Shared by the detail page, the query card and the
+ * query-list page.
+ */
+export declare function sparkActionClass(definition: CustomActionDefinition, size?: 'sm'): string;
 /**
  * The one Spark grid: a `<bs-datatable>` rendering a query or a sub-query.
  *
@@ -213,273 +249,482 @@ declare class SparkQueryActionsContext {
  * reference variable — `<spark-query-grid #grid>` … `grid.query()` — not `viewChild`: hosts wrap
  * grids in `@if`, where a `viewChild` is intermittently undefined.
  */
-declare class SparkQueryGridComponent {
-    private readonly sparkService;
-    private readonly gridRenderers;
-    private readonly queryRefresh;
-    readonly lang: SparkLanguageService;
-    /** Query alias or id. */
-    queryId: _angular_core.InputSignal<string>;
-    /**
-     * The parent persistent object this query is scoped to, when it has one.
-     *
-     * Optional, because not every query is a detail of something: a page can host a grid that
-     * stands on its own — "my accounts", a dashboard list — and the server already treats an absent
-     * parent as "no parent" rather than as an error. Requiring these made that shape impossible to
-     * express: the component simply never loaded, with no request, no error and no log.
-     *
-     * Pass both or neither. One without the other is ignored, matching `SparkService.executeQuery`,
-     * which omits either param when it is falsy, and the execute endpoint, which resolves a parent
-     * only when both are present.
-     */
-    parentId: _angular_core.InputSignal<string>;
-    parentType: _angular_core.InputSignal<string>;
-    /**
-     * Rows supplied from outside. When bound, the grid renders these and runs no fetch.
-     *
-     * This is how streaming stays out of this component (see the class comment). `null` — the
-     * default — means "fetch for yourself"; an empty array means "you have been given no rows",
-     * which is a different statement and renders an empty grid rather than triggering a load.
-     */
-    data: _angular_core.InputSignal<QueryResultItem[] | null>;
-    /**
-     * Server-side search term, passed through to the query.
-     *
-     * An input rather than a box, so the host owns the control and the grid owns the request. A
-     * host with client-side rows filters them itself before binding `data`.
-     */
-    search: _angular_core.InputSignal<string>;
-    /**
-     * Column metadata for externally supplied rows. Required whenever `data` is bound, because a
-     * projection cannot describe itself — there is no per-row metadata left to infer it from.
-     */
-    columns: _angular_core.InputSignal<QueryColumn[] | null>;
-    /**
-     * Change this to re-run the query. Any value works; only its identity matters.
-     *
-     * A declarative token rather than only a `reload()` method, because calling a method means
-     * holding a component handle, and hosts wrap this grid in `@if`, where a `viewChild` is
-     * intermittently undefined.
-     *
-     * This drives the CHEAP refresh (see {@link reload}). It deliberately does not feed the main
-     * effect: re-running `loadData` would re-resolve the query, the entity types, the permissions
-     * and the lookups, and reset the user's page and sort on every button press.
-     */
-    reloadToken: _angular_core.InputSignal<unknown>;
-    /**
-     * Paging and sorting. Two-way, so a host driving `data` can sort those rows by whatever the
-     * user actually clicked — the datatable writes the new sort back through here.
-     */
-    settings: _angular_core.ModelSignal<DatatableSettings>;
-    /** Rows the user has ticked. Two-way so chrome outside the grid can read and clear them. */
-    selection: _angular_core.ModelSignal<QueryResultItem[]>;
-    /**
-     * Replaces where the first column's link points, per row.
-     *
-     * Return `null` to suppress the link for that row — useful when a grid mixes rows that have a
-     * detail page with rows that do not.
-     *
-     * ⚠️ **It changes the destination, not the permission.** `canRead()` still gates whether any
-     * link is rendered at all, and this function is never consulted when that gate is closed. It
-     * cannot be used to reach a row the rights model withheld; it exists for the case where the
-     * row's natural destination is not `/po/{type}/{id}` — a composed row that maps to a page of
-     * its own, or a grid embedded in a route that owns its own child paths.
-     */
-    rowRoute: _angular_core.InputSignal<((row: QueryResultItem) => unknown[] | null) | null>;
-    /** Emitted whenever a load or a page fetch fails, for a host in bespoke chrome. */
-    error: _angular_core.OutputEmitterRef<HttpErrorResponse>;
-    rowClicked: _angular_core.OutputEmitterRef<QueryResultItem>;
-    customActionExecuted: _angular_core.OutputEmitterRef<{
-        action: CustomActionDefinition;
-    }>;
-    colors: typeof Color;
-    /**
-     * Where the first column's link points for this row: the host's `rowRoute` when it supplied one,
-     * otherwise the row's own detail page.
-     *
-     * A method rather than a computed because the answer is per row, and the template already
-     * iterates rows — a computed would have to be a map keyed by id, rebuilt on every page.
-     */
-    protected rowRouteFor(row: QueryResultItem): unknown[] | null;
-    query: _angular_core.WritableSignal<SparkQuery | null>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    loading: _angular_core.WritableSignal<boolean>;
-    canRead: _angular_core.WritableSignal<boolean>;
-    canCreate: _angular_core.WritableSignal<boolean>;
-    resultCount: _angular_core.WritableSignal<number | null>;
-    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
-    /** Names the server withheld for this RESULT; see QueryResult.disabledActions. */
-    private readonly disabledActions;
-    /**
-     * The actions actually offered for this result.
-     *
-     * The catalogue at `/spark/actions/{objectTypeId}` is per TYPE and is never told what an
-     * execution returned, so an action that applies to only some results cannot be filtered there.
-     * A custom query withholds what does not apply via `CustomQueryArgs.DisableActions(...)`, and
-     * the answer arrives on the result.
-     *
-     * An affordance, not a permission -- the action handler still refuses on its own terms.
-     */
-    visibleCustomActions: _angular_core.Signal<CustomActionDefinition[]>;
-    fetchFn: _angular_core.WritableSignal<BsDatatableFetch<QueryResultItem> | null>;
-    /**
-     * Why the component renders its own failure instead of only reporting one.
-     *
-     * `SparkService` is a bare `firstValueFrom` passthrough with no interceptor, so every failure
-     * surfaces here and nowhere else. A host embedding this grid cannot surface what it never sees,
-     * and the default has to be visible with no host cooperation — hence a rendered alert, not just
-     * an output.
-     */
-    errorMessage: _angular_core.WritableSignal<string | null>;
-    /** 'none' unless an action is selection-gated, so unaffected grids gain no checkbox column. */
-    selectionMode: _angular_core.Signal<_mintplayer_ng_spark_models.SparkSelectionMode>;
-    isVirtualScrolling: _angular_core.Signal<boolean>;
-    /**
-     * Columns as sent with the most recent fetched page.
-     *
-     * A host binding `data` (streaming) supplies its own via the `columns` input instead — the
-     * snapshot carries them once, exactly as a paged result does.
-     */
-    private readonly fetchedColumns;
-    /** Every column on the wire, drawn or not — what renderers and lookups resolve against. */
-    allColumns: _angular_core.Signal<QueryColumn[]>;
-    /**
-     * The columns the grid draws. `isVisible: false` ships a value without a column, so a renderer
-     * can read a sibling the grid does not show; undefined means visible, so a server that predates
-     * the field still draws everything.
-     */
-    visibleColumns: _angular_core.Signal<QueryColumn[]>;
-    /**
-     * True when rows do not come from this component's own fetch.
-     *
-     * Either because the host bound `data`, or because the query streams — a streaming query's rows
-     * arrive over a socket and `/execute` is not a way to get them. The grid recognises the second
-     * case itself rather than waiting to be told, because it resolves the query before the host can
-     * see it: left to `data` alone, every streaming grid would fire one pointless fetch on mount,
-     * before the host had anything to bind.
-     */
-    hasExternalData: _angular_core.Signal<boolean>;
-    /** Whether an action's selection rule is satisfied right now. The server checks it again. */
-    isActionEnabled(action: CustomActionDefinition): boolean;
-    constructor();
-    /**
-     * Re-run the query, keeping the current page, sort and scroll position.
-     *
-     * Data-level on purpose: it re-seeds the fetch closure and nothing else. For a definition
-     * change — new columns, a renamed query — the inputs themselves must change; that is the
-     * expensive path. Inert when rows come from the host: there is nothing here to re-run.
-     */
-    reload(): void;
-    private onSearchChanged;
-    /**
-     * Replaces the fetched columns only when they actually differ.
-     *
-     * Columns ship **once per result**, so every page fetch returns an identical set. Assigning it
-     * unconditionally wrote a new array of new objects into the signal each time, re-rendering every
-     * header and re-evaluating every `*bsDatatableColumn` input for no change in content.
-     *
-     * Compared by serialized value rather than by reference: the objects are freshly deserialized from
-     * JSON on every response, so reference equality is always false and would defeat the check. A
-     * dozen small objects per fetch is nothing beside the request that produced them.
-     *
-     * ⚠️ This was written believing it fixed a panel-teardown bug (#431 F7). Measured in a browser: it
-     * does not. The columns were already identical on every fetch, so the guard hits every time and the
-     * teardown had another cause entirely. Kept because avoiding a pointless re-render of every header
-     * on every page is worth having on its own — but it is an optimization, not a fix, and the F7
-     * question remains open.
-     */
-    private setFetchedColumns;
-    /**
-     * The per-column filters currently applied (#431).
-     *
-     * Read inside `makeFetch`'s closure, like `search`, so a change refetches by producing a new fetch
-     * identity rather than by being captured.
-     */
-    private readonly filters;
-    /**
-     * The value source behind every column's panel.
-     *
-     * ⚠️ **Referentially stable, and that is the whole point.** It reads `filters()` when the datatable
-     * *calls* it, not when it is built — so it always sees the current filters while never changing
-     * identity.
-     *
-     * This was a `computed` first, on the reasoning that it had to close over the current filters
-     * because `DistinctsRequest` carries only `{ column, search, signal }`. That was wrong, and the way
-     * it was wrong is worth keeping: a new identity reassigns `[distincts]` on the element, and the
-     * component aborts the in-flight request and bumps a generation counter — so a response already on
-     * its way is discarded as stale and the list renders empty over a perfectly good answer.
-     *
-     * Reading the signal at call time removes the race entirely and is simpler besides.
-     *
-     * The asked-for column's own filter is excluded: a panel must offer the values you could still
-     * pick, not only the ones you already picked.
-     */
-    /**
-     * The last complete distinct list seen per column, for translating a `< none >` selection.
-     *
-     * ⚠️ Only stored when the server reported the list was NOT truncated (`hasMore === false`). The
-     * translation below is the complement of what is listed, so a partial list would exclude the wrong
-     * set — and silently, which is the failure mode this whole feature exists to remove.
-     */
-    private readonly completeDistincts;
-    protected readonly distinctsFn: DatatableDistincts;
-    /**
-     * Translates one filter change into the wire shape and refetches.
-     *
-     * The event always arrives as the `'values'` shape because the panel only ever calls
-     * `ctx.apply(...)`; comparison mode is never declared. `inverse` is a flag on the event and two
-     * arrays on the wire — the translation is this method's whole job.
-     */
-    protected onFilterChange(detail: FilterChangeDetail): void;
-    /**
-     * Back to page 1 and a fresh fetch identity, exactly as a new search term does.
-     *
-     * Both halves matter: the old page number means nothing against a different result set, and the
-     * datatable dedupes reloads by `(page, perPage, sort)` — none of which a filter changes — so
-     * without a new fetch identity the request is silently never made.
-     */
-    private onFilterChanged;
-    onCustomAction(action: CustomActionDefinition): Promise<void>;
-    private reportError;
-    /**
-     * A 404 is deliberately generic.
-     *
-     * `Endpoints/Queries/Get.cs` answers 404 with byte-identical bodies for "no such query" and
-     * "you may not see it", so existence is not disclosed (security audit M-3). The component
-     * therefore genuinely cannot tell them apart, and both "Not found" and "Access denied" would be
-     * a guess — one of them leaking, the other misleading.
-     */
-    private describe;
-    private loadData;
-    /**
-     * The query's entity type.
-     *
-     * The source-name fallback is not optional garnish: a `Database.*` query need not declare
-     * `entityType`, and the sub-query grid — which matched on the declared name alone — rendered
-     * those as an empty card with no columns, no rows and no error, while the identical query
-     * rendered correctly as a page. Both grids are this one now, so there is one answer.
-     */
-    private resolveEntityType;
-    private makeFetch;
-    private loadLookupReferenceOptions;
-    /**
-     * The underlying value a custom renderer receives, which is not the printable one.
-     *
-     * A projection is flat, so this is the cell's own value rather than a display string. It is
-     * deliberately not the attribute-shaped `rendererValue`: a query row has no nested object to
-     * fall back to, and reaching for one would hand every renderer `undefined`.
-     */
-    rendererValueFor(item: QueryResultItem, column: QueryColumn): unknown;
-    getColumnRendererComponent(column: QueryColumn): Type<any> | null;
-    /** The renderer's optional filter-label override for this column, or null for the server text. */
-    filterLabelFor(column: QueryColumn): ((value: unknown) => string) | null;
-    getColumnRendererInputs(component: Type<any>, item: QueryResultItem, column: QueryColumn): Record<string, any>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryGridComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkQueryGridComponent, "spark-query-grid", never, { "queryId": { "alias": "queryId"; "required": true; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "reloadToken": { "alias": "reloadToken"; "required": false; "isSignal": true; }; "settings": { "alias": "settings"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "rowRoute": { "alias": "rowRoute"; "required": false; "isSignal": true; }; }, { "settings": "settingsChange"; "selection": "selectionChange"; "error": "error"; "rowClicked": "rowClicked"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
+export declare class SparkQueryGridComponent {
+  private readonly sparkService;
+  private readonly gridRenderers;
+  private readonly queryRefresh;
+  readonly lang: SparkLanguageService;
+  /** Query alias or id. */
+  queryId: import("@angular/core").InputSignal<string>;
+  /**
+   * The parent persistent object this query is scoped to, when it has one.
+   *
+   * Optional, because not every query is a detail of something: a page can host a grid that
+   * stands on its own — "my accounts", a dashboard list — and the server already treats an absent
+   * parent as "no parent" rather than as an error. Requiring these made that shape impossible to
+   * express: the component simply never loaded, with no request, no error and no log.
+   *
+   * Pass both or neither. One without the other is ignored, matching `SparkService.executeQuery`,
+   * which omits either param when it is falsy, and the execute endpoint, which resolves a parent
+   * only when both are present.
+   */
+  parentId: import("@angular/core").InputSignal<string>;
+  parentType: import("@angular/core").InputSignal<string>;
+  /**
+   * Rows supplied from outside. When bound, the grid renders these and runs no fetch.
+   *
+   * This is how streaming stays out of this component (see the class comment). `null` — the
+   * default — means "fetch for yourself"; an empty array means "you have been given no rows",
+   * which is a different statement and renders an empty grid rather than triggering a load.
+   */
+  data: import("@angular/core").InputSignal<QueryResultItem[] | null>;
+  /**
+   * Server-side search term, passed through to the query.
+   *
+   * An input rather than a box, so the host owns the control and the grid owns the request. A
+   * host with client-side rows filters them itself before binding `data`.
+   */
+  search: import("@angular/core").InputSignal<string>;
+  /**
+   * Column metadata for externally supplied rows. Required whenever `data` is bound, because a
+   * projection cannot describe itself — there is no per-row metadata left to infer it from.
+   */
+  columns: import("@angular/core").InputSignal<QueryColumn[] | null>;
+  /**
+   * Change this to re-run the query. Any value works; only its identity matters.
+   *
+   * A declarative token rather than only a `reload()` method, because calling a method means
+   * holding a component handle, and hosts wrap this grid in `@if`, where a `viewChild` is
+   * intermittently undefined.
+   *
+   * This drives the CHEAP refresh (see {@link reload}). It deliberately does not feed the main
+   * effect: re-running `loadData` would re-resolve the query, the entity types, the permissions
+   * and the lookups, and reset the user's page and sort on every button press.
+   */
+  reloadToken: import("@angular/core").InputSignal<unknown>;
+  /**
+   * Soft-deletion mode (#460, T2): `exclude` (the default, not sent), `include` or `only` (the
+   * recycle bin). Sent with every page and distinct-values request; the server honours a widening
+   * only for `ViewDeleted` holders. A change goes back to page 1 and refetches, like a filter.
+   * While set, row links carry `?deleted=` so the detail page loads the row the same way — a deleted
+   * row is a 404 by id otherwise.
+   */
+  deleted: import("@angular/core").InputSignal<SparkDeletedFilter | null | undefined>;
+  /** The mode actually sent: `exclude` and "unset" are the same request. */
+  protected readonly effectiveDeleted: import("@angular/core").Signal<"include" | "only" | undefined>;
+  /**
+   * The rows' parent is soft-deleted (#460): the detail page it sits on was opened from the recycle
+   * bin with `?deleted=only`. Nothing may be created, deleted or run under a deleted row, so the grid
+   * offers no actions — the same rule as {@link recycleBin}. The fetch is unchanged.
+   */
+  parentDeleted: import("@angular/core").InputSignal<boolean>;
+  /**
+   * The recycle-bin rule (#460), applied here once for every host: while the grid lists `?deleted=only`
+   * (or sits under a deleted parent), it offers no New, no default Delete and no custom action, in
+   * the toolbar or the row menu — as the detail page does for a row opened from the recycle bin. The
+   * server would refuse them anyway: every action judges live rows, and a deleted row is a 404 to it.
+   * Restore and Purge are the SoftDelete entry point's own actions, on the row's detail page.
+   */
+  readonly recycleBin: import("@angular/core").Signal<boolean>;
+  /** Query parameters for the row links; null keeps a plain link. */
+  protected readonly rowQueryParams: import("@angular/core").Signal<{
+    deleted: "include" | "only";
+  } | null>;
+  private readonly router;
+  private readonly currentUrl;
+  /**
+   * Navigation state for a row link: this page's URL, so the detail page can return to this list
+   * (with its `?deleted=` mode) once the row is deleted or purged. See SparkReturnNavigationService.
+   */
+  protected readonly rowLinkState: import("@angular/core").Signal<{
+    sparkReturnUrl: string;
+  }>;
+  /**
+   * A click anywhere on a row opens it, like its first-column link — the link used to be the only
+   * target, so a row whose first column was empty ("—") could not be opened at all. While rows are
+   * selectable a click selects instead, and a double-click opens. Clicks on the link itself or on an
+   * interactive element inside the row (a vote button, a checkbox) are theirs, not the row's; a
+   * modified click (Ctrl, ⌘, Shift, middle) is left to the browser.
+   */
+  protected onRowClick(event: BsDatatableRowEvent<unknown>): void;
+  protected onRowDblClick(event: BsDatatableRowEvent<unknown>): void;
+  private openRow;
+  /**
+   * Paging and sorting. Two-way, so a host driving `data` can sort those rows by whatever the
+   * user actually clicked — the datatable writes the new sort back through here.
+   */
+  settings: import("@angular/core").ModelSignal<DatatableSettings>;
+  /** Rows the user has ticked. Two-way so chrome outside the grid can read and clear them. */
+  selection: import("@angular/core").ModelSignal<QueryResultItem[]>;
+  /**
+   * Replaces where the first column's link points, per row.
+   *
+   * Return `null` to suppress the link for that row — useful when a grid mixes rows that have a
+   * detail page with rows that do not.
+   *
+   * ⚠️ **It changes the destination, not the permission.** `canRead()` still gates whether any
+   * link is rendered at all, and this function is never consulted when that gate is closed. It
+   * cannot be used to reach a row the rights model withheld; it exists for the case where the
+   * row's natural destination is not `/po/{type}/{id}` — a composed row that maps to a page of
+   * its own, or a grid embedded in a route that owns its own child paths.
+   */
+  rowRoute: import("@angular/core").InputSignal<((row: QueryResultItem) => unknown[] | null) | null>;
+  /**
+   * Overrides the query's own `selectionMode` (#460, D17) — the detail page passes the sub-query
+   * entry's. `null` (the default) defers to the query, whose absent setting is `'auto'`.
+   */
+  selectionModeSetting: import("@angular/core").InputSignal<SparkSelectionModeSetting | null>;
+  /** Emitted whenever a load or a page fetch fails, for a host in bespoke chrome. */
+  error: import("@angular/core").OutputEmitterRef<HttpErrorResponse>;
+  rowClicked: import("@angular/core").OutputEmitterRef<QueryResultItem>;
+  customActionExecuted: import("@angular/core").OutputEmitterRef<{
+    action: CustomActionDefinition;
+  }>;
+  /** Emitted when the toolbar's New is pressed, just before the grid navigates to the create page. */
+  createClicked: import("@angular/core").OutputEmitterRef<void>;
+  colors: typeof Color;
+  /**
+   * Where the first column's link points for this row: the host's `rowRoute` when it supplied one,
+   * otherwise the row's own detail page.
+   *
+   * A method rather than a computed because the answer is per row, and the template already
+   * iterates rows — a computed would have to be a map keyed by id, rebuilt on every page.
+   */
+  protected rowRouteFor(row: QueryResultItem): unknown[] | null;
+  query: import("@angular/core").WritableSignal<SparkQuery | null>;
+  entityType: import("@angular/core").WritableSignal<EntityType | null>;
+  allEntityTypes: import("@angular/core").WritableSignal<EntityType[]>;
+  lookupReferenceOptions: import("@angular/core").WritableSignal<Record<string, LookupReference>>;
+  loading: import("@angular/core").WritableSignal<boolean>;
+  canRead: import("@angular/core").WritableSignal<boolean>;
+  canCreate: import("@angular/core").WritableSignal<boolean>;
+  /** The entity type's full rights, for hosts (the query page hands them to its add-on actions). */
+  permissions: import("@angular/core").WritableSignal<EntityPermissions | null>;
+  resultCount: import("@angular/core").WritableSignal<number | null>;
+  customActions: import("@angular/core").WritableSignal<CustomActionDefinition[]>;
+  /** The built-in New and Delete the server listed for this caller (#460, D18); see `toolbarActions`. */
+  defaultActions: import("@angular/core").WritableSignal<CustomActionDefinition[]>;
+  /** Names the server withheld for this RESULT; see QueryResult.disabledActions. */
+  private readonly disabledActions;
+  /**
+   * The actions actually offered for this result.
+   *
+   * The catalogue at `/spark/actions/{objectTypeId}` is per TYPE and is never told what an
+   * execution returned, so an action that applies to only some results cannot be filtered there.
+   * The entity's `OnDisableActionsAsync` hook withholds what does not apply to this query (#460,
+   * D13), and the answer arrives on the result. The server asks the same hook when an action is
+   * submitted from this query and refuses a disabled one with 403.
+   */
+  /**
+   * Whether to offer "New": the type-level right, unless the result withholds `New` (or `Save`) --
+   * the server's OnDisableActionsAsync said so and would refuse the create with 403 (#460, D13).
+   * `canCreate` stays the bare right, since hosts read it as exactly that.
+   */
+  offersCreate: import("@angular/core").Signal<boolean>;
+  visibleCustomActions: import("@angular/core").Signal<CustomActionDefinition[]>;
+  fetchFn: import("@angular/core").WritableSignal<BsDatatableFetch<QueryResultItem> | null>;
+  /**
+   * Why the component renders its own failure instead of only reporting one.
+   *
+   * `SparkService` is a bare `firstValueFrom` passthrough with no interceptor, so every failure
+   * surfaces here and nowhere else. A host embedding this grid cannot surface what it never sees,
+   * and the default has to be visible with no host cooperation — hence a rendered alert, not just
+   * an output.
+   */
+  errorMessage: import("@angular/core").WritableSignal<string | null>;
+  /**
+   * The rendered selection mode (#460, D17): the host's override (a sub-query entry's
+   * `selectionMode`), else the query's own, else `'auto'` — derived from the CUSTOM actions offered,
+   * exactly as before the setting existed, so no existing grid changes behaviour. The default Delete
+   * does not widen `'auto'`: selection is opt-in, and without it Delete stays reachable per row
+   * through the row menu.
+   */
+  selectionMode: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").SparkSelectionMode>;
+  /**
+   * The actions a host renders in its toolbar, in one list (#460, M15): New, Delete and the custom
+   * actions, each with the rule that enables it. The query card and the query-list page render this
+   * same list, so the two surfaces cannot drift.
+   *
+   * - New: the default entry's `showedOn` includes the query, the caller holds `New/T`, and the
+   *   result does not withhold `New`/`Save`.
+   * - Delete: likewise with `Delete/T` and `Delete`, and only while rows can be selected (otherwise
+   *   it could never be enabled — the row menu offers it per row instead).
+   * - Custom: `visibleCustomActions()`.
+   * - In the recycle bin ({@link recycleBin}) none of the three: the list is empty.
+   */
+  toolbarActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
+  /**
+   * The per-row `⋮` menu: every offered action whose rule accepts exactly one row — Delete included,
+   * whatever the selection mode. An action without a rule acts on the query, not on a row, and is
+   * left to the toolbar.
+   */
+  rowActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
+  /** The default Delete: not withheld by the result, and never in the recycle bin. */
+  private offersDelete;
+  /** Whether a toolbar action can run with the current selection. The server checks again. */
+  isToolbarActionEnabled(action: SparkQueryToolbarAction): boolean;
+  /** Runs a toolbar action on the current selection. */
+  runToolbarAction(action: SparkQueryToolbarAction): Promise<void>;
+  /**
+   * The chip's ⊗, offered only for single selection: there the datatable renders no checkbox
+   * column, so it has no header deselect-all, and a row click never deselects.
+   */
+  clearSelection(): void;
+  /** The id of the row whose `⋮` menu is open; at most one is. */
+  readonly openRowMenu: import("@angular/core").WritableSignal<string | null>;
+  /** Below the toggle, right-aligned; above it when there is no room below. */
+  readonly rowMenuPositions: ConnectedPosition[];
+  toggleRowMenu(row: QueryResultItem): void;
+  /**
+   * Closes the open row menu. With a `rowId`, only when that row's menu is the open one: a row's
+   * overlay reports its outside click and its detach AFTER another row's toggle has already opened
+   * that row's menu, and an unscoped close there shut the menu the user had just opened.
+   */
+  closeRowMenu(rowId?: string): void;
+  /**
+   * A click outside the open menu closes it — except on its own toggle, whose click handler toggles
+   * it; closing here as well would reopen it at once.
+   */
+  onRowMenuOutsideClick(event: MouseEvent, toggle: HTMLElement, rowId: string): void;
+  /** Runs the chosen row-menu item and closes the menu. */
+  chooseRowAction(action: SparkQueryToolbarAction, row: QueryResultItem): Promise<void>;
+  /**
+   * Runs a row-menu action on that ONE row. The checkbox selection is neither read nor changed:
+   * the menu is a shortcut for this row, not a second way to tick it.
+   */
+  runRowAction(action: SparkQueryToolbarAction, row: QueryResultItem): Promise<void>;
+  /**
+   * New from this grid: the create page, carrying the sub-query's parent (#460, D19) as query
+   * parameters so it survives the navigation and a reload of the create page. The server's
+   * `OnNewAsync` receives the parent; its base fills the parent reference.
+   */
+  startNew(): void;
+  /**
+   * The default Delete on `ids`: one request, all rows or none (#460, D18). Asks first — with the
+   * entry's `confirmationMessageKey` — then clears the selection and refreshes.
+   */
+  deleteRows(ids: string[], definition?: CustomActionDefinition): Promise<void>;
+  isVirtualScrolling: import("@angular/core").Signal<boolean>;
+  /**
+   * Columns as sent with the most recent fetched page.
+   *
+   * A host binding `data` (streaming) supplies its own via the `columns` input instead — the
+   * snapshot carries them once, exactly as a paged result does.
+   */
+  private readonly fetchedColumns;
+  /** Every column on the wire, drawn or not — what renderers and lookups resolve against. */
+  allColumns: import("@angular/core").Signal<QueryColumn[]>;
+  /**
+   * The columns the grid draws. `isVisible: false` ships a value without a column, so a renderer
+   * can read a sibling the grid does not show; undefined means visible, so a server that predates
+   * the field still draws everything.
+   */
+  visibleColumns: import("@angular/core").Signal<QueryColumn[]>;
+  /**
+   * True when rows do not come from this component's own fetch.
+   *
+   * Either because the host bound `data`, or because the query streams — a streaming query's rows
+   * arrive over a socket and `/execute` is not a way to get them. The grid recognises the second
+   * case itself rather than waiting to be told, because it resolves the query before the host can
+   * see it: left to `data` alone, every streaming grid would fire one pointless fetch on mount,
+   * before the host had anything to bind.
+   */
+  hasExternalData: import("@angular/core").Signal<boolean>;
+  /** Whether an action's selection rule is satisfied right now. The server checks it again. */
+  isActionEnabled(action: CustomActionDefinition): boolean;
+  constructor();
+  /**
+   * Re-run the query, keeping the current page, sort and scroll position.
+   *
+   * Data-level on purpose: it re-seeds the fetch closure and nothing else. For a definition
+   * change — new columns, a renamed query — the inputs themselves must change; that is the
+   * expensive path. Inert when rows come from the host: there is nothing here to re-run.
+   */
+  reload(): void;
+  private onSearchChanged;
+  /**
+   * Replaces the fetched columns only when they actually differ.
+   *
+   * Columns ship **once per result**, so every page fetch returns an identical set. Assigning it
+   * unconditionally wrote a new array of new objects into the signal each time, re-rendering every
+   * header and re-evaluating every `*bsDatatableColumn` input for no change in content.
+   *
+   * Compared by serialized value rather than by reference: the objects are freshly deserialized from
+   * JSON on every response, so reference equality is always false and would defeat the check. A
+   * dozen small objects per fetch is nothing beside the request that produced them.
+   *
+   * ⚠️ This was written believing it fixed a panel-teardown bug (#431 F7). Measured in a browser: it
+   * does not. The columns were already identical on every fetch, so the guard hits every time and the
+   * teardown had another cause entirely. Kept because avoiding a pointless re-render of every header
+   * on every page is worth having on its own — but it is an optimization, not a fix, and the F7
+   * question remains open.
+   */
+  private setFetchedColumns;
+  /**
+   * The per-column filters currently applied (#431).
+   *
+   * Read inside `makeFetch`'s closure, like `search`, so a change refetches by producing a new fetch
+   * identity rather than by being captured.
+   */
+  private readonly filters;
+  /**
+   * The value source behind every column's panel.
+   *
+   * ⚠️ **Referentially stable, and that is the whole point.** It reads `filters()` when the datatable
+   * *calls* it, not when it is built — so it always sees the current filters while never changing
+   * identity.
+   *
+   * This was a `computed` first, on the reasoning that it had to close over the current filters
+   * because `DistinctsRequest` carries only `{ column, search, signal }`. That was wrong, and the way
+   * it was wrong is worth keeping: a new identity reassigns `[distincts]` on the element, and the
+   * component aborts the in-flight request and bumps a generation counter — so a response already on
+   * its way is discarded as stale and the list renders empty over a perfectly good answer.
+   *
+   * Reading the signal at call time removes the race entirely and is simpler besides.
+   *
+   * The asked-for column's own filter is excluded: a panel must offer the values you could still
+   * pick, not only the ones you already picked.
+   */
+  /**
+   * The last complete distinct list seen per column, for translating a `< none >` selection.
+   *
+   * ⚠️ Only stored when the server reported the list was NOT truncated (`hasMore === false`). The
+   * translation below is the complement of what is listed, so a partial list would exclude the wrong
+   * set — and silently, which is the failure mode this whole feature exists to remove.
+   */
+  private readonly completeDistincts;
+  protected readonly distinctsFn: DatatableDistincts;
+  /**
+   * Translates one filter change into the wire shape and refetches.
+   *
+   * The event always arrives as the `'values'` shape because the panel only ever calls
+   * `ctx.apply(...)`; comparison mode is never declared. `inverse` is a flag on the event and two
+   * arrays on the wire — the translation is this method's whole job.
+   */
+  protected onFilterChange(detail: FilterChangeDetail): void;
+  /**
+   * Back to page 1 and a fresh fetch identity, exactly as a new search term does.
+   *
+   * Both halves matter: the old page number means nothing against a different result set, and the
+   * datatable dedupes reloads by `(page, perPage, sort)` — none of which a filter changes — so
+   * without a new fetch identity the request is silently never made.
+   */
+  private onFilterChanged;
+  /**
+   * Runs a custom action on the selection — or on `rowIds` when given (the row menu), which leaves
+   * the checkbox selection untouched.
+   */
+  onCustomAction(action: CustomActionDefinition, rowIds?: string[]): Promise<void>;
+  private reportError;
+  /**
+   * A 404 is deliberately generic.
+   *
+   * `Endpoints/Queries/Get.cs` answers 404 with byte-identical bodies for "no such query" and
+   * "you may not see it", so existence is not disclosed (security audit M-3). The component
+   * therefore genuinely cannot tell them apart, and both "Not found" and "Access denied" would be
+   * a guess — one of them leaking, the other misleading.
+   */
+  private describe;
+  private loadData;
+  /**
+   * The query's entity type.
+   *
+   * The source-name fallback is not optional garnish: a `Database.*` query need not declare
+   * `entityType`, and the sub-query grid — which matched on the declared name alone — rendered
+   * those as an empty card with no columns, no rows and no error, while the identical query
+   * rendered correctly as a page. Both grids are this one now, so there is one answer.
+   */
+  private resolveEntityType;
+  private makeFetch;
+  private loadLookupReferenceOptions;
+  /**
+   * The underlying value a custom renderer receives, which is not the printable one.
+   *
+   * A projection is flat, so this is the cell's own value rather than a display string. It is
+   * deliberately not the attribute-shaped `rendererValue`: a query row has no nested object to
+   * fall back to, and reaching for one would hand every renderer `undefined`.
+   */
+  rendererValueFor(item: QueryResultItem, column: QueryColumn): unknown;
+  getColumnRendererComponent(column: QueryColumn): Type<any> | null;
+  /** The renderer's optional filter-label override for this column, or null for the server text. */
+  filterLabelFor(column: QueryColumn): ((value: unknown) => string) | null;
+  getColumnRendererInputs(component: Type<any>, item: QueryResultItem, column: QueryColumn): Record<string, any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryGridComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkQueryGridComponent, "spark-query-grid", never, {
+    "queryId": {
+      "alias": "queryId";
+      "required": true;
+      "isSignal": true;
+    };
+    "parentId": {
+      "alias": "parentId";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentType": {
+      "alias": "parentType";
+      "required": false;
+      "isSignal": true;
+    };
+    "data": {
+      "alias": "data";
+      "required": false;
+      "isSignal": true;
+    };
+    "search": {
+      "alias": "search";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": false;
+      "isSignal": true;
+    };
+    "reloadToken": {
+      "alias": "reloadToken";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleted": {
+      "alias": "deleted";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentDeleted": {
+      "alias": "parentDeleted";
+      "required": false;
+      "isSignal": true;
+    };
+    "settings": {
+      "alias": "settings";
+      "required": false;
+      "isSignal": true;
+    };
+    "selection": {
+      "alias": "selection";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowRoute": {
+      "alias": "rowRoute";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionModeSetting": {
+      "alias": "selectionModeSetting";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "settings": "settingsChange";
+    "selection": "selectionChange";
+    "error": "error";
+    "rowClicked": "rowClicked";
+    "customActionExecuted": "customActionExecuted";
+    "createClicked": "createClicked";
+  }, never, never, true, never>;
 }
-
 /**
  * A `<bs-card>` around a {@link SparkQueryGridComponent}: icon, caption, actions, grid.
  *
@@ -502,61 +747,168 @@ declare class SparkQueryGridComponent {
  *
  * Content wins over a forwarded input: the closer declaration is the more specific one.
  */
-declare class SparkQueryCardComponent {
-    readonly lang: SparkLanguageService;
-    queryId: _angular_core.InputSignal<string>;
-    parentId: _angular_core.InputSignal<string>;
-    parentType: _angular_core.InputSignal<string>;
-    reloadToken: _angular_core.InputSignal<unknown>;
-    data: _angular_core.InputSignal<QueryResultItem[] | null>;
-    search: _angular_core.InputSignal<string>;
-    /**
-     * Slots forwarded from a host that cannot project content — see the class comment. A card
-     * reached through hand-written markup should use the structural directives instead.
-     */
-    iconTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
-    captionTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
-    actionsTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
-    error: _angular_core.OutputEmitterRef<HttpErrorResponse>;
-    rowClicked: _angular_core.OutputEmitterRef<QueryResultItem>;
-    customActionExecuted: _angular_core.OutputEmitterRef<{
-        action: CustomActionDefinition;
-    }>;
-    /**
-     * Forwarded to the grid. Without this the escape hatch was unreachable from a card — i.e. from
-     * every auto-rendered sub-query and program-unit query page, which is most grids.
-     */
-    rowRoute: _angular_core.InputSignal<((row: QueryResultItem) => unknown[] | null) | null>;
-    colors: typeof Color;
-    private readonly iconSlots;
-    private readonly captionSlots;
-    private readonly actionSlots;
-    /**
-     * The grid, read only to surface its state — the query, the actions, the selection — to this
-     * component's own header.
-     *
-     * Optional rather than `required` on purpose. The header renders ABOVE the grid in this
-     * template, so on the first change-detection pass the view query has not resolved yet and
-     * `viewChild.required()` would throw where a plain one returns `undefined`. Everything below
-     * therefore reads it defensively; the signal updates once the view initialises and the header
-     * re-renders with the real query.
-     *
-     * A host reads grid state through a template reference variable instead, because a host may put
-     * the grid behind an `@if`, where a view query genuinely is intermittently undefined.
-     */
-    protected readonly grid: _angular_core.Signal<SparkQueryGridComponent | undefined>;
-    protected readonly query: _angular_core.Signal<_mintplayer_ng_spark_models.SparkQuery | null>;
-    protected readonly iconTpl: _angular_core.Signal<TemplateRef<any> | null>;
-    protected readonly captionTpl: _angular_core.Signal<TemplateRef<any> | null>;
-    protected readonly actionsTpl: _angular_core.Signal<TemplateRef<any> | null>;
-    /** The caption the card renders unless a slot replaces it. */
-    protected readonly caption: _angular_core.Signal<string>;
-    protected readonly customActions: _angular_core.Signal<CustomActionDefinition[]>;
-    protected readonly selection: _angular_core.Signal<QueryResultItem[]>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryCardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkQueryCardComponent, "spark-query-card", never, { "queryId": { "alias": "queryId"; "required": true; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "reloadToken": { "alias": "reloadToken"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "iconTemplate": { "alias": "iconTemplate"; "required": false; "isSignal": true; }; "captionTemplate": { "alias": "captionTemplate"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; "rowRoute": { "alias": "rowRoute"; "required": false; "isSignal": true; }; }, { "error": "error"; "rowClicked": "rowClicked"; "customActionExecuted": "customActionExecuted"; }, ["iconSlots", "captionSlots", "actionSlots"], never, true, never>;
+export declare class SparkQueryCardComponent {
+  readonly lang: SparkLanguageService;
+  queryId: import("@angular/core").InputSignal<string>;
+  parentId: import("@angular/core").InputSignal<string>;
+  parentType: import("@angular/core").InputSignal<string>;
+  reloadToken: import("@angular/core").InputSignal<unknown>;
+  data: import("@angular/core").InputSignal<QueryResultItem[] | null>;
+  /**
+   * The initial search term. The header's search box starts from it and the user takes over from
+   * there; a new value from the host replaces what was typed.
+   */
+  search: import("@angular/core").InputSignal<string>;
+  /**
+   * Whether the header offers the search box (#460 M15, D17 addendum). On by default, as every
+   * Vidyano sub-query tab has one; a card over bound `data` never shows it, because the grid does
+   * not refetch bound rows and the box would do nothing.
+   */
+  searchable: import("@angular/core").InputSignal<boolean>;
+  /** What the grid searches: the host's `search`, until the user types in the header box. */
+  readonly searchTerm: import("@angular/core").WritableSignal<string>;
+  protected readonly showSearch: import("@angular/core").Signal<boolean>;
+  /**
+   * Overrides the query's `selectionMode` for this card (#460, D17) — the detail page passes the
+   * sub-query entry's. `null` defers to the query (absent there = `'auto'`).
+   */
+  selectionMode: import("@angular/core").InputSignal<SparkSelectionModeSetting | null>;
+  /**
+   * Soft-deletion mode and deleted parent (#460), forwarded to the grid. In the recycle bin — the
+   * grid lists `deleted: 'only'`, or its parent row was opened with `?deleted=only` — the card offers
+   * no New, Delete or custom action, exactly as the query-list page does. See `recycleBin`.
+   */
+  deleted: import("@angular/core").InputSignal<SparkDeletedFilter | null | undefined>;
+  parentDeleted: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Slots forwarded from a host that cannot project content — see the class comment. A card
+   * reached through hand-written markup should use the structural directives instead.
+   */
+  iconTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+  captionTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+  actionsTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+  error: import("@angular/core").OutputEmitterRef<HttpErrorResponse>;
+  rowClicked: import("@angular/core").OutputEmitterRef<QueryResultItem>;
+  customActionExecuted: import("@angular/core").OutputEmitterRef<{
+    action: CustomActionDefinition;
+  }>;
+  /**
+   * Forwarded to the grid. Without this the escape hatch was unreachable from a card — i.e. from
+   * every auto-rendered sub-query and program-unit query page, which is most grids.
+   */
+  rowRoute: import("@angular/core").InputSignal<((row: QueryResultItem) => unknown[] | null) | null>;
+  colors: typeof Color;
+  private readonly iconSlots;
+  private readonly captionSlots;
+  private readonly actionSlots;
+  /**
+   * The grid, read only to surface its state — the query, the actions, the selection — to this
+   * component's own header.
+   *
+   * Optional rather than `required` on purpose. The header renders ABOVE the grid in this
+   * template, so on the first change-detection pass the view query has not resolved yet and
+   * `viewChild.required()` would throw where a plain one returns `undefined`. Everything below
+   * therefore reads it defensively; the signal updates once the view initialises and the header
+   * re-renders with the real query.
+   *
+   * A host reads grid state through a template reference variable instead, because a host may put
+   * the grid behind an `@if`, where a view query genuinely is intermittently undefined.
+   */
+  protected readonly grid: import("@angular/core").Signal<SparkQueryGridComponent | undefined>;
+  protected readonly query: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").SparkQuery | null>;
+  protected readonly iconTpl: import("@angular/core").Signal<TemplateRef<any> | null>;
+  protected readonly captionTpl: import("@angular/core").Signal<TemplateRef<any> | null>;
+  protected readonly actionsTpl: import("@angular/core").Signal<TemplateRef<any> | null>;
+  /** The caption the card renders unless a slot replaces it. */
+  protected readonly caption: import("@angular/core").Signal<string>;
+  protected readonly customActions: import("@angular/core").Signal<CustomActionDefinition[]>;
+  /**
+   * The header's buttons: New, Delete and the custom actions, from the grid (#460, M15) — the same
+   * list the query-list page renders.
+   */
+  protected readonly toolbarActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
+  protected actionClass(action: SparkQueryToolbarAction): string;
+  protected isEnabled(action: SparkQueryToolbarAction): boolean;
+  protected run(action: SparkQueryToolbarAction): void;
+  protected readonly selection: import("@angular/core").Signal<QueryResultItem[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryCardComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkQueryCardComponent, "spark-query-card", never, {
+    "queryId": {
+      "alias": "queryId";
+      "required": true;
+      "isSignal": true;
+    };
+    "parentId": {
+      "alias": "parentId";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentType": {
+      "alias": "parentType";
+      "required": false;
+      "isSignal": true;
+    };
+    "reloadToken": {
+      "alias": "reloadToken";
+      "required": false;
+      "isSignal": true;
+    };
+    "data": {
+      "alias": "data";
+      "required": false;
+      "isSignal": true;
+    };
+    "search": {
+      "alias": "search";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchable": {
+      "alias": "searchable";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionMode": {
+      "alias": "selectionMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleted": {
+      "alias": "deleted";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentDeleted": {
+      "alias": "parentDeleted";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconTemplate": {
+      "alias": "iconTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "captionTemplate": {
+      "alias": "captionTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "actionsTemplate": {
+      "alias": "actionsTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowRoute": {
+      "alias": "rowRoute";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "error": "error";
+    "rowClicked": "rowClicked";
+    "customActionExecuted": "customActionExecuted";
+  }, ["iconSlots", "captionSlots", "actionSlots"], never, true, never>;
 }
-
 /**
  * One cell of a Spark table, wherever that table is.
  *
@@ -585,52 +937,137 @@ declare class SparkQueryCardComponent {
  * gated on `Read`), and it stays in the grid, wrapping this component. Passing both would nest
  * anchors, which is invalid HTML; the grid therefore leaves `link` unset.
  */
-declare class SparkGridCellComponent {
-    private readonly renderers;
-    /** The column being rendered. Its `dataType` and `renderer` decide everything below. */
-    column: _angular_core.InputSignal<SparkCellColumn>;
-    /**
-     * What the caller's value pipe produced: the display text for most columns, and the raw value
-     * for `boolean` and `color`, which need the value rather than a rendering of it.
-     */
-    display: _angular_core.InputSignal<unknown>;
-    /**
-     * The value handed to a declared custom renderer.
-     *
-     * Separate from {@link display} because they are not the same thing: a renderer receives the
-     * underlying value — for AsDetail, the nested object itself — while `display` has already been
-     * flattened to something printable.
-     */
-    rendererValue: _angular_core.InputSignal<unknown>;
-    /** The row, passed through to a custom renderer as `item`. */
-    item: _angular_core.InputSignal<unknown>;
-    /**
-     * Pre-resolved chips for a reference-array column, or empty when the column is not one.
-     *
-     * Resolved by the caller because the label source differs: a query row carries a per-id
-     * breadcrumb map, while an AsDetail row's `__sparkBreadcrumbs` is keyed by column name only and
-     * so cannot label the members of an array. Rather than render a row of raw ids, an AsDetail
-     * caller passes nothing and the cell falls through to text.
-     */
-    chips: _angular_core.InputSignal<ReferenceChip[]>;
-    /** Route for a cell whose value references another entity. See the class comment. */
-    link: _angular_core.InputSignal<unknown[] | null>;
-    protected readonly rendererComponent: _angular_core.Signal<_angular_core.Type<any> | null>;
-    protected readonly rendererInputs: _angular_core.Signal<Record<string, any>>;
-    /** Null and undefined are distinct from `false` here — see the template. */
-    protected readonly isUnsetBoolean: _angular_core.Signal<boolean>;
-    /**
-     * {@link display} when it really is a `Date`, and `null` otherwise.
-     *
-     * Angular's `DatePipe` does not degrade on a non-date: it **throws**
-     * `NG02100: InvalidPipeArgument`, which would take down the whole cell. Both cell pipes
-     * deliberately fall back to the raw text for an unparseable date rather than hiding the stored
-     * value, so that text reaches this component and must not be piped. A template cannot express
-     * `instanceof`, hence the computed.
-     */
-    protected readonly dateValue: _angular_core.Signal<Date | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkGridCellComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkGridCellComponent, "spark-grid-cell", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "rendererValue": { "alias": "rendererValue"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": false; "isSignal": true; }; "chips": { "alias": "chips"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class SparkGridCellComponent {
+  private readonly renderers;
+  /** The column being rendered. Its `dataType` and `renderer` decide everything below. */
+  column: import("@angular/core").InputSignal<SparkCellColumn>;
+  /**
+   * What the caller's value pipe produced: the display text for most columns, and the raw value
+   * for `boolean` and `color`, which need the value rather than a rendering of it.
+   */
+  display: import("@angular/core").InputSignal<unknown>;
+  /**
+   * The value handed to a declared custom renderer.
+   *
+   * Separate from {@link display} because they are not the same thing: a renderer receives the
+   * underlying value — for AsDetail, the nested object itself — while `display` has already been
+   * flattened to something printable.
+   */
+  rendererValue: import("@angular/core").InputSignal<unknown>;
+  /** The row, passed through to a custom renderer as `item`. */
+  item: import("@angular/core").InputSignal<unknown>;
+  /**
+   * Pre-resolved chips for a reference-array column, or empty when the column is not one.
+   *
+   * Resolved by the caller because the label source differs: a query row carries a per-id
+   * breadcrumb map, while an AsDetail row's `__sparkBreadcrumbs` is keyed by column name only and
+   * so cannot label the members of an array. Rather than render a row of raw ids, an AsDetail
+   * caller passes nothing and the cell falls through to text.
+   */
+  chips: import("@angular/core").InputSignal<ReferenceChip[]>;
+  /** Route for a cell whose value references another entity. See the class comment. */
+  link: import("@angular/core").InputSignal<unknown[] | null>;
+  protected readonly rendererComponent: import("@angular/core").Signal<import("@angular/core").Type<any> | null>;
+  protected readonly rendererInputs: import("@angular/core").Signal<Record<string, any>>;
+  /** Null and undefined are distinct from `false` here — see the template. */
+  protected readonly isUnsetBoolean: import("@angular/core").Signal<boolean>;
+  /**
+   * {@link display} when it really is a `Date`, and `null` otherwise.
+   *
+   * Angular's `DatePipe` does not degrade on a non-date: it **throws**
+   * `NG02100: InvalidPipeArgument`, which would take down the whole cell. Both cell pipes
+   * deliberately fall back to the raw text for an unparseable date rather than hiding the stored
+   * value, so that text reaches this component and must not be piped. A template cannot express
+   * `instanceof`, hence the computed.
+   */
+  protected readonly dateValue: import("@angular/core").Signal<Date | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkGridCellComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkGridCellComponent, "spark-grid-cell", never, {
+    "column": {
+      "alias": "column";
+      "required": true;
+      "isSignal": true;
+    };
+    "display": {
+      "alias": "display";
+      "required": false;
+      "isSignal": true;
+    };
+    "rendererValue": {
+      "alias": "rendererValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "item": {
+      "alias": "item";
+      "required": false;
+      "isSignal": true;
+    };
+    "chips": {
+      "alias": "chips";
+      "required": false;
+      "isSignal": true;
+    };
+    "link": {
+      "alias": "link";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
-export { SPARK_GRID_PAGE_SIZES, SparkGridCellComponent, SparkGridRenderers, SparkQueryActionsContext, SparkQueryActionsDirective, SparkQueryCaptionContext, SparkQueryCaptionDirective, SparkQueryCardComponent, SparkQueryGridComponent, SparkQueryIconDirective, SparkQuerySlotContext, initialGridSettings, isVirtualScrollingQuery, slotFor, visibleGridAttributes };
+/** How long typing must pause before the term is published, in milliseconds. */
+export declare const SPARK_SEARCH_DEBOUNCE_MS = 300;
+/**
+ * The query search box: a magnifier, the input and a clear button (#460 M15, D17 addendum).
+ *
+ * One component for both surfaces that search a query — the query-list page above its grid and the
+ * `<spark-query-card>` header next to its actions, as Vidyano's sub-query tabs have it — so they
+ * behave identically: the same debounce, the same clear button, the same placeholder.
+ *
+ * Two-way bound through `term`, which is what a grid's `search` input takes:
+ *
+ * ```html
+ * <spark-search-box [(term)]="searchTerm" />
+ * <spark-query-grid [search]="searchTerm()" … />
+ * ```
+ *
+ * Typing publishes the term once it has paused for {@link SPARK_SEARCH_DEBOUNCE_MS}, so a word is
+ * one query rather than one per keystroke. Clearing (the ✕ button, or Escape) publishes at once. A
+ * `term` set from outside — a host resetting it — replaces what the box shows.
+ */
+export declare class SparkSearchBoxComponent {
+  /** The published search term. Debounced while typing; immediate on clear. */
+  readonly term: import("@angular/core").ModelSignal<string>;
+  /** The input group's size: `sm` for a card header, the default for a page. */
+  readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg">;
+  /** Overrides {@link SPARK_SEARCH_DEBOUNCE_MS}; `0` publishes on every keystroke. */
+  readonly debounce: import("@angular/core").InputSignal<number>;
+  /** What the input shows, which runs ahead of `term` while the debounce is pending. */
+  protected readonly text: import("@angular/core").WritableSignal<string>;
+  private timer;
+  constructor();
+  protected onInput(value: string): void;
+  /** Empties the box and publishes the empty term at once. */
+  clear(): void;
+  private cancelPending;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkSearchBoxComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkSearchBoxComponent, "spark-search-box", never, {
+    "term": {
+      "alias": "term";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "debounce": {
+      "alias": "debounce";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "term": "termChange";
+  }, never, never, true, never>;
+}