@mintplayer/ng-spark 22.23.0 → 22.25.0

package/types/mintplayer-ng-spark-query-list.d.ts

@@ -1,10 +1,10 @@
-import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { QueryResultItem, CustomActionDefinition, QueryColumn } from '@mintplayer/ng-spark/models';
-import * as _angular_core from '@angular/core';
-import { TemplateRef } from '@angular/core';
-import { Color } from '@mintplayer/ng-bootstrap';
-import { SparkLanguageService } from '@mintplayer/ng-spark/services';
-
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { Color } from "@mintplayer/ng-bootstrap";
+import { SparkLanguageService } from "@mintplayer/ng-spark/services";
+import { SparkQueryToolbarAction } from "@mintplayer/ng-spark/grid";
+import { CustomActionDefinition, QueryColumn, QueryColumnFilter, QueryResultItem, SparkDeletedFilter } from "@mintplayer/ng-spark/models";
+import { SparkQueryListContext } from "@mintplayer/ng-spark/panels";
 /**
  * The routed query page: chrome around one {@link SparkQueryGridComponent}.
  *
@@ -22,78 +22,139 @@ import { SparkLanguageService } from '@mintplayer/ng-spark/services';
  * is the shared component. This page previously wrote out `<bs-datatable>` twice, once per
  * transport, with a shared row template between them; both are gone.
  */
