@mintplayer/ng-spark 22.23.0 → 22.25.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mintplayer/ng-spark",
   "private": false,
-  "version": "22.23.0",
+  "version": "22.25.0",
   "description": "Angular component library for MintPlayer.Spark CRUD applications",
   "repository": {
     "type": "git",
@@ -14,7 +14,8 @@
     "@angular/common": "^22.0.0",
     "@angular/router": "^22.0.0",
     "@angular/forms": "^22.0.0",
-    "@mintplayer/ng-bootstrap": "^22.19.0",
+    "@mintplayer/ng-bootstrap": "^22.20.0",
+    "@mintplayer/web-components": "^2.17.0",
     "@mintplayer/pagination": "*",
     "rxjs": "~7.8.0"
   },
@@ -41,10 +42,18 @@
       "types": "./types/mintplayer-ng-spark-column-filter.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-column-filter.mjs"
     },
+    "./contributions": {
+      "types": "./types/mintplayer-ng-spark-contributions.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-contributions.mjs"
+    },
     "./grid": {
       "types": "./types/mintplayer-ng-spark-grid.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-grid.mjs"
     },
+    "./history": {
+      "types": "./types/mintplayer-ng-spark-history.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-history.mjs"
+    },
     "./icon": {
       "types": "./types/mintplayer-ng-spark-icon.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-icon.mjs"
@@ -53,6 +62,14 @@
       "types": "./types/mintplayer-ng-spark-models.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-models.mjs"
     },
+    "./moderation": {
+      "types": "./types/mintplayer-ng-spark-moderation.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-moderation.mjs"
+    },
+    "./panels": {
+      "types": "./types/mintplayer-ng-spark-panels.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-panels.mjs"
+    },
     "./pipes": {
       "types": "./types/mintplayer-ng-spark-pipes.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-pipes.mjs"
@@ -96,6 +113,10 @@
     "./shell": {
       "types": "./types/mintplayer-ng-spark-shell.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-shell.mjs"
+    },
+    "./soft-delete": {
+      "types": "./types/mintplayer-ng-spark-soft-delete.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-soft-delete.mjs"
     }
   },
   "type": "module",

package/types/mintplayer-ng-spark-attribute-description.d.ts

@@ -1,7 +1,6 @@
-import * as _angular_core from '@angular/core';
-import { TranslatedString } from '@mintplayer/ng-spark/models';
-
-type SparkAttributeDescriptionPosition = 'top' | 'bottom' | 'start' | 'end';
+import { TranslatedString } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
+export type SparkAttributeDescriptionPosition = 'top' | 'bottom' | 'start' | 'end';
 /**
  * The [i] beside an attribute label: a focusable button whose tooltip shows the attribute's
  * `description` (#348). Renders nothing when the model declares no description, so every label
@@ -14,17 +13,25 @@ type SparkAttributeDescriptionPosition = 'top' | 'bottom' | 'start' | 'end';
  * Clicks are stopped: the [i] lives inside sortable grid headers and `<label for>` elements, and
  * must neither toggle the sort nor move focus into the input.
  */
