@mintplayer/ng-spark 22.26.0 → 22.28.0

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

@@ -10,14 +10,6 @@ import { SparkQueryRowAction } from "@mintplayer/ng-spark/panels";
 import { ReferenceChip } from "@mintplayer/ng-spark/pipes";
 /** Page sizes offered by every Spark grid. */
 export declare const SPARK_GRID_PAGE_SIZES: number[];
-/**
- * The attributes a grid shows, in display order.
- *
- * Shared so the two grids cannot disagree about what "visible" means — they each had their own
- * copy of this expression, which is the kind of thing that stays identical right up until it
- * doesn't.
- */
-export declare function visibleGridAttributes(entityType: EntityType | null): EntityAttributeDefinition[];
 /**
  * Initial datatable settings for a query, seeded with the query's declared sort.
  *
@@ -200,21 +192,21 @@ export declare class SparkQueryActionsContext {
   query: SparkQuery | null;
 }
 /**
- * One button of a query's toolbar (#460, M15): the built-in New or Delete, or a custom action.
+ * One button of a query's toolbar (#460 M15, #467 R3): the built-in New, Edit 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' | 'addon';
+  kind: 'new' | 'edit' | 'delete' | 'custom' | 'addon';
   /** For `addon` (row menu only): the add-on's entry (`SPARK_QUERY_ROW_ACTIONS`). */
   addon?: SparkQueryRowAction;
   /** 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. */
+  /** `*bsPriorityNavItem` priority: New first, then Edit, then Delete, then custom actions by offset. */
   priority: number;
 }
 /**
@@ -357,14 +349,13 @@ export declare class SparkQueryGridComponent {
   }>;
   /**
    * 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.
+   * target, so a row whose first column was empty ("—") could not be opened at all. This holds on
+   * every list, selectable or not (#467, D9): only the checkbox cell selects, which the datatable's
+   * `'checkbox'` mode guarantees. 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.
@@ -449,45 +440,60 @@ export declare class SparkQueryGridComponent {
    */
   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.