-declare class SparkQueryListComponent {
-    private readonly route;
-    private readonly router;
-    private readonly sparkService;
-    private readonly streamingService;
-    private readonly destroyRef;
-    protected readonly lang: SparkLanguageService;
-    extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
-    showCustomActions: _angular_core.InputSignal<boolean>;
-    /**
-     * Forwarded to the grid, so a query PAGE can replace its row links — the same reason the card
-     * forwards it. Without this the escape hatch existed only for a directly-embedded grid.
-     */
-    rowRoute: _angular_core.InputSignal<((row: QueryResultItem) => unknown[] | null) | null>;
-    rowClicked: _angular_core.OutputEmitterRef<QueryResultItem>;
-    createClicked: _angular_core.OutputEmitterRef<void>;
-    customActionExecuted: _angular_core.OutputEmitterRef<{
-        action: CustomActionDefinition;
-    }>;
-    colors: typeof Color;
-    /** The query the grid should render, resolved from the route. Null until it is known. */
-    queryId: _angular_core.WritableSignal<string | null>;
-    errorMessage: _angular_core.WritableSignal<string | null>;
-    searchTerm: _angular_core.WritableSignal<string>;
-    private readonly grid;
-    /**
-     * Grid state, surfaced for this page's chrome.
-     *
-     * Optional `viewChild`, read defensively: the action bar and caption render above the grid, so
-     * on the first change-detection pass the query has not resolved yet.
-     */
-    protected readonly query: _angular_core.Signal<_mintplayer_ng_spark_models.SparkQuery | null>;
-    protected readonly entityType: _angular_core.Signal<_mintplayer_ng_spark_models.EntityType | null>;
-    protected readonly customActions: _angular_core.Signal<CustomActionDefinition[]>;
-    protected readonly canCreate: _angular_core.Signal<boolean>;
-    protected readonly resultCount: _angular_core.Signal<number | null>;
-    protected readonly isVirtualScrolling: _angular_core.Signal<boolean>;
-    protected readonly gridError: _angular_core.Signal<string | null>;
-    /** Whether an action's selection rule is satisfied. Delegated: the grid holds the selection. */
-    /** @see SparkPoDetailComponent.customActionClass — same allow-list, same default. */
-    protected customActionClass(action: CustomActionDefinition): string;
-    protected isActionEnabled(action: CustomActionDefinition): boolean;
-    isStreaming: _angular_core.WritableSignal<boolean>;
-    private streamingSub;
-    /** Columns as sent with the stream's snapshot; empty until it arrives. */
-    protected readonly streamColumns: _angular_core.WritableSignal<QueryColumn[]>;
-    private readonly allItems;
-    private readonly streamItems;
-    /**
-     * Rows handed to the grid, or `null` to let it fetch for itself.
-     *
-     * Null for a normal query — an empty array would read as "here are no rows" and suppress the
-     * fetch entirely.
-     */
-    protected readonly gridData: _angular_core.Signal<QueryResultItem[] | null>;
-    constructor();
-    private onParamsChange;
-    /**
-     * A load failure has to render, not just be swallowed: a denied query answers 404 (audit M-3, so
-     * existence is not leaked), which is indistinguishable from a missing one — hence a deliberately
-     * generic message rather than a guess at which it was.
-     */
-    private reportLoadFailure;
-    protected onCustomAction(action: CustomActionDefinition): Promise<void>;
-    protected onCreate(): void;
-    protected clearSearch(): void;
-    private connectStreaming;
-    private disconnectStreaming;
-    private handleStreamingMessage;
-    private applyFilter;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryListComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkQueryListComponent, "spark-query-list", never, { "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; "showCustomActions": { "alias": "showCustomActions"; "required": false; "isSignal": true; }; "rowRoute": { "alias": "rowRoute"; "required": false; "isSignal": true; }; }, { "rowClicked": "rowClicked"; "createClicked": "createClicked"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
-}
-
-export { SparkQueryListComponent };
+export declare class SparkQueryListComponent {
+  private readonly route;
+  private readonly router;
+  private readonly sparkService;
+  private readonly streamingService;
+  private readonly destroyRef;
+  protected readonly lang: SparkLanguageService;
+  extraActionsTemplate: import("@angular/core").InputSignal<TemplateRef<void> | null>;
+  showCustomActions: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Forwarded to the grid, so a query PAGE can replace its row links — the same reason the card
+   * forwards it. Without this the escape hatch existed only for a directly-embedded grid.
+   */
+  rowRoute: import("@angular/core").InputSignal<((row: QueryResultItem) => unknown[] | null) | null>;
+  rowClicked: import("@angular/core").OutputEmitterRef<QueryResultItem>;
+  createClicked: import("@angular/core").OutputEmitterRef<void>;
+  customActionExecuted: import("@angular/core").OutputEmitterRef<{
+    action: CustomActionDefinition;
+  }>;
+  colors: typeof Color;
+  /** The query the grid should render, resolved from the route. Null until it is known. */
+  queryId: import("@angular/core").WritableSignal<string | null>;
+  errorMessage: import("@angular/core").WritableSignal<string | null>;
+  searchTerm: import("@angular/core").WritableSignal<string>;
+  private readonly grid;
+  /**
+   * Grid state, surfaced for this page's chrome.
+   *
+   * Optional `viewChild`, read defensively: the action bar and caption render above the grid, so
+   * on the first change-detection pass the query has not resolved yet.
+   */
+  protected readonly query: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").SparkQuery | null>;
+  protected readonly entityType: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").EntityType | null>;
+  protected readonly customActions: import("@angular/core").Signal<CustomActionDefinition[]>;
+  protected readonly canCreate: import("@angular/core").Signal<boolean>;
+  protected readonly resultCount: import("@angular/core").Signal<number | null>;
+  protected readonly isVirtualScrolling: import("@angular/core").Signal<boolean>;
+  protected readonly gridError: import("@angular/core").Signal<string | null>;
+  protected readonly permissions: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").EntityPermissions | null>;
+  /** Add-on buttons for the action bar (#460, `SPARK_QUERY_LIST_ACTIONS`), e.g. the Deleted toggle. */
+  protected readonly listActions: import("@mintplayer/ng-spark/panels").SparkQueryListAction[];
+  /**
+   * The soft-deletion mode (#460, T2), read from the route's `?deleted=` so the recycle bin survives
+   * a reload and the back button from a row opened in it. `exclude` unless the route says otherwise.
+   */
+  protected readonly deletedMode: import("@angular/core").WritableSignal<SparkDeletedFilter>;
+  /** Bumped by `context.reload()`; the grid treats any new value as "re-run the query". */
+  private readonly reloadToken;
+  protected readonly listContext: import("@angular/core").Signal<SparkQueryListContext | null>;
+  protected readonly gridReloadToken: import("@angular/core").Signal<number>;
+  private setDeleted;
+  /** Whether an action's selection rule is satisfied. Delegated: the grid holds the selection. */
+  /** @see SparkPoDetailComponent.customActionClass — same allow-list, same default. */
+  protected customActionClass(action: CustomActionDefinition): string;
+  /** The grid's toolbar model (#460, M15), the same list the sub-query card renders. */
+  protected readonly toolbarActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
+  protected toolbarActionClass(action: SparkQueryToolbarAction): string;
+  protected isToolbarActionEnabled(action: SparkQueryToolbarAction): boolean;
+  protected runToolbarAction(action: SparkQueryToolbarAction): void;
+  protected isActionEnabled(action: CustomActionDefinition): boolean;
+  isStreaming: import("@angular/core").WritableSignal<boolean>;
+  private streamingSub;
+  /** Columns as sent with the stream's snapshot; empty until it arrives. */
+  protected readonly streamColumns: import("@angular/core").WritableSignal<QueryColumn[]>;
+  private readonly allItems;
+  private readonly streamItems;
+  /**
+   * Rows handed to the grid, or `null` to let it fetch for itself.
+   *
+   * Null for a normal query — an empty array would read as "here are no rows" and suppress the
+   * fetch entirely.
+   */
+  protected readonly gridData: import("@angular/core").Signal<QueryResultItem[] | null>;
+  constructor();
+  /**
+   * The parent the URL scopes the query to (`?parentId=…&parentType=…`), sent exactly as a sub-query
+   * sends its container. Both or neither: one without the other is ignored, as the server does.
+   */
+  protected readonly urlParentId: import("@angular/core").WritableSignal<string>;
+  protected readonly urlParentType: import("@angular/core").WritableSignal<string>;
+  /**
+   * Column filters from the URL: every other query-string parameter, `?Language=en&Script=Latn`
+   * (repeat a name for several values). The grid applies only those naming an attribute of the
+   * query's type; the rest are ignored. This is the contributions History link's shape, and works for
+   * any query.
+   */
+  protected readonly urlFilters: import("@angular/core").WritableSignal<QueryColumnFilter[]>;
+  /** The URL filters the grid applied, as removable chips. */
+  protected readonly activeUrlFilters: import("@angular/core").Signal<QueryColumnFilter[]>;
+  /** Query-string names the page or the row links own, never column filters. */
+  private static readonly reservedParams;
+  private applyUrlScope;
+  /** Drops one URL filter (its query-string parameter); the grid refetches. */
+  protected clearUrlFilter(name: string): void;
+  /** Drops the parent and every URL filter. */
+  protected clearUrlScope(): void;
+  protected filterValues(filter: QueryColumnFilter): string;
+  /** The column's label for a chip: the query's own column label, else the attribute's, else its name. */
+  protected filterLabel(name: string): string;
+  private onParamsChange;
+  /**
+   * A load failure has to render, not just be swallowed: a denied query answers 404 (audit M-3, so
+   * existence is not leaked), which is indistinguishable from a missing one — hence a deliberately
+   * generic message rather than a guess at which it was.
+   */
+  private reportLoadFailure;
+  protected onCustomAction(action: CustomActionDefinition): Promise<void>;
+  protected onCreate(): void;
+  protected clearSearch(): void;
+  private connectStreaming;
+  private disconnectStreaming;
+  private handleStreamingMessage;
+  private applyFilter;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkQueryListComponent, "spark-query-list", never, {
+    "extraActionsTemplate": {
+      "alias": "extraActionsTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "showCustomActions": {
+      "alias": "showCustomActions";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowRoute": {
+      "alias": "rowRoute";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "rowClicked": "rowClicked";
+    "createClicked": "createClicked";
+    "customActionExecuted": "customActionExecuted";
+  }, never, never, true, never>;
+}

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

@@ -1,11 +1,10 @@
-import { Type, InputSignal, InjectionToken, Provider } from '@angular/core';
-import { QueryResultItemValue, PersistentObjectAttribute, SparkCellColumn, QueryResultItem, EntityAttributeDefinition, PersistentObject } from '@mintplayer/ng-spark/models';
-
+import { InjectionToken, InputSignal, Provider, Type } from "@angular/core";
+import { EntityAttributeDefinition, EntityType, PersistentObject, PersistentObjectAttribute, QueryResultItem, QueryResultItemValue, SparkCellColumn } from "@mintplayer/ng-spark/models";
 /**
  * Drops entries the component doesn't declare, so every contract member is
  * genuinely optional — NgComponentOutlet throws on an undeclared input.
  */
-declare function withDeclaredInputs(component: Type<any>, inputs: Record<string, any>): Record<string, any>;
+export declare function withDeclaredInputs(component: Type<any>, inputs: Record<string, any>): Record<string, any>;
 /**
  * The renderer-facing value of an attribute: the flat value, or for AsDetail
  * attributes (whose flat value the server nulls on purpose) the nested
@@ -13,7 +12,7 @@ declare function withDeclaredInputs(component: Type<any>, inputs: Record<string,
  *
  * Used by the detail and edit paths, which still work in attributes.
  */
-declare function rendererValue(attr: PersistentObjectAttribute | undefined): any;
+export declare function rendererValue(attr: PersistentObjectAttribute | undefined): any;
 /**
  * The renderer-facing value of a query-result cell.
  *
@@ -24,98 +23,121 @@ declare function rendererValue(attr: PersistentObjectAttribute | undefined): any
  * stops a renderer silently receiving `undefined` because it was written against the attribute
  * shape's `object` / `objects` fields, which a row does not carry.
  */
-declare function cellValue(value: QueryResultItemValue | undefined): any;
-
+export declare function cellValue(value: QueryResultItemValue | undefined): any;
 /**
  * Contract for detail-page renderers (spark-po-detail).
  * Displays a single attribute value in the PO detail view.
  */
-interface SparkAttributeDetailRenderer {
-    /**
-     * The current attribute value. For an AsDetail attribute this is the nested
-     * PersistentObject (single) or PersistentObject[] (array).
-     */
-    value?: InputSignal<any>;
-    /** The attribute definition metadata */
-    attribute?: InputSignal<EntityAttributeDefinition | undefined>;
-    /** Renderer-specific options from rendererOptions */
-    options?: InputSignal<Record<string, any> | undefined>;
-    /** The full form data (for cross-field dependencies); AsDetail keys carry the nested PO(s) */
-    formData?: InputSignal<Record<string, any>>;
-    /** The full PersistentObject being displayed — ids/breadcrumbs the flattened formData drops */
-    item?: InputSignal<PersistentObject | undefined>;
+export interface SparkAttributeDetailRenderer {
+  /**
+   * The current attribute value. For an AsDetail attribute this is the nested
+   * PersistentObject (single) or PersistentObject[] (array).
+   */
+  value?: InputSignal<any>;
+  /** The attribute definition metadata */
+  attribute?: InputSignal<EntityAttributeDefinition | undefined>;
+  /** Renderer-specific options from rendererOptions */
+  options?: InputSignal<Record<string, any> | undefined>;
+  /** The full form data (for cross-field dependencies); AsDetail keys carry the nested PO(s) */
+  formData?: InputSignal<Record<string, any>>;
+  /** The full PersistentObject being displayed — ids/breadcrumbs the flattened formData drops */
+  item?: InputSignal<PersistentObject | undefined>;
 }
 /**
  * Contract for query-list column renderers (spark-query-list).
  * Displays a compact cell value in the list/grid view.
  */
-interface SparkAttributeColumnRenderer {
-    /**
-     * The cell value. For an AsDetail column this is the nested PersistentObject (single) /
-     * PersistentObject[] (array) in an AsDetail sub-table, and the projected value in a query grid.
-     */
-    value?: InputSignal<any>;
-    /**
-     * The column being rendered.
-     *
-     * A query grid supplies a {@link SparkCellColumn} from the result own column metadata; an
-     * AsDetail sub-table supplies its attribute definition, which satisfies the same shape. This
-     * replaced an `attribute` input typed as the definition: a query result no longer carries
-     * attribute metadata per row, so naming it `attribute` would promise something the grid cannot
-     * deliver.
-     */
-    column?: InputSignal<SparkCellColumn | undefined>;
-    /** Renderer-specific options from rendererOptions */
-    options?: InputSignal<Record<string, any> | undefined>;
-    /**
-     * The row this cell belongs to: a {@link QueryResultItem} in a query grid, a plain record
-     * (possibly including the reserved '__sparkBreadcrumbs' key) in AsDetail sub-tables. Passed
-     * only when declared.
-     */
-    item?: InputSignal<QueryResultItem | Record<string, any> | undefined>;
+export interface SparkAttributeColumnRenderer {
+  /**
+   * The cell value. For an AsDetail column this is the nested PersistentObject (single) /
+   * PersistentObject[] (array) in an AsDetail sub-table, and the projected value in a query grid.
+   */
+  value?: InputSignal<any>;
+  /**
+   * The column being rendered.
+   *
+   * A query grid supplies a {@link SparkCellColumn} from the result own column metadata; an
+   * AsDetail sub-table supplies its attribute definition, which satisfies the same shape. This
+   * replaced an `attribute` input typed as the definition: a query result no longer carries
+   * attribute metadata per row, so naming it `attribute` would promise something the grid cannot
+   * deliver.
+   */
+  column?: InputSignal<SparkCellColumn | undefined>;
+  /** Renderer-specific options from rendererOptions */
+  options?: InputSignal<Record<string, any> | undefined>;
+  /**
+   * The row this cell belongs to: a {@link QueryResultItem} in a query grid, a plain record
+   * (possibly including the reserved '__sparkBreadcrumbs' key) in AsDetail sub-tables. Passed
+   * only when declared.
+   */
+  item?: InputSignal<QueryResultItem | Record<string, any> | undefined>;
+}
+/**
+ * Contract for AsDetail **row** renderers (`rowComponent` of a registration): drawn once per row of an
+ * AsDetail table, on the detail page and in the edit form, for the row-type attributes carrying the
+ * renderer — which are then not drawn as columns.
+ */
+export interface SparkAttributeRowRenderer {
+  /** The row: a flat record of the row's values (reserved `__spark…` keys included). */
+  row?: InputSignal<Record<string, any>>;
+  /** The row-type attributes carrying this renderer, in model order. */
+  attributes?: InputSignal<EntityAttributeDefinition[]>;
+  /** `rendererOptions` of the first of them. */
+  options?: InputSignal<Record<string, any> | undefined>;
+  /** The id of the object that owns the AsDetail list (undefined on a create page). */
+  ownerId?: InputSignal<string | undefined>;
 }
 /**
  * Contract for edit-form renderers (spark-po-form on create/edit pages).
  * Replaces the default <input> for this attribute.
  */
-interface SparkAttributeEditRenderer {
-    /** The current attribute value */
-    value?: InputSignal<any>;
-    /** The attribute definition metadata */
-    attribute?: InputSignal<EntityAttributeDefinition | undefined>;
-    /** Renderer-specific options from rendererOptions */
-    options?: InputSignal<Record<string, any> | undefined>;
-    /**
-     * Callback to notify parent form of value changes (since NgComponentOutlet
-     * doesn't support outputs). Not declaring it disables write-back.
-     */
-    valueChange?: InputSignal<(value: any) => void>;
+export interface SparkAttributeEditRenderer {
+  /** The current attribute value */
+  value?: InputSignal<any>;
+  /** The attribute definition metadata */
+  attribute?: InputSignal<EntityAttributeDefinition | undefined>;
+  /** Renderer-specific options from rendererOptions */
+  options?: InputSignal<Record<string, any> | undefined>;
+  /**
+   * Callback to notify parent form of value changes (since NgComponentOutlet
+   * doesn't support outputs). Not declaring it disables write-back.
+   */
+  valueChange?: InputSignal<(value: any) => void>;
 }
-
-interface SparkAttributeRendererRegistration {
-    /** The renderer name (must match attr.renderer in model JSON) */
-    name: string;
-    /** Component for the PO detail page. Must implement SparkAttributeDetailRenderer. Omit for a column/edit-only renderer. */
-    detailComponent?: Type<any> | null;
-    /** Component for query-list column cells. Must implement SparkAttributeColumnRenderer. Omit for a detail/edit-only renderer. */
-    columnComponent?: Type<any> | null;
-    /** Optional component for create/edit forms. Must implement SparkAttributeEditRenderer. When omitted, the default input is used. */
-    editComponent?: Type<any>;
-    /**
-     * Relabels this column's values in a filter panel (#431).
-     *
-     * A renderer is a component that paints arbitrary DOM, and a distinct value has no row, so it
-     * cannot be instantiated to produce text for a filter list. 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 is the escape for when that is too raw — a value stored as
-     * `2` whose cell reads "High priority".
-     *
-     * ⚠️ A **pure function**: no DOM, no component instantiation, no row context. There is no row to
-     * give it, which is the whole reason the renderer itself cannot be used here.
-     */
-    filterLabel?: (value: unknown) => string;
+export interface SparkAttributeRendererRegistration {
+  /** The renderer name (must match attr.renderer in model JSON) */
+  name: string;
+  /** Component for the PO detail page. Must implement SparkAttributeDetailRenderer. Omit for a column/edit-only renderer. */
+  detailComponent?: Type<any> | null;
+  /** Component for query-list column cells. Must implement SparkAttributeColumnRenderer. Omit for a detail/edit-only renderer. */
+  columnComponent?: Type<any> | null;
+  /** Optional component for create/edit forms. Must implement SparkAttributeEditRenderer. When omitted, the default input is used. */
+  editComponent?: Type<any>;
+  /**
+   * A **row** renderer for AsDetail tables (the PO detail page and the edit form). Attributes of a row
+   * type that carry this renderer are not drawn as columns; instead the component is drawn ONCE per
+   * row, under the row's first cell, given all of them. Must implement {@link SparkAttributeRowRenderer}.
+   *
+   * For facts about a row rather than columns of it — contributions' "by Alice · 3 days ago ·
+   * History (4)" line collapses three read-only attributes into one. `rendererOptions` are taken from
+   * the first such attribute (a library writes the same options on each).
+   */
+  rowComponent?: Type<any>;
+  /**
+   * Relabels this column's values in a filter panel (#431).
+   *
+   * A renderer is a component that paints arbitrary DOM, and a distinct value has no row, so it
+   * cannot be instantiated to produce text for a filter list. 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 is the escape for when that is too raw — a value stored as
+   * `2` whose cell reads "High priority".
+   *
+   * ⚠️ A **pure function**: no DOM, no component instantiation, no row context. There is no row to
+   * give it, which is the whole reason the renderer itself cannot be used here.
+   */
+  filterLabel?: (value: unknown) => string;
 }
-declare const SPARK_ATTRIBUTE_RENDERERS: InjectionToken<SparkAttributeRendererRegistration[]>;
+export declare const SPARK_ATTRIBUTE_RENDERERS: InjectionToken<SparkAttributeRendererRegistration[]>;
 /**
  * Register custom attribute renderers globally.
  *
@@ -125,7 +147,21 @@ declare const SPARK_ATTRIBUTE_RENDERERS: InjectionToken<SparkAttributeRendererRe
  *   { name: 'color-swatch', detailComponent: ColorDetailComponent, columnComponent: ColorColumnComponent },
  * ])
  */
-declare function provideSparkAttributeRenderers(renderers: SparkAttributeRendererRegistration[]): Provider;
-
-export { SPARK_ATTRIBUTE_RENDERERS, cellValue, provideSparkAttributeRenderers, rendererValue, withDeclaredInputs };
-export type { SparkAttributeColumnRenderer, SparkAttributeDetailRenderer, SparkAttributeEditRenderer, SparkAttributeRendererRegistration };
+export declare function provideSparkAttributeRenderers(renderers: SparkAttributeRendererRegistration[]): Provider;
+/** The row renderer of an AsDetail row type, resolved once per type (see `rowComponent`). */
+export interface SparkResolvedRowRenderer {
+  component: Type<any>;
+  /** The row-type attributes carrying the renderer, in model order. */
+  attributes: EntityAttributeDefinition[];
+  /** `rendererOptions` of the first of them. */
+  options: Record<string, any> | undefined;
+}
+/** Whether `attribute` is drawn by a row renderer (and therefore not as a column). */
+export declare function isRowRendered(attribute: EntityAttributeDefinition, registry: readonly SparkAttributeRendererRegistration[] | null | undefined): boolean;
+/**
+ * The first row renderer the row type's visible attributes name, or null. One per row: a row type
+ * whose attributes name two different row renderers gets the first in model order.
+ */
+export declare function resolveRowRenderer(rowType: EntityType | null | undefined, registry: readonly SparkAttributeRendererRegistration[] | null | undefined): SparkResolvedRowRenderer | null;
+/** The input bag for a row renderer, filtered to what the component declares. */
+export declare function rowRendererInputs(renderer: SparkResolvedRowRenderer, row: Record<string, any>, ownerId: string | undefined): Record<string, any>;

package/types/mintplayer-ng-spark-retry-action-modal.d.ts

@@ -1,8 +1,7 @@
-import * as _angular_core from '@angular/core';
-import { Color } from '@mintplayer/ng-bootstrap';
-import { RetryActionService } from '@mintplayer/ng-spark/services';
-import { EntityType } from '@mintplayer/ng-spark/models';
-
+import { Color } from "@mintplayer/ng-bootstrap";
+import { RetryActionService } from "@mintplayer/ng-spark/services";
+import { EntityType } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
 /**
  * Renders a retry-action popup. Before PRD §3 this component rendered title / message /
  * option buttons only and silently forwarded the incoming <c>persistentObject</c> back to
@@ -12,32 +11,30 @@ import { EntityType } from '@mintplayer/ng-spark/models';
  * field, and the values the user fills in flow back to the server via
  * <c>RetryResult.PersistentObject</c>.
  */
-declare class SparkRetryActionModalComponent {
-    protected readonly retryActionService: RetryActionService;
-    private readonly sparkService;
-    colors: typeof Color;
-    isOpen: _angular_core.Signal<boolean>;
-    /**
-     * EntityType definition for the incoming PO — fetched lazily via SparkService so the
-     * form knows which attributes are editable, their labels, rules, renderers, etc.
-     * `null` when the payload has no persistentObject or its objectTypeId doesn't match
-     * any registered entity type (renders the modal as a simple option picker).
-     */
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    formData: _angular_core.WritableSignal<Record<string, any>>;
-    private allEntityTypes;
-    constructor();
-    private seedForm;
-    onOption(option: string): void;
-    /**
-     * Builds the PO the server sees under <c>Retry.Result.PersistentObject</c>. If the
-     * form resolved an EntityType, rebuild from the schema + formData (identical to the
-     * po-edit save path — AsDetail recursion included). Otherwise forward the incoming
-     * PO unmodified so pre-§3 flows without editable attributes keep working.
-     */
-    private populatedPersistentObject;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkRetryActionModalComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkRetryActionModalComponent, "spark-retry-action-modal", never, {}, {}, never, never, true, never>;
-}
-
-export { SparkRetryActionModalComponent };
+export declare class SparkRetryActionModalComponent {
+  protected readonly retryActionService: RetryActionService;
+  private readonly sparkService;
+  colors: typeof Color;
+  isOpen: import("@angular/core").Signal<boolean>;
+  /**
+   * EntityType definition for the incoming PO — fetched lazily via SparkService so the
+   * form knows which attributes are editable, their labels, rules, renderers, etc.
+   * `null` when the payload has no persistentObject or its objectTypeId doesn't match
+   * any registered entity type (renders the modal as a simple option picker).
+   */
+  entityType: import("@angular/core").WritableSignal<EntityType | null>;
+  formData: import("@angular/core").WritableSignal<Record<string, any>>;
+  private allEntityTypes;
+  constructor();
+  private seedForm;
+  onOption(option: string): void;
+  /**
+   * Builds the PO the server sees under <c>Retry.Result.PersistentObject</c>. If the
+   * form resolved an EntityType, rebuild from the schema + formData (identical to the
+   * po-edit save path — AsDetail recursion included). Otherwise forward the incoming
+   * PO unmodified so pre-§3 flows without editable attributes keep working.
+   */
+  private populatedPersistentObject;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkRetryActionModalComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkRetryActionModalComponent, "spark-retry-action-modal", never, {}, {}, never, never, true, never>;
+}

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

@@ -1,12 +1,8 @@
-import { Route, Routes } from '@angular/router';
-
-interface SparkRouteConfig {
-    queryList?: Route['loadComponent'];
-    poCreate?: Route['loadComponent'];
-    poEdit?: Route['loadComponent'];
-    poDetail?: Route['loadComponent'];
+import { Route, Routes } from "@angular/router";
+export interface SparkRouteConfig {
+  queryList?: Route['loadComponent'];
+  poCreate?: Route['loadComponent'];
+  poEdit?: Route['loadComponent'];
+  poDetail?: Route['loadComponent'];
 }
-declare function sparkRoutes(config?: SparkRouteConfig): Routes;
-
-export { sparkRoutes };
-export type { SparkRouteConfig };
+export declare function sparkRoutes(config?: SparkRouteConfig): Routes;