-declare class SparkAttributeDescriptionComponent {
-    /** The attribute's `description`; `undefined` (the common case) renders nothing. */
-    description: _angular_core.InputSignal<TranslatedString | undefined>;
-    /** Where the tooltip opens relative to the [i]. */
-    position: _angular_core.InputSignal<SparkAttributeDescriptionPosition>;
-    /** Resolved for the current language; re-evaluates when the user switches language. */
-    text: _angular_core.Signal<string>;
-    onClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkAttributeDescriptionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkAttributeDescriptionComponent, "spark-attribute-description", never, { "description": { "alias": "description"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { SparkAttributeDescriptionComponent };
-export type { SparkAttributeDescriptionPosition };
+export declare class SparkAttributeDescriptionComponent {
+  /** The attribute's `description`; `undefined` (the common case) renders nothing. */
+  description: import("@angular/core").InputSignal<TranslatedString | undefined>;
+  /** Where the tooltip opens relative to the [i]. */
+  position: import("@angular/core").InputSignal<SparkAttributeDescriptionPosition>;
+  /** Resolved for the current language; re-evaluates when the user switches language. */
+  text: import("@angular/core").Signal<string>;
+  onClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkAttributeDescriptionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkAttributeDescriptionComponent, "spark-attribute-description", never, {
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "position": {
+      "alias": "position";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/mintplayer-ng-spark-client-operations.d.ts

@@ -1,90 +1,77 @@
-import { PersistentObject } from '@mintplayer/ng-spark/models';
-import * as i0 from '@angular/core';
-import { InjectionToken, EnvironmentProviders } from '@angular/core';
-
-declare enum NotificationKind {
-    Info = 0,
-    Success = 1,
-    Warning = 2,
-    Error = 3
+import { PersistentObject, TranslatedString } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
+import { EnvironmentProviders, InjectionToken } from "@angular/core";
+export declare enum NotificationKind {
+  Info = 0,
+  Success = 1,
+  Warning = 2,
+  Error = 3
 }
-interface NavigateOperation {
-    type: 'navigate';
-    objectTypeId?: string;
-    id?: string;
-    routeName?: string;
+export interface NavigateOperation {
+  type: 'navigate';
+  objectTypeId?: string;
+  id?: string;
+  routeName?: string;
 }
-interface NotifyOperation {
-    type: 'notify';
-    message: string;
-    kind: NotificationKind;
-    durationMs?: number;
+export interface NotifyOperation {
+  type: 'notify';
+  /** The text in the request's language (the browser's `Accept-Language`). */
+  message: string;
+  /**
+   * The text in every language, when the server has it. Shown in the language the user picked in
+   * the app (`SparkLanguageService`), which the server never learns; `message` is the fallback.
+   */
+  translatedMessage?: TranslatedString | null;
+  kind: NotificationKind;
+  durationMs?: number;
 }
-interface RefreshAttributeOperation {
-    type: 'refreshAttribute';
-    objectTypeId: string;
-    id: string;
-    attributeName: string;
-    value?: unknown;
-    /**
-     * Nested rows of an `AsDetail` attribute. A loaded AsDetail attribute carries its rows in
-     * `object` / `objects` and leaves `value` null, so a patch limited to `value` could never
-     * refresh a detail grid -- it always sent null, and a null over a null repaints nothing.
-     *
-     * An empty `objects` array means the grid is now empty, and is distinct from omitting it.
-     */
-    object?: unknown;
-    objects?: unknown[];
+export interface RefreshAttributeOperation {
+  type: 'refreshAttribute';
+  objectTypeId: string;
+  id: string;
+  attributeName: string;
+  value?: unknown;
+  /**
+   * Nested rows of an `AsDetail` attribute. A loaded AsDetail attribute carries its rows in
+   * `object` / `objects` and leaves `value` null, so a patch limited to `value` could never
+   * refresh a detail grid -- it always sent null, and a null over a null repaints nothing.
+   *
+   * An empty `objects` array means the grid is now empty, and is distinct from omitting it.
+   */
+  object?: unknown;
+  objects?: unknown[];
 }
-interface RefreshQueryOperation {
-    type: 'refreshQuery';
-    queryId: string;
+export interface RefreshQueryOperation {
+  type: 'refreshQuery';
+  queryId: string;
 }
-type DisableTarget = {
-    kind: 'persistentObject';
-    objectTypeId: string;
-    id: string;
-} | {
-    kind: 'query';
-    queryId: string;
-} | {
-    kind: 'currentResponse';
-} | {
-    kind: 'session';
-};
-interface DisableActionOperation {
-    type: 'disableAction';
-    actionName: string;
-    target: DisableTarget;
-}
-interface RetryOperation {
-    type: 'retry';
-    step: number;
-    title: string;
-    options: string[];
-    defaultOption?: string | null;
-    persistentObject?: PersistentObject | null;
-    message?: string | null;
+export interface RetryOperation {
+  type: 'retry';
+  step: number;
+  title: string;
+  options: string[];
+  defaultOption?: string | null;
+  persistentObject?: PersistentObject | null;
+  message?: string | null;
 }
 /**
  * Discriminated union of known operation types, plus an open shape for unknown
  * future operations. Handlers should narrow via the `type` discriminator before
  * accessing fields specific to their operation type.
  */
-type ClientOperation = NavigateOperation | NotifyOperation | RefreshAttributeOperation | RefreshQueryOperation | DisableActionOperation | RetryOperation | {
-    type: string;
-    [key: string]: unknown;
+export type ClientOperation = NavigateOperation | NotifyOperation | RefreshAttributeOperation | RefreshQueryOperation | RetryOperation | {
+  type: string;
+  [key: string]: unknown;
 };
 /**
  * Wire envelope returned by every action endpoint. `result` carries the primary
  * payload (the PersistentObject for a Create, the QueryResult for an Execute,
  * etc.); `operations` carries the side-effects the frontend dispatches.
  */
-interface ClientOperationEnvelope<T = unknown> {
-    result: T | null;
-    operations: ClientOperation[];
+export interface ClientOperationEnvelope<T = unknown> {
+  result: T | null;
+  operations: ClientOperation[];
 }
-
 /**
  * Routes received operations to registered handlers. Unknown operation types
  * (no matching registration) are silently dropped — this is the forward-compat
@@ -105,41 +92,39 @@ interface ClientOperationEnvelope<T = unknown> {
  *   built-in `notify` handler renders via Angular interpolation (escaped) so
  *   it's safe to pass through, but anything more powerful must validate.
  */
-declare class SparkClientOperationDispatcher {
-    private readonly handlerMap;
-    constructor();
-    dispatch(operations: readonly ClientOperation[] | null | undefined): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SparkClientOperationDispatcher, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SparkClientOperationDispatcher>;
+export declare class SparkClientOperationDispatcher {
+  private readonly handlerMap;
+  constructor();
+  dispatch(operations: readonly ClientOperation[] | null | undefined): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkClientOperationDispatcher, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-
 /**
  * A handler for a specific operation type. Receives the operation and
  * executes the side-effect (e.g. show a toast, navigate, refresh a query).
  * Handlers should `as`-narrow the operation to the type they registered for.
  */
-type ClientOperationHandler = (operation: ClientOperation) => void;
+export type ClientOperationHandler = (operation: ClientOperation) => void;
 /**
  * One entry in the multi-provider registration. Apps can register custom
  * handlers alongside the built-in ones to extend the operation set with
  * app-specific operation types.
  */
-interface ClientOperationHandlerRegistration {
-    type: string;
-    handler: ClientOperationHandler;
+export interface ClientOperationHandlerRegistration {
+  type: string;
+  handler: ClientOperationHandler;
 }
 /**
  * Multi-provider token. `provideSparkClientOperations()` registers the
  * built-in handlers; apps can add their own with additional `multi: true`
  * providers using this token.
  */
-declare const SPARK_CLIENT_OPERATION_HANDLERS: InjectionToken<readonly ClientOperationHandlerRegistration[]>;
-
-interface SparkToast {
-    id: string;
-    message: string;
-    kind: NotificationKind;
-    durationMs: number;
+export declare const SPARK_CLIENT_OPERATION_HANDLERS: InjectionToken<readonly ClientOperationHandlerRegistration[]>;
+export interface SparkToast {
+  id: string;
+  message: string;
+  kind: NotificationKind;
+  durationMs: number;
 }
 /**
  * Holds the active toasts as a signal. The `<spark-toast-container>` component
@@ -148,23 +133,21 @@ interface SparkToast {
  * Auto-dismissal: each toast schedules its own removal after `durationMs`. Pass
  * `0` to make a toast sticky (manual dismissal only).
  */
-declare class SparkNotificationService {
-    private readonly _toasts;
-    readonly toasts: i0.Signal<readonly SparkToast[]>;
-    show(message: string, kind?: NotificationKind, durationMs?: number): void;
-    dismiss(id: string): void;
-    clear(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SparkNotificationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SparkNotificationService>;
+export declare class SparkNotificationService {
+  private readonly _toasts;
+  readonly toasts: import("@angular/core").Signal<readonly SparkToast[]>;
+  show(message: string, kind?: NotificationKind, durationMs?: number): void;
+  dismiss(id: string): void;
+  clear(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkNotificationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-
-declare class SparkToastContainerComponent {
-    protected readonly notifications: SparkNotificationService;
-    protected readonly Kind: typeof NotificationKind;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SparkToastContainerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SparkToastContainerComponent, "spark-toast-container", never, {}, {}, never, never, true, never>;
+export declare class SparkToastContainerComponent {
+  protected readonly notifications: SparkNotificationService;
+  protected readonly Kind: typeof NotificationKind;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkToastContainerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkToastContainerComponent, "spark-toast-container", never, {}, {}, never, never, true, never>;
 }
-
 /**
  * Registers the built-in client-operation handlers: `notify`, `refreshQuery`,
  * `refreshAttribute` and `navigate`. Apps add this once in their bootstrap providers.
@@ -176,8 +159,9 @@ declare class SparkToastContainerComponent {
  * That happened twice more before anyone noticed. `refreshAttribute` and `navigate` were both
  * declared wire types with no handler anywhere in the repository: every
  * `IClientAccessor.RefreshAttribute` and `Navigate` call in every Spark application was
- * computed, serialised, sent and discarded. Both are registered below. The remaining gap is
- * `disableAction`, registered purely to log so that it stays visible rather than invisible.
+ * computed, serialised, sent and discarded. Both are registered below. The last gap,
+ * `disableAction`, was closed by deleting it (#460, D13): disabled actions travel on the object's
+ * or result's `disabledActions` and are enforced by the server at submit.
  *
  * The lesson worth keeping: a wire type in `operations.ts` is not a feature. Adding one without
  * a handler here produces a server API that appears to work and does nothing.
@@ -185,8 +169,7 @@ declare class SparkToastContainerComponent {
  * To register custom operation types alongside the built-ins, add additional
  * `multi: true` providers using <see cref="SPARK_CLIENT_OPERATION_HANDLERS" />.
  */
-declare function provideSparkClientOperations(): EnvironmentProviders;
-
+export declare function provideSparkClientOperations(): EnvironmentProviders;
 /**
  * Carries a server-issued `refreshQuery` to whichever grids are showing that query.
  *
@@ -199,25 +182,24 @@ declare function provideSparkClientOperations(): EnvironmentProviders;
  * `notify` was registered, and unknown types are ignored silently — so `refreshOnCompleted`
  * on the server had no effect on any grid the action did not happen to be hosted in.
  */
-declare class SparkQueryRefreshService {
-    private readonly tokens;
-    /** Bumped every time the server asks for this query to refresh. */
-    tokenFor(queryId: string | undefined): number;
-    /**
-     * Ask every grid showing `queryId` to re-fetch.
-     *
-     * Matched on the EXACT string a grid passes to {@link tokenFor} -- whichever of id or alias
-     * its `queryId` input holds. A caller that knows only the other form will not reach it.
-     *
-     * Callers bumping several keys for one user action should do so in one synchronous run: the
-     * signal coalesces bumps within a tick into a single effect run, and bumps split across an
-     * await become one re-fetch each.
-     */
-    request(queryId: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryRefreshService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SparkQueryRefreshService>;
+export declare class SparkQueryRefreshService {
+  private readonly tokens;
+  /** Bumped every time the server asks for this query to refresh. */
+  tokenFor(queryId: string | undefined): number;
+  /**
+   * Ask every grid showing `queryId` to re-fetch.
+   *
+   * Matched on the EXACT string a grid passes to {@link tokenFor} -- whichever of id or alias
+   * its `queryId` input holds. A caller that knows only the other form will not reach it.
+   *
+   * Callers bumping several keys for one user action should do so in one synchronous run: the
+   * signal coalesces bumps within a tick into a single effect run, and bumps split across an
+   * await become one re-fetch each.
+   */
+  request(queryId: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryRefreshService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-
 /**
  * Carries a server-issued `refreshAttribute` to whichever detail page is showing that object.
  *
@@ -246,40 +228,37 @@ declare class SparkQueryRefreshService {
  * Only the keys the server sent are present, and each is applied on its own. An `objects: []`
  * means the grid is now empty, which is why emptiness has to be distinguishable from absence.
  */
-interface SparkAttributePatch {
-    value?: unknown;
-    object?: unknown;
-    objects?: unknown[];
-}
-declare class SparkAttributeRefreshService {
-    private readonly tokens;
-    private readonly patches;
-    /**
-     * Objects are keyed by type AND id: the same id can exist under two types, and a detail page
-     * only ever wants the attributes meant for the object it is showing.
-     */
-    private static keyFor;
-    /** Bumped every time the server patches an attribute of this object. */
-    tokenFor(objectTypeId: string | undefined | null, id: string | undefined | null): number;
-    /**
-     * The newest value the server sent for each patched attribute of this object.
-     *
-     * Cumulative rather than drained on read: a detail page that mounts after the operation arrived
-     * still sees the value, and two pages showing the same object both get it. Values are overwritten
-     * by later patches, so this holds one entry per attribute, not a history.
-     */
-    patchesFor(objectTypeId: string | undefined | null, id: string | undefined | null): Record<string, SparkAttributePatch>;
-    /**
-     * Record a new value for one attribute and wake whoever is showing the object.
-     *
-     * Callers patching several attributes for one user action should do so in one synchronous run:
-     * the signals coalesce within a tick into a single effect run, and patches split across an await
-     * become one run each.
-     */
-    request(objectTypeId: string, id: string, attributeName: string, patch: SparkAttributePatch): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SparkAttributeRefreshService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SparkAttributeRefreshService>;
+export interface SparkAttributePatch {
+  value?: unknown;
+  object?: unknown;
+  objects?: unknown[];
 }
-
-export { NotificationKind, SPARK_CLIENT_OPERATION_HANDLERS, SparkAttributeRefreshService, SparkClientOperationDispatcher, SparkNotificationService, SparkQueryRefreshService, SparkToastContainerComponent, provideSparkClientOperations };
-export type { ClientOperation, ClientOperationEnvelope, ClientOperationHandler, ClientOperationHandlerRegistration, DisableActionOperation, DisableTarget, NavigateOperation, NotifyOperation, RefreshAttributeOperation, RefreshQueryOperation, RetryOperation, SparkAttributePatch, SparkToast };
+export declare class SparkAttributeRefreshService {
+  private readonly tokens;
+  private readonly patches;
+  /**
+   * Objects are keyed by type AND id: the same id can exist under two types, and a detail page
+   * only ever wants the attributes meant for the object it is showing.
+   */
+  private static keyFor;
+  /** Bumped every time the server patches an attribute of this object. */
+  tokenFor(objectTypeId: string | undefined | null, id: string | undefined | null): number;
+  /**
+   * The newest value the server sent for each patched attribute of this object.
+   *
+   * Cumulative rather than drained on read: a detail page that mounts after the operation arrived
+   * still sees the value, and two pages showing the same object both get it. Values are overwritten
+   * by later patches, so this holds one entry per attribute, not a history.
+   */
+  patchesFor(objectTypeId: string | undefined | null, id: string | undefined | null): Record<string, SparkAttributePatch>;
+  /**
+   * Record a new value for one attribute and wake whoever is showing the object.
+   *
+   * Callers patching several attributes for one user action should do so in one synchronous run:
+   * the signals coalesce within a tick into a single effect run, and patches split across an await
+   * become one run each.
+   */
+  request(objectTypeId: string, id: string, attributeName: string, patch: SparkAttributePatch): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkAttributeRefreshService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/types/mintplayer-ng-spark-column-filter.d.ts

@@ -1,7 +1,6 @@
-import * as _angular_core from '@angular/core';
-import { DistinctValues, FilterContext, DistinctValue } from '@mintplayer/ng-bootstrap/datatable';
-import { QueryColumn } from '@mintplayer/ng-spark/models';
-
+import { DistinctValue, DistinctValues, FilterContext } from "@mintplayer/ng-bootstrap/datatable";
+import { QueryColumn } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
 /**
  * The contents of one column's filter panel (#431).
  *
@@ -24,54 +23,73 @@ import { QueryColumn } from '@mintplayer/ng-spark/models';
  * `.form-control` and `.btn` do not reach it — they are only styled inside `bs-*` components. Every
  * visual here is explicit.
  */
-declare class SparkColumnFilterPanelComponent {
-    readonly column: _angular_core.InputSignal<QueryColumn>;
-    /** The datatable's bucketed list, or null while nothing has loaded. */
-    readonly values: _angular_core.InputSignal<DistinctValues | null>;
-    readonly ctx: _angular_core.InputSignal<FilterContext>;
-    /**
-     * Optional relabelling for a column with a custom cell renderer.
-     *
-     * A renderer is a component that paints arbitrary DOM, and a distinct value has no row, so it
-     * cannot be instantiated to produce text. The label therefore defaults to the server-computed cell
-     * text — a status rendered as a coloured pill lists `Active`, a rating rendered as stars lists `3`.
-     * This hook is the escape for the case where that is too raw: a pure function, no DOM, no row.
-     */
-    readonly filterLabel: _angular_core.InputSignal<((value: unknown) => string) | null>;
-    /** Whether this column offers a value list at all, or only free text. */
-    protected readonly listsDistincts: _angular_core.Signal<boolean>;
-    /** Selected values, by value. Identity is the value, never the label — two rows may share text. */
-    private readonly selected;
-    protected readonly inverse: _angular_core.WritableSignal<boolean>;
-    protected readonly freeText: _angular_core.WritableSignal<string>;
-    protected readonly hasSelection: _angular_core.Signal<boolean>;
-    protected readonly matching: _angular_core.Signal<DistinctValue[]>;
-    protected readonly remaining: _angular_core.Signal<DistinctValue[]>;
-    protected readonly hasMore: _angular_core.Signal<boolean>;
-    /**
-     * Whether to show the empty state.
-     *
-     * Covers three states on purpose: nothing loaded yet, nothing matched, and the distinct request
-     * failed. The datatable swallows a rejected promise into a null list with no error, so the third
-     * is not distinguishable here - and the server already refuses to distinguish "no values" from
-     * "you may not list them".
-     */
-    protected readonly isEmpty: _angular_core.Signal<boolean>;
-    protected labelFor(value: DistinctValue): string;
-    protected isChecked(value: DistinctValue): boolean;
-    protected toggle(value: DistinctValue, checked: boolean): void;
-    protected toggleInverse(): void;
-    protected onSearch(term: string): void;
-    /**
-     * Applies the free-text filter of a column whose values may not be enumerated.
-     *
-     * It goes through the same `apply` as a checkbox list, carrying one synthetic entry, so the grid
-     * has exactly one event shape to translate and no second wire form to maintain.
-     */
-    protected applyFreeText(): void;
-    protected clear(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkColumnFilterPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkColumnFilterPanelComponent, "spark-column-filter-panel", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "ctx": { "alias": "ctx"; "required": true; "isSignal": true; }; "filterLabel": { "alias": "filterLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { SparkColumnFilterPanelComponent };
+export declare class SparkColumnFilterPanelComponent {
+  readonly column: import("@angular/core").InputSignal<QueryColumn>;
+  /** The datatable's bucketed list, or null while nothing has loaded. */
+  readonly values: import("@angular/core").InputSignal<DistinctValues | null>;
+  readonly ctx: import("@angular/core").InputSignal<FilterContext>;
+  /**
+   * Optional relabelling for a column with a custom cell renderer.
+   *
+   * A renderer is a component that paints arbitrary DOM, and a distinct value has no row, so it
+   * cannot be instantiated to produce text. The label therefore defaults to the server-computed cell
+   * text — a status rendered as a coloured pill lists `Active`, a rating rendered as stars lists `3`.
+   * This hook is the escape for the case where that is too raw: a pure function, no DOM, no row.
+   */
+  readonly filterLabel: import("@angular/core").InputSignal<((value: unknown) => string) | null>;
+  /** Whether this column offers a value list at all, or only free text. */
+  protected readonly listsDistincts: import("@angular/core").Signal<boolean>;
+  /** Selected values, by value. Identity is the value, never the label — two rows may share text. */
+  private readonly selected;
+  protected readonly inverse: import("@angular/core").WritableSignal<boolean>;
+  protected readonly freeText: import("@angular/core").WritableSignal<string>;
+  protected readonly hasSelection: import("@angular/core").Signal<boolean>;
+  protected readonly matching: import("@angular/core").Signal<DistinctValue[]>;
+  protected readonly remaining: import("@angular/core").Signal<DistinctValue[]>;
+  protected readonly hasMore: import("@angular/core").Signal<boolean>;
+  /**
+   * Whether to show the empty state.
+   *
+   * Covers three states on purpose: nothing loaded yet, nothing matched, and the distinct request
+   * failed. The datatable swallows a rejected promise into a null list with no error, so the third
+   * is not distinguishable here - and the server already refuses to distinguish "no values" from
+   * "you may not list them".
+   */
+  protected readonly isEmpty: import("@angular/core").Signal<boolean>;
+  protected labelFor(value: DistinctValue): string;
+  protected isChecked(value: DistinctValue): boolean;
+  protected toggle(value: DistinctValue, checked: boolean): void;
+  protected toggleInverse(): void;
+  protected onSearch(term: string): void;
+  /**
+   * Applies the free-text filter of a column whose values may not be enumerated.
+   *
+   * It goes through the same `apply` as a checkbox list, carrying one synthetic entry, so the grid
+   * has exactly one event shape to translate and no second wire form to maintain.
+   */
+  protected applyFreeText(): void;
+  protected clear(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkColumnFilterPanelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkColumnFilterPanelComponent, "spark-column-filter-panel", never, {
+    "column": {
+      "alias": "column";
+      "required": true;
+      "isSignal": true;
+    };
+    "values": {
+      "alias": "values";
+      "required": false;
+      "isSignal": true;
+    };
+    "ctx": {
+      "alias": "ctx";
+      "required": true;
+      "isSignal": true;
+    };
+    "filterLabel": {
+      "alias": "filterLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}