+   * The built-in actions this result offers (#467, R1(1–3)), each with its toolbar kind: listed for
+   * the caller (the right), on the query side (`defaultQueryActions` already filtered `showedOn`),
+   * not withheld by this result's `disabledActions` — Edit also not when `Save` is — and nothing in
+   * the recycle bin. New additionally needs the type's create right ({@link offersCreate}).
+   */
+  readonly offeredDefaultActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
+  /**
+   * The rendered selection mode (#467, R1): the host's override (a sub-query entry's
+   * `selectionMode`), else the query's own, else `'auto'` — derived from the EFFECTIVE action list
+   * (built-ins and custom actions alike), so a list is selectable exactly when the caller can use an
+   * action on ticked rows here. Recomputed whenever `disabledActions` or the deleted mode changes;
+   * the selection is cleared when the mode becomes `'none'`.
    */
   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.
+   * The actions a host renders in its toolbar, in one list (#460 M15, #467 R3): New, Edit, 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. The same effective list decides
+   * {@link selectionMode}.
    *
-   * - 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).
+   * - New, Edit, Delete: {@link offeredDefaultActions}. Edit and Delete act on ticked rows, so a list
+   *   declared `'none'` leaves them to the row menu, where they would otherwise never be enabled.
    * - Custom: `visibleCustomActions()`.
-   * - In the recycle bin ({@link recycleBin}) none of the three: the list is empty.
+   * - In the recycle bin ({@link recycleBin}) none: 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.
+   * The per-row `⋮` menu: every offered action whose rule accepts exactly one row — Edit and 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[]>;
   /** What an add-on row action is asked whether it is offered; null until the type resolved. */
   private readonly rowActionScope;
-  /** 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.
+   * The built-in Edit (#467, R2): it only navigates, to the row's edit page with this list as the
+   * return state. Get and Update enforce everything (row gate, `can`, etag, write shield); the `=1`
+   * rule is client-side only, since there is no bulk edit.
    */
+  editRow(row: QueryResultItem | undefined): void;
+  /** The chip's ⊗: drops the whole selection, ticked rows on other pages included. */
   clearSelection(): void;
+  /** The ids of the rows on the page currently shown; the chip counts the ticked rows outside it. */
+  private readonly loadedIds;
+  /**
+   * Ticked rows that are not on the page shown (#467, D19): the selection survives paging, so the
+   * chip says how many of the rows an action will act on cannot be seen ("7 selected, 4 on other
+   * pages"). Actions always receive the whole `selection()`, which is what the chip counts.
+   */
+  readonly offPageCount: import("@angular/core").Signal<number>;
   /** 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. */
@@ -520,10 +526,11 @@ export declare class SparkQueryGridComponent {
    */
   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.
+   * The default Delete on `rows`: one request, all rows or none (#460, D18). Asks first — with the
+   * entry's `confirmation` (`{count}` substituted) — then clears the selection and refreshes. Each row
+   * goes with the `etag` it was listed with (#467, D14), so a row changed since is refused, not lost.
    */
-  deleteRows(ids: string[], definition?: CustomActionDefinition): Promise<void>;
+  deleteRows(rows: QueryResultItem[], definition?: CustomActionDefinition): Promise<void>;
   isVirtualScrolling: import("@angular/core").Signal<boolean>;
   /**
    * Columns as sent with the most recent fetched page.
@@ -532,14 +539,11 @@ export declare class SparkQueryGridComponent {
    * 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.
+   * Every column on the wire — what the grid draws, and what renderers and lookups resolve against.
+   * Every column that ships is drawn (#264): there is no shipped-but-hidden column.
    */
-  visibleColumns: import("@angular/core").Signal<QueryColumn[]>;
+  allColumns: import("@angular/core").Signal<QueryColumn[]>;
   /**
    * True when rows do not come from this component's own fetch.
    *

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

@@ -23,6 +23,11 @@ export interface ValidationErrorResponse {
  * Values can be combined: ShowedOn.Query | ShowedOn.PersistentObject
  */
 export declare enum ShowedOn {
+  /**
+   * Drawn on no page (#264; Vidyano's `Never`). The attribute still ships on the object, and an action can show
+   * it for one object through the runtime `showedOn` it sets on load, new or refresh.
+   */
+  None = 0,
   Query = 1,
   PersistentObject = 2
 }
@@ -86,7 +91,6 @@ export interface PersistentObjectAttribute {
   dataType: string;
   isArray?: boolean;
   isRequired: boolean;
-  isVisible: boolean;
   isReadOnly: boolean;
   order: number;
   query?: string;
@@ -128,51 +132,71 @@ export interface PersistentObjectAttribute {
    */
   asDetailType?: string;
 }
+/**
+ * One action of the composed catalogue (#467, D7), as `/spark/actions/list` reports it for a type:
+ * a built-in (New, Edit, Delete) or a custom action, already narrowed to what the caller may run.
+ * Text arrives resolved by the server (D26).
+ */
 export interface CustomActionDefinition {
   name: string;
-  displayName: TranslatedString;
+  /** `actions.{name}.label`, or the humanized name when untranslated. */
+  label: TranslatedString;
   icon?: string;
-  description?: string;
+  /** `actions.{name}.description`; absent when untranslated. */
+  description?: TranslatedString;
   showedOn: string;
   selectionRule?: string;
   refreshOnCompleted: boolean;
-  confirmationMessageKey?: string;
+  /**
+   * The confirmation to ask before running, `actions.{name}.confirmation` or the explicit key the
+   * catalogue names. May contain `{count}`, the number of rows about to be acted on. Absent: no prompt.
+   */
+  confirmation?: TranslatedString;
   /**
    * How prominently, and how warily, to present the action: 'primary', 'secondary', 'danger',
    * 'warning'. Undefined renders the neutral default.
    *
    * Presentation only — the server decides who may see and run an action. A 'danger' variant just
-   * asks the button to look like what it does; pair it with `confirmationMessageKey` for anything
+   * asks the button to look like what it does; pair it with a `confirmation` for anything
    * irreversible, because the colour warns and the prompt is what actually prevents the accident.
    */
   variant?: string;
   offset: number;
   /**
-   * True for the framework's built-in `New` and `Delete` (#460, D18): catalogue entries with a
-   * `showedOn` and a `selectionRule` like any custom action (defaults: New has no rule, Delete is
-   * `>0`; an app overrides them in `customActions.json`), but run through `/po/new` and
-   * `/po/delete-many`, never `/actions/execute`. Absent for a custom action.
+   * True for the framework's built-in `New`, `Edit` and `Delete` (#460 D18, #467 D7): catalogue
+   * entries with a `showedOn` and a `selectionRule` like any custom action (the core's
+   * `actions.json` ships them; an app overrides or removes them in its own), but run through
+   * `/po/new`, the edit page and `/po/delete-many`, never `/actions/execute`. Absent for a custom action.
    */
   isDefault?: boolean;
 }
-/** How many rows a grid lets the user select — what `<bs-datatable>` renders. */
-export type SparkSelectionMode = 'none' | 'single' | 'multiple';
 /**
- * What a query definition (or a sub-query entry) declares (#460, D17): a fixed mode, or `'auto'` —
+ * Whether a grid lets the user tick rows — what `<bs-datatable>` renders. There is no single
+ * selection (#467, D10): a selectable list is a checkbox list, and actions whose rule does not
+ * match the count are disabled rather than the selection trimmed.
+ */
+export type SparkSelectionMode = 'none' | 'multiple';
+/**
+ * What a query definition (or a sub-query entry) declares (#460 D17): a fixed mode, or `'auto'` —
  * the default, and what an absent field means — to derive it from the actions offered.
  */
 export type SparkSelectionModeSetting = 'auto' | SparkSelectionMode;
+/** The largest selection the server accepts in one request (`SparkDefaultActions.MaxSelectedItems`). */
+export declare const SPARK_MAX_SELECTED_ITEMS = 200;
 /**
- * The selection mode a grid renders.
- *
- * A declared `'none'`, `'single'` or `'multiple'` wins outright. `'auto'` (or nothing) derives it,
- * so a grid gains a checkbox column exactly when an action needs one and is otherwise
- * pixel-identical to a grid with no selection at all — as Vidyano's query grid does. The offered
- * actions include the default Delete (`>0`) when the caller may delete, so such a grid is
- * multi-select.
+ * Whether an action needs ticked rows (#467, R1(4)): it has a rule, and the rule accepts at least
+ * one row. `=0` accepts none, so an action that runs only without a selection never makes a list
+ * selectable; an action without a rule acts on the query, not on rows.
+ */
+export declare function needsSelection(action: CustomActionDefinition): boolean;
+/**
+ * The selection mode a grid renders (#467, R1).
  *
- * Derived: `'single'` when every gated action is satisfied by one row and refused by two; anything
- * else that cares about the count gets `'multiple'`.
+ * A declared `'none'` or `'multiple'` wins outright. `'auto'` (or nothing) derives it from
+ * `actions`, which must already be the **effective** list for this result — listed for the caller
+ * (the right), shown on queries, not withheld by `disabledActions` and not hidden by the recycle
+ * bin. Built-in Edit and Delete count like any other action. `'multiple'` when at least one of them
+ * {@link needsSelection}, else `'none'`, so a read-only user sees a list with no checkbox column.
  */
 export declare function selectionModeFor(actions: CustomActionDefinition[], declared?: SparkSelectionModeSetting | null): SparkSelectionMode;
 /**
@@ -229,7 +253,6 @@ export interface EntityAttributeDefinition {
   description?: TranslatedString;
   dataType: string;
   isRequired: boolean;
-  isVisible: boolean;
   isReadOnly: boolean;
   order: number;
   query?: string;
@@ -293,7 +316,8 @@ export interface AttributeGroup {
 export interface EntityType {
   id: string;
   name: string;
-  description?: TranslatedString;
+  /** The type's display name, resolved by the server (#467, D6; formerly `description`). */
+  label?: TranslatedString;
   /**
    * The backing CLR type, or absent for a JSON-only virtual type (#325).
    *
@@ -369,7 +393,8 @@ export interface SparkQuerySortColumn {
 export interface SparkQuery {
   id: string;
   name: string;
-  description?: TranslatedString;
+  /** The query's display name, resolved by the server (#467; formerly `description`). */
+  label?: TranslatedString;
   source: string;
   alias?: string;
   sortColumns: SparkQuerySortColumn[];
@@ -456,7 +481,7 @@ export interface QueryColumn extends SparkCellColumn {
    * header sortable anyway. Neither side read it. The attribute-level `isSortable` on `EntityType`
    * is the drag-reorder flag and stays.
    *
-   * Absent means sortable, matching `isVisible`: a server predating the field still draws arrows.
+   * Absent means sortable: a server predating the field still draws arrows.
    */
   canSort?: boolean;
   /** Whether the grid draws a filter cell for this column. Absent means filterable. */
@@ -467,26 +492,26 @@ export interface QueryColumn extends SparkCellColumn {
    * stronger disclosure than filtering by one already known.
    */
   canListDistincts?: boolean;
-  /**
-   * Whether the grid draws this column. `false` means the row carries the value but no column is
-   * rendered — for a renderer that needs a sibling value (a lock glyph beside a name) without
-   * spending a column on it. `showedOn` decides what ships; this decides what is drawn.
-   */
-  isVisible?: boolean;
   /** The query backing a Reference column, by name — the client's option source. */
   query?: string;
 }
 /**
  * One row: an id, a display string, and a value per column.
  *
- * Deliberately too weak to act on — no attribute metadata, no `can` block, no etag, because none
- * of those can be trusted from a projection.
+ * Deliberately too weak to act on — no attribute metadata, no `can` block, because neither can be
+ * trusted from a projection. It does carry its document's `etag` (#467, D14), a version rather than
+ * a judgement, so a delete from the list says which version it removes.
  */
 export interface QueryResultItem {
   /** Never null and unique within a result; the server refuses anything else. */
   id: string;
   /** What to show when the row is named rather than tabulated (a reference picker's value). */
   breadcrumb?: string;
+  /**
+   * The document's change vector when the list loaded (#467, D14). A delete sends it back; a row
+   * changed since is a 409. Absent for a row with no document behind it.
+   */
+  etag?: string;
   values: QueryResultItemValue[];
   /** Presentation hints for the whole row. Keys arrive lower-cased. */
   typeHints?: Record<string, string>;
@@ -527,8 +552,8 @@ export type SparkRow = QueryResultItem | PersistentObject | Record<string, unkno
  * for its `objectId` as for its text, and a helper that discarded it would have to be replaced the
  * first time a renderer wanted to link somewhere. `?.value` is the cost, once per call site.
  *
- * ⚠️ A value only reaches a grid row if its attribute is on the **query surface**. To read a sibling
- * the grid does not draw, mark it `"showedOn": "Query", "isVisible": false` — shipped, not drawn. An
+ * ⚠️ A value only reaches a grid row if its attribute is on the **query surface**, which also makes it a
+ * column: there is no shipped-but-not-drawn value (#264). An
  * attribute marked `"showedOn": "PersistentObject"` is absent from a row by design, and this returns
  * `undefined` for it; that is the first thing to check when a sibling read comes back empty.
  */
@@ -926,6 +951,13 @@ export declare function comparableValue(attribute: PersistentObjectAttribute | u
 export declare function comparableFormValue(value: unknown): string;
 /** Whether two form-dict values hold the same content (see {@link comparableFormValue}). */
 export declare function formValuesEqual(a: unknown, b: unknown): boolean;
+/**
+ * The prompt to show before running `action` on `count` rows, with `{count}` substituted, or null
+ * when the action asks for no confirmation (#467, D7).
+ */
+export declare function confirmationText(action: CustomActionDefinition | undefined | null, count: number, lang?: string): string | null;
+/** The built-in action named `name` (`New`, `Edit`, `Delete`) in `actions`, when the server listed it. */
+export declare function builtInAction(actions: CustomActionDefinition[], name: 'New' | 'Edit' | 'Delete'): CustomActionDefinition | undefined;
 /** Whether `showedOn` offers the action on a query: `"query"` or `"both"`, in any casing. */
 export declare function isShowedOnQuery(showedOn: string | undefined | null): boolean;
 /** Whether `showedOn` offers the action on a detail page: `"detail"` or `"both"`, in any casing. */
@@ -937,7 +969,7 @@ export declare function isShowedOnDetail(showedOn: string | undefined | null): b
  * and `"both"` — as the server model and the custom-actions guide have always
  * documented — compared case-insensitively (#460 M15: `"Both"` used to render nowhere).
  *
- * The built-in New and Delete (`isDefault`, #460 D18) are left out: they are not executed as
+ * The built-in New, Edit and Delete (`isDefault`, #460 D18, #467 D7) are left out: they are not executed as
  * custom actions, and the grid offers them itself (see {@link defaultQueryActions}).
  *
  * ⚠️ This narrows what is DISPLAYED. It is NOT an authorization boundary: the grant
@@ -948,8 +980,8 @@ export declare function filterQueryActions(actions: CustomActionDefinition[]): C
 /** The custom actions a detail page should offer — the detail-side counterpart of {@link filterQueryActions}. */
 export declare function filterDetailActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
 /**
- * The built-in New and Delete the server listed for this caller (#460, D18), when their `showedOn`
- * includes the query side. Present only when the caller holds `New/T` or `Delete/T`.
+ * The built-in New, Edit and Delete the server listed for this caller (#460 D18, #467 D7), when their `showedOn`
+ * includes the query side. Present only when the caller holds `New/T`, `Edit/T` or `Delete/T`.
  */
 export declare function defaultQueryActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
 /**
@@ -991,7 +1023,8 @@ export interface RefreshedOption {
 export interface AttributeOverlay {
   isRequired?: boolean;
   isReadOnly?: boolean;
-  isVisible?: boolean;
+  /** Where the attribute is drawn for this object; an action sets it on load, new or refresh (#264). */
+  showedOn?: ShowedOn | string;
   rules?: ValidationRule[];
   query?: string;
   /** `undefined` means the hook did not touch the options; an empty array means there are none. */
@@ -1001,7 +1034,9 @@ export type RefreshOverlay = Record<string, AttributeOverlay>;
 /** Applies an overlay to one attribute definition, returning a new object when anything changed. */
 export declare function applyOverlay(attr: EntityAttributeDefinition, overlay: AttributeOverlay | undefined): EntityAttributeDefinition;
 /**
- * Reads a refresh response into an overlay.
+ * Reads a refresh response into an overlay — or a loaded or new object, whose attributes carry the same
+ * server-owned presentation: what `OnLoadAsync`/`OnNewAsync` set (`showedOn`, `isRequired`, `isReadOnly`) applies
+ * from the first render, not only after the first refresh (#264, G5/G7).
  *
  * Everything here is presentation the server owns outright, so it is taken verbatim — there is no
  * merging to do on this half, only on values.

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

@@ -141,9 +141,9 @@ export declare class SparkModerationService {
   }>;
   /**
    * The caller's own reputation, shared by every caller in flight at once: the badge and the
-   * review-queue link both re-read on the same navigation and cost one request.
+   * review-queue link both re-read on the same navigation and cost one request. `null` signed out.
    */
-  ownReputation(): Promise<ModerationReputation>;
+  ownReputation(): Promise<ModerationReputation | null>;
   /** Casts (+1 / −1) or withdraws (0) the caller's vote; resolves to the target's new state. */
   vote(type: string, id: string, direction: -1 | 0 | 1): Promise<ModerationVoteState>;
   /**
@@ -159,8 +159,12 @@ export declare class SparkModerationService {
   unlock(type: string, id: string): Promise<void>;
   /** What the moderator panel shows about a target, including which tools the caller holds. */
   status(type: string, id: string): Promise<ModerationStatus>;
-  /** A user's reputation; the caller's own when `userId` is omitted (with privileges and suspension). */
-  reputation(userId?: string): Promise<ModerationReputation>;
+  /**
+   * A user's reputation; the caller's own when `userId` is omitted (with privileges and suspension).
+   * `null` for an anonymous caller: the server answers it 200 with no result rather than 401, so a
+   * badge on a page anyone may read never sends the app to the sign-in page.
+   */
+  reputation(userId?: string): Promise<ModerationReputation | null>;
   /** The caller's own ledger, newest first. Voters are never named; a reversal reads "Voting corrected (−N)". */
   history(take?: number): Promise<ModerationReputationLine[]>;
   cases(status?: string, skip?: number, take?: number): Promise<ModerationCaseSummary[]>;

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

@@ -117,6 +117,9 @@ export declare class AsDetailTypePipe implements PipeTransform {
 /**
  * The columns of an AsDetail table: the row type's visible attributes, in order — minus those a
  * registered row renderer draws (`rowComponent`), when the host passes its renderer registry.
+ *
+ * An attribute the row type's model draws nowhere (`showedOn: None`, #264) is not a column. Columns are per
+ * type, so they come from the model; a runtime `showedOn` on one row cannot add or remove a column.
  */
 export declare class AsDetailColumnsPipe implements PipeTransform {
   transform(attr: EntityAttributeDefinition, asDetailTypes: Record<string, EntityType>, renderers?: readonly SparkAttributeRendererRegistration[] | null): EntityAttributeDefinition[];

package/types/mintplayer-ng-spark-po-create.d.ts

@@ -16,6 +16,10 @@ export declare class SparkPoCreateComponent {
   validationErrors: import("@angular/core").WritableSignal<ValidationError[]>;
   isSaving: import("@angular/core").WritableSignal<boolean>;
   private allEntityTypes;
+  /**
+   * The errors the form cannot show next to a field: those with no attribute, and those on an attribute the
+   * form does not draw (#264, G6). Those used to be swallowed; Vidyano promotes them to a notification too.
+   */
   generalErrors: import("@angular/core").Signal<ValidationError[]>;
   /**
    * The parent a sub-query card's New passed in the URL (`parentId`, `parentType`, `queryId`), or

package/types/mintplayer-ng-spark-po-detail.d.ts

@@ -60,8 +60,12 @@ export declare class SparkPoDetailComponent {
   asDetailReferenceOptions: import("@angular/core").WritableSignal<Record<string, Record<string, QueryResultItem[]>>>;
   type: string;
   id: string;
-  canEdit: import("@angular/core").WritableSignal<boolean>;
-  canDelete: import("@angular/core").WritableSignal<boolean>;
+  /** The catalogue's Edit (#467, D8) when this page offers it: listed for the caller, on the detail side, and allowed on this row. */
+  editAction: import("@angular/core").WritableSignal<CustomActionDefinition | null>;
+  /** The catalogue's Delete, on the same terms as {@link editAction}. */
+  deleteAction: import("@angular/core").WritableSignal<CustomActionDefinition | null>;
+  canEdit: import("@angular/core").Signal<boolean>;
+  canDelete: import("@angular/core").Signal<boolean>;
   customActions: import("@angular/core").WritableSignal<CustomActionDefinition[]>;
   /** Type-level rights, kept for the add-on context; null until loaded. */
   permissions: import("@angular/core").WritableSignal<EntityPermissions | null>;
@@ -104,6 +108,10 @@ export declare class SparkPoDetailComponent {
   private loadItem;
   /** (Re)loads the object, its type, rights and actions. Also what add-ons call via `context.reload()`. */
   load(): Promise<void>;
+  /**
+   * Drawn from the loaded object's own `showedOn`, falling back to the model's (#264, G-Q3): an action sets
+   * it per object in `OnLoadAsync` — a stolen car's police report number is shown, the model says `None`.
+   */
   visibleAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
   private static readonly DEFAULT_TAB;
   ungroupedAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
@@ -125,6 +133,8 @@ export declare class SparkPoDetailComponent {
    * a louder style. Restricted to a known set rather than interpolated, because the value arrives
    * from a JSON file and must not be able to put arbitrary classes on the button.
    */
+  /** Edit's and Delete's button classes: the catalogue's variant, else the look they always had. */
+  protected builtInActionClass(action: CustomActionDefinition, fallback: 'primary' | 'danger'): string;
   protected customActionClass(action: CustomActionDefinition): string;
   /**
    * The action currently running, or null. Drives the disabled state on every custom-action

package/types/mintplayer-ng-spark-po-edit.d.ts

@@ -147,6 +147,11 @@ export declare class SparkPoEditComponent {
    * is not the question's author edits only its translations; the server drops the rest from the
    * save anyway). Shared by the form and {@link getEditableAttributes}, so what is drawn, what is
    * initialised and what is saved agree. A refresh overlay can still lift it.
+   * <para>
+   * The same goes for where an attribute is drawn and whether it is required (#264, G5/G7): an action
+   * sets the runtime `showedOn`/`isRequired` in `OnLoadAsync` (a stolen car shows its police report
+   * number, required), and the form honours that from its first render rather than after a refresh.
+   * </para>
    */
   formEntityType: import("@angular/core").Signal<EntityType | null>;
   type: string;
@@ -160,6 +165,10 @@ export declare class SparkPoEditComponent {
   validationErrors: import("@angular/core").WritableSignal<ValidationError[]>;
   isSaving: import("@angular/core").WritableSignal<boolean>;
   private allEntityTypes;
+  /**
+   * The errors the form cannot show next to a field: those with no attribute, and those on an attribute the
+   * form does not draw (#264, G6). Those used to be swallowed; Vidyano promotes them to a notification too.
+   */
   generalErrors: import("@angular/core").Signal<ValidationError[]>;
   /** After a 409 was merged: what they changed, and that nothing has been saved yet. */
   private readonly conflictNoticeText;
@@ -212,6 +221,13 @@ export declare class SparkPoEditComponent {
    * then dropped on the floor and refused by the server as missing — with no way out of the form.
    * The overlay is the form's, bound two-way, so the two halves cannot drift again.
    */
+  /**
+   * The attributes {@link formDataFrom} gives a slot: the editable ones, plus those the model makes editable
+   * but this object's load made read-only (#264). A refresh can lift a load-time `isReadOnly` (a stolen car's
+   * plate, once the car is back in use), and the control must then show the loaded value, not an empty
+   * required field. Only {@link getEditableAttributes} decides what is saved, so a slot alone sends nothing.
+   */
+  private formDataAttributes;
   getEditableAttributes(): import("@mintplayer/ng-spark/models").EntityAttributeDefinition[];
   onSave(): Promise<void>;
   onCancel(): void;

package/types/mintplayer-ng-spark-po-form.d.ts

@@ -514,6 +514,7 @@ export declare class SparkReferencePickerComponent {
   pagination: import("@angular/core").WritableSignal<PaginationResponse<QueryResultItem> | undefined>;
   settings: import("@angular/core").WritableSignal<DatatableSettings>;
   searchTerm: string;
+  /** The picker lists query rows, so its columns are the query's: `showedOn` includes Query (#264; not None). */
   visibleAttributes: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").EntityAttributeDefinition[]>;
   rows: import("@angular/core").Signal<QueryResultItem[]>;
   displayValue: import("@angular/core").Signal<string>;

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

@@ -3,7 +3,7 @@ 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 { CustomActionDefinition, QueryColumn, QueryColumnFilter, QueryResultItem, SparkDeletedFilter, SparkSelectionModeSetting } from "@mintplayer/ng-spark/models";
 import { SparkQueryListContext } from "@mintplayer/ng-spark/panels";
 /**
  * The routed query page: chrome around one {@link SparkQueryGridComponent}.
@@ -31,6 +31,11 @@ export declare class SparkQueryListComponent {
   protected readonly lang: SparkLanguageService;
   extraActionsTemplate: import("@angular/core").InputSignal<TemplateRef<void> | null>;
   showCustomActions: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Overrides the query's own `selectionMode` (#467, R3), as the sub-query card's input does: for a
+   * host that embeds this page and wants, say, `'none'` on a list the actions would make selectable.
+   */
+  selectionMode: import("@angular/core").InputSignal<SparkSelectionModeSetting | null>;
   /**
    * 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.
@@ -147,6 +152,11 @@ export declare class SparkQueryListComponent {
       "required": false;
       "isSignal": true;
     };
+    "selectionMode": {
+      "alias": "selectionMode";
+      "required": false;
+      "isSignal": true;
+    };
     "rowRoute": {
       "alias": "rowRoute";
       "required": false;