@mintplayer/ng-spark 22.23.0 → 22.25.0

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

@@ -1,40 +1,35 @@
-import { WritableSignal } from '@angular/core';
-
-type TranslatedString = Record<string, string>;
+import { WritableSignal } from "@angular/core";
+export type TranslatedString = Record<string, string>;
 /** Global reactive language state — shared across library boundaries via globalThis */
-declare const currentLanguage: WritableSignal<string>;
-declare function resolveTranslation(ts: TranslatedString | undefined, lang?: string): string;
-
-interface ValidationRule {
-    type: string;
-    value?: any;
-    min?: number;
-    max?: number;
-    message?: TranslatedString;
-}
-
-interface ValidationError {
-    attributeName: string;
-    errorMessage: TranslatedString;
-    ruleType: string;
-}
-interface ValidationErrorResponse {
-    errors: ValidationError[];
-}
-
+export declare const currentLanguage: WritableSignal<string>;
+export declare function resolveTranslation(ts: TranslatedString | undefined, lang?: string): string;
+export interface ValidationRule {
+  type: string;
+  value?: any;
+  min?: number;
+  max?: number;
+  message?: TranslatedString;
+}
+export interface ValidationError {
+  attributeName: string;
+  errorMessage: TranslatedString;
+  ruleType: string;
+}
+export interface ValidationErrorResponse {
+  errors: ValidationError[];
+}
 /**
  * Flags enum controlling on which pages an attribute should be displayed.
  * Values can be combined: ShowedOn.Query | ShowedOn.PersistentObject
  */
-declare enum ShowedOn {
-    Query = 1,
-    PersistentObject = 2
+export declare enum ShowedOn {
+  Query = 1,
+  PersistentObject = 2
 }
 /**
  * Helper function to check if a ShowedOn value includes a specific flag.
  */
-declare function hasShowedOnFlag(value: ShowedOn | string | undefined, flag: ShowedOn): boolean;
-
+export declare function hasShowedOnFlag(value: ShowedOn | string | undefined, flag: ShowedOn): boolean;
 /**
  * Per-row action affordances (#236 G5). Present only when the entity type has a row-level rule;
  * absent otherwise, so clients fall back to the type-level permissions from
@@ -44,262 +39,364 @@ declare function hasShowedOnFlag(value: ShowedOn | string | undefined, flag: Sho
  * row rule (#243) — a present block never claims more than the permissions endpoint would, so
  * letting it override the type-level answer is safe.
  */
-interface PersistentObjectPermissions {
-    edit: boolean;
-    delete: boolean;
-}
-interface PersistentObject {
-    id: string;
-    name: string;
-    objectTypeId: string;
-    breadcrumb?: string;
-    /**
-     * Optimistic-concurrency token -- RavenDB's change vector for the document behind this object.
-     * The server stamps it on every `/po/load` and expects it back on update.
-     *
-     * ⚠️ The check is opt-in BY PRESENCE of this field. Dropping it does not fail loudly; it makes
-     * the save unconditional, so two people editing the same record both succeed and the second
-     * silently overwrites the first. That is what used to happen here: `SparkClient` round-tripped
-     * the token and got a 409, the browser did not and got last-write-wins, on the same endpoint.
-     */
-    etag?: string;
-    attributes: PersistentObjectAttribute[];
-    /** Per-row edit/delete affordances; undefined = fall back to type-level permissions. */
-    can?: PersistentObjectPermissions;
-    /**
-     * Custom actions withheld for THIS object, by name. Absent or empty means every action the
-     * caller has the right to is offered.
-     *
-     * The action catalogue at `/spark/actions/{objectTypeId}` is per TYPE -- it is never told which
-     * row is open -- so an action that applies to only some rows cannot be filtered there. The
-     * entity actions hook decides while it has the entity in hand, and the answer arrives here.
-     *
-     * An affordance, not a permission: the action endpoint is still reachable and its handler still
-     * refuses on its own terms. What this prevents is offering a destructive action where it cannot
-     * apply.
-     */
-    disabledActions?: string[];
-}
-
-interface PersistentObjectAttribute {
-    id: string;
-    name: string;
-    label?: TranslatedString;
-    value?: any;
-    dataType: string;
-    isArray?: boolean;
-    isRequired: boolean;
-    isVisible: boolean;
-    isReadOnly: boolean;
-    order: number;
-    query?: string;
-    breadcrumb?: string;
-    /**
-     * For `dataType === 'Reference'` with `isArray === true`: resolved display label per
-     * referenced id (id → breadcrumb), so the UI can render a chip per selected reference.
-     * The single-reference counterpart is `breadcrumb`.
-     */
-    breadcrumbs?: Record<string, string | null>;
-    /**
-     * Controls on which pages the attribute should be displayed.
-     * Query = shown in list views, PersistentObject = shown in detail/edit views.
-     * Can be a numeric flag value or a string like "Query, PersistentObject".
-     */
-    showedOn?: ShowedOn | string;
-    isValueChanged?: boolean;
-    rules: ValidationRule[];
-    group?: string;
-    /** Renderer component name for custom display in detail/list views */
-    renderer?: string;
-    /** Options passed to the renderer component */
-    rendererOptions?: Record<string, any>;
-    /**
-     * When `dataType === 'AsDetail'` and `isArray === false`: the single nested
-     * PersistentObject carrying the detail entity's values. `null` when the field is unset.
-     * Mirrors the server's PersistentObjectAttributeAsDetail.Object.
-     */
-    object?: PersistentObject | null;
-    /**
-     * When `dataType === 'AsDetail'` and `isArray === true`: the nested PO collection, one
-     * per array element. Mirrors PersistentObjectAttributeAsDetail.Objects.
-     */
-    objects?: PersistentObject[] | null;
-    /**
-     * CLR type name of the detail entity for AsDetail attributes (e.g. `HR.Entities.Address`).
-     * Emitted by the server so the frontend can look up the matching EntityType metadata
-     * without re-resolving through `asDetailType` on the schema definition.
-     */
-    asDetailType?: string;
-}
-
+export interface PersistentObjectPermissions {
+  edit: boolean;
+  delete: boolean;
+}
+export interface PersistentObject {
+  id: string;
+  name: string;
+  objectTypeId: string;
+  breadcrumb?: string;
+  /**
+   * Optimistic-concurrency token -- RavenDB's change vector for the document behind this object.
+   * The server stamps it on every `/po/load` and expects it back on update.
+   *
+   * ⚠️ The check is opt-in BY PRESENCE of this field. Dropping it does not fail loudly; it makes
+   * the save unconditional, so two people editing the same record both succeed and the second
+   * silently overwrites the first. That is what used to happen here: `SparkClient` round-tripped
+   * the token and got a 409, the browser did not and got last-write-wins, on the same endpoint.
+   */
+  etag?: string;
+  attributes: PersistentObjectAttribute[];
+  /** Per-row edit/delete affordances; undefined = fall back to type-level permissions. */
+  can?: PersistentObjectPermissions;
+  /**
+   * Custom actions withheld for THIS object, by name. Absent or empty means every action the
+   * caller has the right to is offered.
+   *
+   * The action catalogue at `/spark/actions/{objectTypeId}` is per TYPE -- it is never told which
+   * row is open -- so an action that applies to only some rows cannot be filtered there. The
+   * entity's `OnDisableActionsAsync` hook decides on the stored entity, and the answer arrives here
+   * -- built-in actions (`Edit`, `Save`, `Delete`) included (#460, D13). The server asks the same
+   * hook again at submit and refuses a disabled action with 403.
+   */
+  disabledActions?: string[];
+  /**
+   * Read-side facts an add-on attached to this object on load, keyed by the add-on (e.g.
+   * `{ contribution: { own: true } }` on a contribution row). Server-written; never sent back.
+   */
+  metadata?: Record<string, any>;
+}
+export interface PersistentObjectAttribute {
+  id: string;
+  name: string;
+  label?: TranslatedString;
+  value?: any;
+  dataType: string;
+  isArray?: boolean;
+  isRequired: boolean;
+  isVisible: boolean;
+  isReadOnly: boolean;
+  order: number;
+  query?: string;
+  breadcrumb?: string;
+  /**
+   * For `dataType === 'Reference'` with `isArray === true`: resolved display label per
+   * referenced id (id → breadcrumb), so the UI can render a chip per selected reference.
+   * The single-reference counterpart is `breadcrumb`.
+   */
+  breadcrumbs?: Record<string, string | null>;
+  /**
+   * Controls on which pages the attribute should be displayed.
+   * Query = shown in list views, PersistentObject = shown in detail/edit views.
+   * Can be a numeric flag value or a string like "Query, PersistentObject".
+   */
+  showedOn?: ShowedOn | string;
+  isValueChanged?: boolean;
+  rules: ValidationRule[];
+  group?: string;
+  /** Renderer component name for custom display in detail/list views */
+  renderer?: string;
+  /** Options passed to the renderer component */
+  rendererOptions?: Record<string, any>;
+  /**
+   * When `dataType === 'AsDetail'` and `isArray === false`: the single nested
+   * PersistentObject carrying the detail entity's values. `null` when the field is unset.
+   * Mirrors the server's PersistentObjectAttributeAsDetail.Object.
+   */
+  object?: PersistentObject | null;
+  /**
+   * When `dataType === 'AsDetail'` and `isArray === true`: the nested PO collection, one
+   * per array element. Mirrors PersistentObjectAttributeAsDetail.Objects.
+   */
+  objects?: PersistentObject[] | null;
+  /**
+   * CLR type name of the detail entity for AsDetail attributes (e.g. `HR.Entities.Address`).
+   * Emitted by the server so the frontend can look up the matching EntityType metadata
+   * without re-resolving through `asDetailType` on the schema definition.
+   */
+  asDetailType?: string;
+}
+export interface CustomActionDefinition {
+  name: string;
+  displayName: TranslatedString;
+  icon?: string;
+  description?: string;
+  showedOn: string;
+  selectionRule?: string;
+  refreshOnCompleted: boolean;
+  confirmationMessageKey?: string;
+  /**
+   * 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
+   * 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.
+   */
+  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'` —
+ * the default, and what an absent field means — to derive it from the actions offered.
+ */
+export type SparkSelectionModeSetting = 'auto' | SparkSelectionMode;
+/**
+ * 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.
+ *
+ * Derived: `'single'` when every gated action is satisfied by one row and refused by two; anything
+ * else that cares about the count gets `'multiple'`.
+ */
+export declare function selectionModeFor(actions: CustomActionDefinition[], declared?: SparkSelectionModeSetting | null): SparkSelectionMode;
+/**
+ * One sub-query of a type, with the overrides the parent's type states for it (#460, D17).
+ */
+export interface SparkSubQuery {
+  /** The query's alias or id. */
+  query: string;
+  /** Overrides the query's own `selectionMode` on this parent's detail page. */
+  selectionMode?: SparkSelectionModeSetting;
+  /** The row attribute pointing at the parent, when the row type has several (server-side). */
+  parentReference?: string;
+}
+/**
+ * An entry of `EntityType.queries` as it arrives on the wire: a bare alias — the shape every model
+ * had before #460 M15, and still what the server sends for an entry without overrides — or the
+ * object form.
+ */
+export type SparkSubQueryEntry = string | SparkSubQuery;
+/** One entry in its object form, whichever shape it arrived in. */
+export declare function normalizeSubQuery(entry: SparkSubQueryEntry): SparkSubQuery;
+/** A type's sub-queries in object form; empty when it declares none. */
+export declare function subQueriesOf(type: {
+  queries?: SparkSubQueryEntry[];
+} | null | undefined): SparkSubQuery[];
 /**
  * Controls how a Reference attribute is picked in the PO-edit form.
  * Serialized as a string by the server (mirrors the .NET EReferenceDisplayType).
  */
-declare enum EReferenceDisplayType {
-    /** Renders as a `<bs-select>` listing every referenced item. */
-    Dropdown = "Dropdown",
-    /** Renders a readonly textbox + "…" button that opens a searchable modal grid picker. */
-    Modal = "Modal"
-}
-interface EntityAttributeDefinition {
-    id: string;
-    name: string;
-    label?: TranslatedString;
-    /** Help text rendered as an [i] tooltip beside the label. Absent when the model declares none. */
-    description?: TranslatedString;
-    dataType: string;
-    isRequired: boolean;
-    isVisible: boolean;
-    isReadOnly: boolean;
-    order: number;
-    query?: string;
-    /** For reference attributes, specifies the target entity type's CLR type name */
-    referenceType?: string;
-    /** For AsDetail attributes, specifies the nested entity type's CLR type name */
-    asDetailType?: string;
-    /** When true, the attribute represents an array/collection of AsDetail objects */
-    isArray?: boolean;
-    /** For array AsDetail attributes: "modal" (default) or "inline" */
-    editMode?: 'inline' | 'modal';
-    /**
-     * For Reference attributes: 'Modal' renders the "…" + modal query-grid picker;
-     * 'Dropdown'/absent (default) renders a `<bs-select>`. Hand-set in the model JSON.
-     */
-    referenceDisplayType?: EReferenceDisplayType;
-    /** For array AsDetail attributes: when true, rows can be drag-reordered (order = array position) */
-    isSortable?: boolean;
-    /**
-     * When true, changing this attribute's value posts the in-progress object to
-     * `/spark/po/{objectTypeId}/refresh` and applies the reshaped result as an overlay.
-     * Schema-only by design — it never travels on a PersistentObjectAttribute, so a client
-     * cannot claim a trigger the model did not declare.
-     */
-    triggersRefresh?: boolean;
-    /** For LookupReference attributes, specifies the lookup reference type name */
-    lookupReferenceType?: string;
-    /**
-     * Controls on which pages the attribute should be displayed.
-     * Query = shown in list views, PersistentObject = shown in detail/edit views.
-     * Can be a numeric flag value or a string like "Query, PersistentObject".
-     */
-    showedOn?: ShowedOn | string;
-    rules: ValidationRule[];
-    /** References an AttributeGroup.id to assign this attribute to a group */
-    group?: string;
-    /** Number of grid columns this attribute spans within a tab's column layout */
-    columnSpan?: number;
-    /** Renderer component name for custom display in detail/list views */
-    renderer?: string;
-    /** Options passed to the renderer component */
-    rendererOptions?: Record<string, any>;
-}
-interface AttributeTab {
-    id: string;
-    name: string;
-    label?: TranslatedString;
-    order: number;
-    /** Number of columns for the grid layout within this tab */
-    columnCount?: number;
-}
-interface AttributeGroup {
-    id: string;
-    name: string;
-    label?: TranslatedString;
-    /** References an AttributeTab.id to assign this group to a tab */
-    tab?: string;
-    order: number;
-}
-interface EntityType {
-    id: string;
-    name: string;
-    description?: TranslatedString;
-    /**
-     * The backing CLR type, or absent for a JSON-only virtual type (#325).
-     *
-     * Optional on purpose: the server sends null for a virtual type, and this was declared
-     * non-nullable, so any unguarded `.endsWith(...)` on it threw a TypeError naming an innocent
-     * query. Types are data from the wire, not a promise about it.
-     */
-    clrType?: string;
-    /**
-     * Whether this caller may OPEN one of these, as opposed to list them.
-     *
-     * The catalogue is gated on Query, so its presence here means "you may list this type" and says
-     * nothing about opening one. A reference must not render as a link when this is false: it used
-     * to, and the click refused on arrival.
-     */
-    canRead?: boolean;
-    alias?: string;
-    /**
-     * Breadcrumb template: literal text plus `{AttributeName}` placeholders. A scalar placeholder
-     * renders its value; a reference placeholder renders the referenced entity's breadcrumb.
-     * The server resolves this — clients only read the resulting strings. Example: "{Street}, {City}".
-     */
-    breadcrumb?: string;
-    /**
-     * When false, the breadcrumb needs the collection document (a placeholder field is not on the
-     * projection). null/absent means renderable from the projection. Informational on the client.
-     */
-    breadcrumbProjectionSatisfiable?: boolean;
-    tabs?: AttributeTab[];
-    groups?: AttributeGroup[];
-    attributes: EntityAttributeDefinition[];
-    /** Query aliases or IDs to display as related query tables on the detail page. */
-    queries?: string[];
-    /**
-     * The definitions of this type's AsDetail row types, sent alongside it so a detail table can draw
-     * its columns.
-     *
-     * Needed because a row type usually has no rights of its own — a row is edited through its parent
-     * — and the entity-type catalogue is gated on `Query`. Resolving a row type from the catalogue
-     * therefore failed silently, and the table rendered with **no columns at all**.
-     *
-     * Per-caller and gated on the *parent's* right, which is the same gate that already ships each
-     * row's attribute schema inside `attr.objects`. Pruned server-side: no `queryType`, `indexName`,
-     * `queries` or `alias`.
-     */
-    detailTypes?: EntityType[];
-    /**
-     * Whether adding or removing a row of this type asks the server first.
-     *
-     * Absent or false — the default — keeps the purely client-side behaviour: New pushes a blank row,
-     * Delete splices it out, and the parent's save is the first the server hears of either. On, the
-     * grid calls `newObject` before showing a row and `deleteRow` before removing one, so
-     * `OnNewAsync` can default it and the delete hook can refuse.
-     *
-     * ⚠️ Read it off the **row type**, never the parent: the type that owns the hooks owns the
-     * decision. For a row type resolved out of `detailTypes` the flag survives the server-side
-     * pruning, so both sources agree.
-     *
-     * ⚠️ It governs the round trip and nothing else. It is not a permission, and it is outside the
-     * model hash, so nothing that gates a write may be conditional on it — the save path enforces the
-     * row type's New/Edit/Delete rights on every embedded collection whether this is on or off.
-     */
-    serverSideRowLifecycle?: boolean;
-}
-
-type SparkQueryRenderMode = 'Pagination' | 'VirtualScrolling';
-interface SparkQuerySortColumn {
-    property: string;
-    direction: string;
-}
-interface SparkQuery {
-    id: string;
-    name: string;
-    description?: TranslatedString;
-    source: string;
-    alias?: string;
-    sortColumns: SparkQuerySortColumn[];
-    renderMode?: SparkQueryRenderMode;
-    /** The RavenDB index this query runs against, resolved by name server-side. */
-    indexName?: string;
-    /** Optional entity type name (e.g., "Person"). When set, used for entity type resolution. */
-    entityType?: string;
-    /** When true, this query uses WebSocket streaming with snapshot + patch updates. */
-    isStreamingQuery?: boolean;
-}
-
+export declare enum EReferenceDisplayType {
+  /** Renders as a `<bs-select>` listing every referenced item. */
+  Dropdown = "Dropdown",
+  /** Renders a readonly textbox + "…" button that opens a searchable modal grid picker. */
+  Modal = "Modal"
+}
+/**
+ * When changing an attribute asks the server to reshape the object (mirrors the .NET
+ * `ERefreshTrigger`, serialized PascalCase like {@link EReferenceDisplayType}).
+ *
+ * - `None` — no refresh; the same as absent.
+ * - `Auto` — free text refreshes on blur; discrete editors (lookup, reference, boolean, date,
+ *   datetime, enum, color) refresh immediately.
+ * - `ValueChanged` — refreshes on every change; free text is debounced (300 ms) and flushed by
+ *   blur or save.
+ * - `Blur` — refreshes on blur. A discrete editor never blurs meaningfully, so there it acts as
+ *   `ValueChanged` (and `--spark-verify-model` warns).
+ */
+export type RefreshTrigger = 'None' | 'Auto' | 'ValueChanged' | 'Blur';
+export interface EntityAttributeDefinition {
+  id: string;
+  name: string;
+  label?: TranslatedString;
+  /** Help text rendered as an [i] tooltip beside the label. Absent when the model declares none. */
+  description?: TranslatedString;
+  dataType: string;
+  isRequired: boolean;
+  isVisible: boolean;
+  isReadOnly: boolean;
+  order: number;
+  query?: string;
+  /** For reference attributes, specifies the target entity type's CLR type name */
+  referenceType?: string;
+  /** For AsDetail attributes, specifies the nested entity type's CLR type name */
+  asDetailType?: string;
+  /** When true, the attribute represents an array/collection of AsDetail objects */
+  isArray?: boolean;
+  /** For array AsDetail attributes: "modal" (default) or "inline" */
+  editMode?: 'inline' | 'modal';
+  /**
+   * For Reference attributes: 'Modal' renders the "…" + modal query-grid picker;
+   * 'Dropdown'/absent (default) renders a `<bs-select>`. Hand-set in the model JSON.
+   */
+  referenceDisplayType?: EReferenceDisplayType;
+  /** For array AsDetail attributes: when true, rows can be drag-reordered (order = array position) */
+  isSortable?: boolean;
+  /**
+   * When set (and not `'None'`), changing this attribute's value posts the in-progress object to
+   * `/spark/po/{objectTypeId}/refresh` and applies the reshaped result as an overlay; the value
+   * decides when (see {@link RefreshTrigger}). Absent means no refresh.
+   * Schema-only by design — it never travels on a PersistentObjectAttribute, so a client
+   * cannot claim a trigger the model did not declare.
+   */
+  triggersRefresh?: RefreshTrigger;
+  /** For LookupReference attributes, specifies the lookup reference type name */
+  lookupReferenceType?: string;
+  /**
+   * Controls on which pages the attribute should be displayed.
+   * Query = shown in list views, PersistentObject = shown in detail/edit views.
+   * Can be a numeric flag value or a string like "Query, PersistentObject".
+   */
+  showedOn?: ShowedOn | string;
+  rules: ValidationRule[];
+  /** References an AttributeGroup.id to assign this attribute to a group */
+  group?: string;
+  /** Number of grid columns this attribute spans within a tab's column layout */
+  columnSpan?: number;
+  /** Renderer component name for custom display in detail/list views */
+  renderer?: string;
+  /** Options passed to the renderer component */
+  rendererOptions?: Record<string, any>;
+}
+export interface AttributeTab {
+  id: string;
+  name: string;
+  label?: TranslatedString;
+  order: number;
+  /** Number of columns for the grid layout within this tab */
+  columnCount?: number;
+}
+export interface AttributeGroup {
+  id: string;
+  name: string;
+  label?: TranslatedString;
+  /** References an AttributeTab.id to assign this group to a tab */
+  tab?: string;
+  order: number;
+}
+export interface EntityType {
+  id: string;
+  name: string;
+  description?: TranslatedString;
+  /**
+   * The backing CLR type, or absent for a JSON-only virtual type (#325).
+   *
+   * Optional on purpose: the server sends null for a virtual type, and this was declared
+   * non-nullable, so any unguarded `.endsWith(...)` on it threw a TypeError naming an innocent
+   * query. Types are data from the wire, not a promise about it.
+   */
+  clrType?: string;
+  /**
+   * Whether this caller may OPEN one of these, as opposed to list them.
+   *
+   * The catalogue is gated on Query, so its presence here means "you may list this type" and says
+   * nothing about opening one. A reference must not render as a link when this is false: it used
+   * to, and the click refused on arrival.
+   */
+  canRead?: boolean;
+  alias?: string;
+  /**
+   * Breadcrumb template: literal text plus `{AttributeName}` placeholders. A scalar placeholder
+   * renders its value; a reference placeholder renders the referenced entity's breadcrumb.
+   * The server resolves this — clients only read the resulting strings. Example: "{Street}, {City}".
+   */
+  breadcrumb?: string;
+  /**
+   * When false, the breadcrumb needs the collection document (a placeholder field is not on the
+   * projection). null/absent means renderable from the projection. Informational on the client.
+   */
+  breadcrumbProjectionSatisfiable?: boolean;
+  tabs?: AttributeTab[];
+  groups?: AttributeGroup[];
+  attributes: EntityAttributeDefinition[];
+  /**
+   * The sub-queries displayed as related query tables on the detail page: a bare alias or id, or
+   * `{ query, selectionMode?, parentReference? }` (#460, D17). Read them with `subQueriesOf(type)`.
+   */
+  queries?: SparkSubQueryEntry[];
+  /**
+   * The definitions of this type's AsDetail row types, sent alongside it so a detail table can draw
+   * its columns.
+   *
+   * Needed because a row type usually has no rights of its own — a row is edited through its parent
+   * — and the entity-type catalogue is gated on `Query`. Resolving a row type from the catalogue
+   * therefore failed silently, and the table rendered with **no columns at all**.
+   *
+   * Per-caller and gated on the *parent's* right, which is the same gate that already ships each
+   * row's attribute schema inside `attr.objects`. Pruned server-side: no `queryType`, `indexName`,
+   * `queries` or `alias`.
+   */
+  detailTypes?: EntityType[];
+  /**
+   * Whether adding or removing a row of this type asks the server first.
+   *
+   * Absent or false — the default — keeps the purely client-side behaviour: New pushes a blank row,
+   * Delete splices it out, and the parent's save is the first the server hears of either. On, the
+   * grid calls `newObject` before showing a row and `deleteRow` before removing one, so
+   * `OnNewAsync` can default it and the delete hook can refuse.
+   *
+   * ⚠️ Read it off the **row type**, never the parent: the type that owns the hooks owns the
+   * decision. For a row type resolved out of `detailTypes` the flag survives the server-side
+   * pruning, so both sources agree.
+   *
+   * ⚠️ It governs the round trip and nothing else. It is not a permission, and it is outside the
+   * model hash, so nothing that gates a write may be conditional on it — the save path enforces the
+   * row type's New/Edit/Delete rights on every embedded collection whether this is on or off.
+   */
+  serverSideRowLifecycle?: boolean;
+}
+export type SparkQueryRenderMode = 'Pagination' | 'VirtualScrolling';
+export interface SparkQuerySortColumn {
+  property: string;
+  direction: string;
+}
+export interface SparkQuery {
+  id: string;
+  name: string;
+  description?: TranslatedString;
+  source: string;
+  alias?: string;
+  sortColumns: SparkQuerySortColumn[];
+  renderMode?: SparkQueryRenderMode;
+  /** The RavenDB index this query runs against, resolved by name server-side. */
+  indexName?: string;
+  /** Optional entity type name (e.g., "Person"). When set, used for entity type resolution. */
+  entityType?: string;
+  /** When true, this query uses WebSocket streaming with snapshot + patch updates. */
+  isStreamingQuery?: boolean;
+  /**
+   * Whether the grid offers row selection (#460, D17). Absent is `'auto'`: derived from the offered
+   * actions. A sub-query entry on the parent's type may override it.
+   */
+  selectionMode?: SparkSelectionModeSetting;
+  /**
+   * The row type's attribute that points at the parent when the query is a sub-query — only needed
+   * when the row type references the parent's type more than once (#460, D19). Server-side use.
+   */
+  parentReference?: string;
+}
+/**
+ * Which rows a query asks for with respect to soft deletion (#460). Core carries it to every row
+ * policy; the SoftDelete package's policy honours it only for holders of `ViewDeleted` on the type.
+ * Omitted means `'exclude'`.
+ */
+export type SparkDeletedFilter = 'exclude' | 'include' | 'only';
 /**
  * What a query returns: the column metadata once, then one lightweight row per result.
  *
@@ -309,25 +406,23 @@ interface SparkQuery {
  * **persistent object is a document**. Nothing here is entitled to act on a row — every
  * mutating path re-loads by id and re-applies security server-side.
  */
-interface QueryResult {
-    columns: QueryColumn[];
-    items: QueryResultItem[];
-    /** Rows matching the query after filtering, before paging. */
-    totalItems: number;
-    skip: number;
-    take: number;
-    typeHints?: Record<string, string>;
-    /**
-     * Custom actions withheld for THIS result, by name. Absent or empty means every action the
-     * caller has the right to is offered.
-     *
-     * The mirror of `PersistentObject.disabledActions`, set server-side via
-     * `CustomQueryArgs.DisableActions(...)`. The action catalogue is per type and is never told what
-     * an execution returned, so this is where a per-result answer travels.
-     *
-     * An affordance, not a permission -- the action handler still refuses on its own terms.
-     */
-    disabledActions?: string[];
+export interface QueryResult {
+  columns: QueryColumn[];
+  items: QueryResultItem[];
+  /** Rows matching the query after filtering, before paging. */
+  totalItems: number;
+  skip: number;
+  take: number;
+  typeHints?: Record<string, string>;
+  /**
+   * Actions withheld for THIS query, by name (custom, and `New`). Absent or empty means every
+   * action the caller has the right to is offered.
+   *
+   * The mirror of `PersistentObject.disabledActions`, set server-side by the entity's
+   * `OnDisableActionsAsync` hook with a query target (#460, D13). The server asks the same hook when
+   * an action is submitted from this query and refuses a disabled one with 403.
+   */
+  disabledActions?: string[];
 }
 /**
  * The subset of column metadata a cell needs in order to render.
@@ -336,50 +431,50 @@ interface QueryResult {
  * page's attribute) satisfy this, which is what lets one cell component serve the query grid and
  * the AsDetail sub-table without either side knowing about the other's shape.
  */
-interface SparkCellColumn {
-    name: string;
-    label?: TranslatedString;
-    /** Help text rendered as an [i] tooltip in the column header. Absent when the model declares none. */
-    description?: TranslatedString;
-    dataType: string;
-    isArray?: boolean;
-    renderer?: string;
-    rendererOptions?: Record<string, any>;
-    referenceType?: string;
-    lookupReferenceType?: string;
-    asDetailType?: string;
+export interface SparkCellColumn {
+  name: string;
+  label?: TranslatedString;
+  /** Help text rendered as an [i] tooltip in the column header. Absent when the model declares none. */
+  description?: TranslatedString;
+  dataType: string;
+  isArray?: boolean;
+  renderer?: string;
+  rendererOptions?: Record<string, any>;
+  referenceType?: string;
+  lookupReferenceType?: string;
+  asDetailType?: string;
 }
 /** One column of a query result, sent once rather than repeated on every row. */
-interface QueryColumn extends SparkCellColumn {
-    order: number;
-    /**
-     * Whether the grid offers a sort affordance for this column. Resolved server-side from the query's
-     * override then the attribute, so it arrives already decided.
-     *
-     * This replaced an `isSortable` that carried the server's AsDetail *drag-reorder* flag — a
-     * different concept that was `false` for every scalar column while the grid hard-coded every
-     * 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.
-     */
-    canSort?: boolean;
-    /** Whether the grid draws a filter cell for this column. Absent means filterable. */
-    canFilter?: boolean;
-    /**
-     * Whether this column's distinct values may be listed. When `false` and `canFilter` is true the
-     * panel offers a free-text filter instead of a value list — listing a column's values is a much
-     * 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;
+export interface QueryColumn extends SparkCellColumn {
+  order: number;
+  /**
+   * Whether the grid offers a sort affordance for this column. Resolved server-side from the query's
+   * override then the attribute, so it arrives already decided.
+   *
+   * This replaced an `isSortable` that carried the server's AsDetail *drag-reorder* flag — a
+   * different concept that was `false` for every scalar column while the grid hard-coded every
+   * 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.
+   */
+  canSort?: boolean;
+  /** Whether the grid draws a filter cell for this column. Absent means filterable. */
+  canFilter?: boolean;
+  /**
+   * Whether this column's distinct values may be listed. When `false` and `canFilter` is true the
+   * panel offers a free-text filter instead of a value list — listing a column's values is a much
+   * 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.
@@ -387,28 +482,28 @@ interface QueryColumn extends SparkCellColumn {
  * Deliberately too weak to act on — no attribute metadata, no `can` block, no etag, because none
  * of those can be trusted from a projection.
  */
-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;
-    values: QueryResultItemValue[];
-    /** Presentation hints for the whole row. Keys arrive lower-cased. */
-    typeHints?: Record<string, string>;
+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;
+  values: QueryResultItemValue[];
+  /** Presentation hints for the whole row. Keys arrive lower-cased. */
+  typeHints?: Record<string, string>;
 }
 /** One cell. */
-interface QueryResultItemValue {
-    /** The {@link QueryColumn.name} this value belongs to. */
-    key: string;
-    /** Typed JSON, not a string — the server converts on the way out. */
-    value?: any;
-    /** For a reference cell: the target document's id, so a link needs no second lookup. */
-    objectId?: string;
-    /** For a reference cell: the target's display string. */
-    breadcrumb?: string;
-    /** Resolved display labels per referenced id, for a multi-reference cell. */
-    breadcrumbs?: Record<string, string | null>;
-    typeHints?: Record<string, string>;
+export interface QueryResultItemValue {
+  /** The {@link QueryColumn.name} this value belongs to. */
+  key: string;
+  /** Typed JSON, not a string — the server converts on the way out. */
+  value?: any;
+  /** For a reference cell: the target document's id, so a link needs no second lookup. */
+  objectId?: string;
+  /** For a reference cell: the target's display string. */
+  breadcrumb?: string;
+  /** Resolved display labels per referenced id, for a multi-reference cell. */
+  breadcrumbs?: Record<string, string | null>;
+  typeHints?: Record<string, string>;
 }
 /**
  * Every shape a renderer's `item` can arrive in.
@@ -419,7 +514,7 @@ interface QueryResultItemValue {
  * grid and an AsDetail table therefore sees two of them, which is why {@link valueFor} reads all
  * three rather than making every app write the branch.
  */
-type SparkRow = QueryResultItem | PersistentObject | Record<string, unknown>;
+export type SparkRow = QueryResultItem | PersistentObject | Record<string, unknown>;
 /**
  * The value a row carries for a column, whatever shape the row is in — or `undefined` when it
  * carries none.
@@ -437,7 +532,7 @@ type SparkRow = QueryResultItem | PersistentObject | Record<string, unknown>;
  * 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.
  */
-declare function valueFor(item: SparkRow | null | undefined, columnName: string): QueryResultItemValue | undefined;
+export declare function valueFor(item: SparkRow | null | undefined, columnName: string): QueryResultItemValue | undefined;
 /**
  * Whether this row is a query result item.
  *
@@ -445,9 +540,9 @@ declare function valueFor(item: SparkRow | null | undefined, columnName: string)
  * legitimately have a column named `values` holding an array, and mistaking one for the other would
  * silently read the wrong thing.
  */
-declare function isQueryRow(row: SparkRow | null | undefined): row is QueryResultItem;
+export declare function isQueryRow(row: SparkRow | null | undefined): row is QueryResultItem;
 /** Whether this row is a full persistent object. Discriminated on elements, as above. */
-declare function isPersistentObject(row: SparkRow | null | undefined): row is PersistentObject;
+export declare function isPersistentObject(row: SparkRow | null | undefined): row is PersistentObject;
 /**
  * One column's value filter (#431): the values a caller picked, or the values they excluded.
  *
@@ -460,10 +555,10 @@ declare function isPersistentObject(row: SparkRow | null | undefined): row is Pe
  * moves values between them. `null` is a real, selectable value meaning "no value"; an empty or
  * absent array is the absent filter.
  */
-interface QueryColumnFilter {
-    name: string;
-    includes?: unknown[];
-    excludes?: unknown[];
+export interface QueryColumnFilter {
+  name: string;
+  includes?: unknown[];
+  excludes?: unknown[];
 }
 /**
  * One selectable entry in a column's filter panel.
@@ -471,11 +566,11 @@ interface QueryColumnFilter {
  * Structurally identical to the datatable's own `DistinctValue`, deliberately — it is what lets the
  * HTTP response be handed straight to `[distincts]` with no mapper in between.
  */
-interface DistinctValue {
-    /** The raw stored value. `null` is a real entry meaning "no value", not an absent one. */
-    value: unknown;
-    /** What the user reads. Never matched on. */
-    label: string;
+export interface DistinctValue {
+  /** The raw stored value. `null` is a real entry meaning "no value", not an absent one. */
+  value: unknown;
+  /** What the user reads. Never matched on. */
+  label: string;
 }
 /**
  * A column's distinct values.
@@ -486,144 +581,130 @@ interface DistinctValue {
  * `hasMore` reports that the cap truncated the list, and the panel re-queries only when it is set or
  * the search term widens — so a dishonest `false` strands a user typing past the cap.
  */
-interface DistinctValuesResult {
-    matching: DistinctValue[];
-    remaining: DistinctValue[];
-    hasMore: boolean;
-}
-
-interface ProgramUnit {
-    id: string;
-    name: TranslatedString;
-    icon?: string;
-    /**
-     * Canonical unit type, exact-cased by the server's loader: 'query' | 'persistentObject' | 'url'.
-     * Kept as string rather than a union so an older client tolerates a newer server.
-     */
-    type: string;
-    queryId?: string;
-    persistentObjectId?: string;
-    /**
-     * For a persistentObject unit: the specific object to open — the menu entry deep-links to
-     * `/po/{type}/{objectId}`. Absent means the type's default list. For a composed page this is
-     * whatever stable string the app declared; the server's Actions class may ignore it.
-     */
-    objectId?: string;
-    /** For a url unit: the external address, rendered as a plain anchor (never a router link). */
-    url?: string;
-    order: number;
-    alias?: string;
-}
-interface ProgramUnitGroup {
-    id: string;
-    name: TranslatedString;
-    icon?: string;
-    order: number;
-    programUnits: ProgramUnit[];
-}
-interface ProgramUnitsConfiguration {
-    programUnitGroups: ProgramUnitGroup[];
-}
-
-declare enum ELookupDisplayType {
-    Dropdown = 0,
-    Modal = 1
-}
-interface LookupReferenceListItem {
-    name: string;
-    isTransient: boolean;
-    valueCount: number;
-    displayType: ELookupDisplayType;
-}
-interface LookupReference {
-    name: string;
-    isTransient: boolean;
-    displayType: ELookupDisplayType;
-    values: LookupReferenceValue[];
-}
-interface LookupReferenceValue {
-    key: string;
-    values: TranslatedString;
-    isActive: boolean;
-    extra?: Record<string, unknown>;
-}
-
-interface RetryActionPayload {
-    type: 'retry-action';
-    step: number;
-    title: string;
-    message?: string;
-    options: string[];
-    defaultOption?: string;
-    persistentObject?: PersistentObject;
-}
-interface RetryActionResult {
-    step: number;
-    option: string;
-    persistentObject?: PersistentObject;
-}
-
-interface EntityPermissions {
-    /**
-     * Whether the caller may list this type. Independently grantable from `canRead` — `Query/Person`
-     * alone lists rows while refusing a by-id load — and reported since preview.60. The combined
-     * `QueryRead` right bundles the two invisibly, which is why this was the one action introspection
-     * never mentioned.
-     */
-    canQuery: boolean;
-    canRead: boolean;
-    canCreate: boolean;
-    canEdit: boolean;
-    canDelete: boolean;
-}
-
-interface CustomActionDefinition {
-    name: string;
-    displayName: TranslatedString;
-    icon?: string;
-    description?: string;
-    showedOn: string;
-    selectionRule?: string;
-    refreshOnCompleted: boolean;
-    confirmationMessageKey?: string;
-    /**
-     * 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
-     * irreversible, because the colour warns and the prompt is what actually prevents the accident.
-     */
-    variant?: string;
-    offset: number;
-}
-
+export interface DistinctValuesResult {
+  matching: DistinctValue[];
+  remaining: DistinctValue[];
+  hasMore: boolean;
+}
+export interface ProgramUnit {
+  id: string;
+  name: TranslatedString;
+  icon?: string;
+  /**
+   * Canonical unit type, exact-cased by the server's loader: 'query' | 'persistentObject' | 'url'.
+   * Kept as string rather than a union so an older client tolerates a newer server.
+   */
+  type: string;
+  queryId?: string;
+  persistentObjectId?: string;
+  /**
+   * For a persistentObject unit: the specific object to open — the menu entry deep-links to
+   * `/po/{type}/{objectId}`. Absent means the type's default list. For a composed page this is
+   * whatever stable string the app declared; the server's Actions class may ignore it.
+   */
+  objectId?: string;
+  /** For a url unit: the external address, rendered as a plain anchor (never a router link). */
+  url?: string;
+  order: number;
+  alias?: string;
+}
+export interface ProgramUnitGroup {
+  id: string;
+  name: TranslatedString;
+  icon?: string;
+  order: number;
+  programUnits: ProgramUnit[];
+}
+export interface ProgramUnitsConfiguration {
+  programUnitGroups: ProgramUnitGroup[];
+}
+export declare enum ELookupDisplayType {
+  Dropdown = 0,
+  Modal = 1
+}
+export interface LookupReferenceListItem {
+  name: string;
+  isTransient: boolean;
+  valueCount: number;
+  displayType: ELookupDisplayType;
+}
+export interface LookupReference {
+  name: string;
+  isTransient: boolean;
+  displayType: ELookupDisplayType;
+  values: LookupReferenceValue[];
+}
+export interface LookupReferenceValue {
+  key: string;
+  values: TranslatedString;
+  isActive: boolean;
+  extra?: Record<string, unknown>;
+}
+export interface RetryActionPayload {
+  type: 'retry-action';
+  step: number;
+  title: string;
+  message?: string;
+  options: string[];
+  defaultOption?: string;
+  persistentObject?: PersistentObject;
+}
+export interface RetryActionResult {
+  step: number;
+  option: string;
+  persistentObject?: PersistentObject;
+}
+export interface EntityPermissions {
+  /**
+   * Whether the caller may list this type. Independently grantable from `canRead` — `Query/Person`
+   * alone lists rows while refusing a by-id load — and reported since preview.60. The combined
+   * `QueryRead` right bundles the two invisibly, which is why this was the one action introspection
+   * never mentioned.
+   */
+  canQuery: boolean;
+  canRead: boolean;
+  canCreate: boolean;
+  canEdit: boolean;
+  canDelete: boolean;
+  /**
+   * SoftDelete (#460): `Restore/T`, `Purge/T` and `ViewDeleted/T` (the recycle bin — query and load
+   * with `deleted: 'include' | 'only'`). Type-level only; a row may still refuse. Optional because a
+   * server older than 11.0.0-preview.91 does not send them — treat absent as `false`.
+   */
+  canRestore?: boolean;
+  canPurge?: boolean;
+  canViewDeleted?: boolean;
+  /** History (#460): `History/T` (list and read revisions) and `Revert/T` together with `Edit/T`. */
+  canViewHistory?: boolean;
+  canRevert?: boolean;
+  /** Contributions: `RevertContribution/T` (make a contribution current again; a generated contribution type only). */
+  canRevertContribution?: boolean;
+}
 /**
  * The opening message of a stream: the column metadata plus the rows so far.
  *
  * Columns arrive once, here. A stream is one result whose rows arrive over time, so its shape is
  * fixed when it opens — patches carry values only.
  */
-interface StreamingSnapshotMessage {
-    type: 'snapshot';
-    columns: QueryColumn[];
-    data: QueryResultItem[];
+export interface StreamingSnapshotMessage {
+  type: 'snapshot';
+  columns: QueryColumn[];
+  data: QueryResultItem[];
 }
-interface StreamingPatchItem {
-    id: string;
-    /** Changed cell values, keyed by column name. Never metadata — the snapshot fixed that. */
-    values: Record<string, any>;
+export interface StreamingPatchItem {
+  id: string;
+  /** Changed cell values, keyed by column name. Never metadata — the snapshot fixed that. */
+  values: Record<string, any>;
 }
-interface StreamingPatchMessage {
-    type: 'patch';
-    updated: StreamingPatchItem[];
+export interface StreamingPatchMessage {
+  type: 'patch';
+  updated: StreamingPatchItem[];
 }
-interface StreamingErrorMessage {
-    type: 'error';
-    message: string;
+export interface StreamingErrorMessage {
+  type: 'error';
+  message: string;
 }
-type StreamingMessage = StreamingSnapshotMessage | StreamingPatchMessage | StreamingErrorMessage;
-
+export type StreamingMessage = StreamingSnapshotMessage | StreamingPatchMessage | StreamingErrorMessage;
 /**
  * Conversions between the wire format for a timestamp and what an `<input type="datetime-local">`
  * or `<input type="date">` will accept.
@@ -641,7 +722,7 @@ type StreamingMessage = StreamingSnapshotMessage | StreamingPatchMessage | Strea
  * Parses a wire timestamp. Returns `null` for anything unusable, matching the contract of
  * `parsedDate` / `queryCellValue` -- a bad value renders as empty rather than as `Invalid Date`.
  */
-declare function parseWireDate(value: unknown): Date | null;
+export declare function parseWireDate(value: unknown): Date | null;
 /**
  * Wire value -> the `yyyy-MM-ddTHH:mm` a `datetime-local` input needs, in the **viewer's** zone.
  *
@@ -649,9 +730,9 @@ declare function parseWireDate(value: unknown): Date | null;
  * *on that value's own date*, so a timestamp in July and one in January convert differently in a
  * zone that observes DST.
  */
-declare function toDateTimeLocalInput(value: unknown): string;
+export declare function toDateTimeLocalInput(value: unknown): string;
 /** Wire value -> the `yyyy-MM-dd` a `date` input needs, in the viewer's zone. */
-declare function toDateInput(value: unknown): string;
+export declare function toDateInput(value: unknown): string;
 /**
  * `yyyy-MM-ddTHH:mm` from the control -> a complete ISO-8601 string carrying the viewer's offset
  * **for the entered date**.
@@ -665,9 +746,9 @@ declare function toDateInput(value: unknown): string;
  * before a fall-back and after a spring-forward. That is specified ECMAScript behaviour, and the
  * server's conversion helper deliberately reproduces the same choice so the two cannot drift.
  */
-declare function fromDateTimeLocalInput(local: unknown): string | null;
+export declare function fromDateTimeLocalInput(local: unknown): string | null;
 /** `yyyy-MM-dd` from a `date` control -> an ISO string at local midnight with the viewer's offset. */
-declare function fromDateInput(local: unknown): string | null;
+export declare function fromDateInput(local: unknown): string | null;
 /**
  * Compares two wire timestamps **by instant**, which is what a `DateTimeOffset` means in Spark.
  *
@@ -680,21 +761,20 @@ declare function fromDateInput(local: unknown): string | null;
  * the instant and silently hides a destroyed offset. Here comparing by instant is the correct thing:
  * we are asking "did the user change this value", not "is the offset intact".
  */
-declare function wireDatesEqual(a: unknown, b: unknown): boolean;
+export declare function wireDatesEqual(a: unknown, b: unknown): boolean;
 /** True for the attribute data types that are edited through a native date/time control. */
-declare function isDateDataType(dataType: string | null | undefined): dataType is 'date' | 'datetime';
+export declare function isDateDataType(dataType: string | null | undefined): dataType is 'date' | 'datetime';
 /** Wire -> control, picking the right shape for the data type. */
-declare function toDateInputValue(dataType: string | null | undefined, value: unknown): string;
+export declare function toDateInputValue(dataType: string | null | undefined, value: unknown): string;
 /** Control -> wire, picking the right shape for the data type. */
-declare function fromDateInputValue(dataType: string | null | undefined, value: unknown): string | null;
-
+export declare function fromDateInputValue(dataType: string | null | undefined, value: unknown): string | null;
 /**
  * Resolves an `EntityType` by its CLR type name (e.g. `"HR.Entities.Address"`).
  * Callers typically close over a list they already hold. `getEntityTypes()` is NOT cached --
  * it issues a request per call -- so resolve against a list you fetched once rather than
  * calling it inside the resolver.
  */
-type EntityTypeResolver = (clrTypeName: string) => EntityType | undefined;
+export type EntityTypeResolver = (clrTypeName: string) => EntityType | undefined;
 /**
  * Flattens a nested `PersistentObject` into the plain `Record<string, any>` shape the
  * form state uses throughout ng-spark. Primitive / reference attributes contribute their
@@ -704,7 +784,7 @@ type EntityTypeResolver = (clrTypeName: string) => EntityType | undefined;
  * This is the ONE place that reads the server's new AsDetail wire shape and collapses it
  * back to the flat dict the form components already handle.
  */
-declare function nestedPoToDict(po: PersistentObject | null | undefined): Record<string, any>;
+export declare function nestedPoToDict(po: PersistentObject | null | undefined): Record<string, any>;
 /**
  * Reserved key under which a flattened nested object keeps the breadcrumb the SERVER resolved for
  * that object itself (as opposed to {@link AS_DETAIL_BREADCRUMBS_KEY}, which keys the breadcrumbs
@@ -717,7 +797,7 @@ declare function nestedPoToDict(po: PersistentObject | null | undefined): Record
  * used to discard the resolved string, leaving the form to substitute `{Crumb}` against a dict that
  * can never contain it.
  */
-declare const AS_DETAIL_SELF_BREADCRUMB_KEY = "__sparkBreadcrumb";
+export declare const AS_DETAIL_SELF_BREADCRUMB_KEY = "__sparkBreadcrumb";
 /**
  * Reserved key under which a flattened nested object keeps its own row key — the value of whatever
  * property the server registered as that type's `[ValueKey]`.
@@ -737,7 +817,7 @@ declare const AS_DETAIL_SELF_BREADCRUMB_KEY = "__sparkBreadcrumb";
  * Safe to carry, for the same reason the breadcrumb is: `dictToNestedPo` walks the entity type's
  * attributes and never the dict's keys, so a reserved key is never sent back as an attribute.
  */
-declare const AS_DETAIL_ROW_KEY = "__sparkRowKey";
+export declare const AS_DETAIL_ROW_KEY = "__sparkRowKey";
 /**
  * The breadcrumb the server resolved for a flattened object, or null when it resolved to nothing.
  *
@@ -746,7 +826,7 @@ declare const AS_DETAIL_ROW_KEY = "__sparkRowKey";
  * (EntityMapper.cs:209-211). That is a placeholder, not data, and rendering it would be worse than
  * rendering nothing — it reads as a real value. `typeName` lets a caller filter it back out.
  */
-declare function selfBreadcrumb(row: Record<string, any> | null | undefined, typeName?: string): string | null;
+export declare function selfBreadcrumb(row: Record<string, any> | null | undefined, typeName?: string): string | null;
 /**
  * The same filter as {@link selfBreadcrumb}, for a caller holding the server's breadcrumb string
  * directly rather than a flattened row dict — `attr.object.breadcrumb` on a detail page, or a query
@@ -757,14 +837,14 @@ declare function selfBreadcrumb(row: Record<string, any> | null | undefined, typ
  * first; the two that read the string straight off the wire kept printing `BuildFeedback` and
  * `GateSettings` at users (#384). A second copy of the comparison is how that happens again.
  */
-declare function resolvedBreadcrumb(value: unknown, typeName?: string): string | null;
+export declare function resolvedBreadcrumb(value: unknown, typeName?: string): string | null;
 /**
  * Reserved key under which {@link nestedPoToDisplayRow} stashes the server-resolved breadcrumb of
  * each reference attribute (keyed by attribute name). Lets an AsDetail reference cell render the
  * label the server already resolved by id — page-independent — instead of guessing from a single
  * reference-query options page. Prefixed to avoid colliding with a real attribute name.
  */
-declare const AS_DETAIL_BREADCRUMBS_KEY = "__sparkBreadcrumbs";
+export declare const AS_DETAIL_BREADCRUMBS_KEY = "__sparkBreadcrumbs";
 /**
  * Reserved key under which a flattened row keeps the **wire** values of its date cells, keyed by
  * attribute name.
@@ -780,7 +860,7 @@ declare const AS_DETAIL_BREADCRUMBS_KEY = "__sparkBreadcrumbs";
  * instant is unchanged. Safe to carry for the same reason as the other reserved keys: the rebuild
  * walks the entity type's attributes, never the dict's keys.
  */
-declare const AS_DETAIL_ORIGINAL_DATES_KEY = "__sparkOriginalDates";
+export declare const AS_DETAIL_ORIGINAL_DATES_KEY = "__sparkOriginalDates";
 /**
  * Whether a flattened-row key is one this module reserved rather than a model attribute.
  *
@@ -790,7 +870,15 @@ declare const AS_DETAIL_ORIGINAL_DATES_KEY = "__sparkOriginalDates";
  * dict to build display text: a caller joining `Object.values(dict)` prints the row's guid and its
  * own breadcrumb as though they were fields.
  */
-declare function isReservedAsDetailKey(key: string): boolean;
+export declare function isReservedAsDetailKey(key: string): boolean;
+/**
+ * Reserved key under which a flattened row keeps the {@link PersistentObject.metadata} the server
+ * attached to it on load (an add-on's read-side facts — contributions' `{ contribution: { own } }`).
+ * Never sent back: `dictToNestedPo` walks the entity type's attributes, never the dict's keys.
+ */
+export declare const AS_DETAIL_METADATA_KEY = "__sparkMetadata";
+/** The metadata the server attached to a flattened row under `key`, or undefined. */
+export declare function rowMetadata<T = any>(row: Record<string, any> | null | undefined, key: string): T | undefined;
 /**
  * Like {@link nestedPoToDict}, but for the read-only detail display path. In addition to each
  * attribute's value it preserves the server-resolved per-reference `breadcrumb` under
@@ -798,7 +886,7 @@ declare function isReservedAsDetailKey(key: string): boolean;
  * regardless of whether the referenced document fits on the reference query's first options page.
  * The form/edit path keeps using {@link nestedPoToDict}, which never carries breadcrumbs.
  */
-declare function nestedPoToDisplayRow(po: PersistentObject | null | undefined): Record<string, any>;
+export declare function nestedPoToDisplayRow(po: PersistentObject | null | undefined): Record<string, any>;
 /**
  * Builds a nested `PersistentObject` from a flat dict against the schema in
  * <paramref name="entityType"/>. Used when the form is about to save — AsDetail attributes
@@ -809,22 +897,61 @@ declare function nestedPoToDisplayRow(po: PersistentObject | null | undefined):
  * `getEntityTypes()` list, keyed by CLR type name). Nested AsDetail inside AsDetail is
  * handled recursively.
  */
-declare function dictToNestedPo(dict: Record<string, any> | null | undefined, entityType: EntityType, resolve: EntityTypeResolver): PersistentObject;
-
+export declare function dictToNestedPo(dict: Record<string, any> | null | undefined, entityType: EntityType, resolve: EntityTypeResolver): PersistentObject;
+/**
+ * The one answer to "do these two reads hold the same content?", shared by History's revision diff
+ * and po-edit's three-way conflict merge.
+ *
+ * Two reads of identical content are NOT byte-identical: their envelopes carry per-read fields
+ * (etags, breadcrumbs, row keys, the wire values a flattened row keeps for its date cells) that
+ * differ between reads, and comparing them reports every AsDetail attribute as changed. Both
+ * functions below reduce a value to its content first. They come in two shapes because the two
+ * callers hold two shapes: History compares wire attributes, po-edit compares the flat form dict.
+ */
+/**
+ * A comparable form of a wire attribute's content.
+ *
+ * Nested objects (AsDetail rows, references rendered as objects) are reduced to their attributes'
+ * values: their envelopes carry per-read fields (etags, breadcrumbs, row keys) that differ between two
+ * reads of identical content and would report every AsDetail attribute as changed.
+ */
+export declare function comparableValue(attribute: PersistentObjectAttribute | undefined): string;
+/**
+ * A comparable form of a value in the flat form dict ({@link nestedPoToDict}'s shape).
+ *
+ * The reserved keys a flattened row carries (its row key, its breadcrumb, the wire values of its
+ * dates) are dropped, and object keys are sorted, so two flattenings of the same content compare
+ * equal whatever order their attributes arrived in. `undefined` and `null` are the same absence.
+ */
+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;
+/** 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. */
+export declare function isShowedOnDetail(showedOn: string | undefined | null): boolean;
 /**
  * The custom actions a query should offer, from the entity type's full set.
  *
  * `showedOn` must include the query side. The accepted values are `"detail"`, `"query"`
  * and `"both"` — as the server model and the custom-actions guide have always
- * documented. Both grids previously tested for `"list"`, a value nothing emits, so an
- * action authored per the documentation rendered nowhere at all.
+ * 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
+ * custom actions, and the grid offers them itself (see {@link defaultQueryActions}).
  *
  * ⚠️ This narrows what is DISPLAYED. It is NOT an authorization boundary: the grant
  * is, and it is enforced independently in `ExecuteCustomAction` regardless of which
  * query the caller clicked from — a caller can always POST directly.
  */
-declare function filterQueryActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
-
+export declare function filterQueryActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
+/** 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`.
+ */
+export declare function defaultQueryActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
 /**
  * Parses a custom action's `selectionRule` — a cardinality expression over the number
  * of selected rows — into a predicate.
@@ -842,29 +969,14 @@ declare function filterQueryActions(actions: CustomActionDefinition[]): CustomAc
  * Client-side this only drives whether a button is disabled. The server enforces the same
  * rule independently — and neither is an authorization boundary: the action's grant is.
  */
-declare function parseSelectionRule(rule?: string | null): (count: number) => boolean;
-
-type SparkSelectionMode = 'none' | 'single' | 'multiple';
-/**
- * The selection mode a grid needs in order to satisfy the actions offered on it.
- *
- * Derived rather than configured, 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.
- * Vidyano's query grid does the same thing — it renders the checkbox column only if some
- * action is selection-gated.
- *
- * `'single'` when every gated action is satisfied by one row and refused by two; anything
- * else that cares about the count gets `'multiple'`.
- */
-declare function selectionModeFor(actions: CustomActionDefinition[]): SparkSelectionMode;
-
+export declare function parseSelectionRule(rule?: string | null): (count: number) => boolean;
 /**
  * One selectable value, as replaced by a refresh hook. Mirrors the server's
  * `PersistentObjectAttributeOption`.
  */
-interface RefreshedOption {
-    key: string;
-    label?: Record<string, string>;
+export interface RefreshedOption {
+  key: string;
+  label?: Record<string, string>;
 }
 /**
  * What a refresh changed about one attribute's *presentation*.
@@ -876,25 +988,25 @@ interface RefreshedOption {
  * Mutating the existing object instead is inert, because the rendering computed would not re-run.
  * An overlay is the only shape that is both reactive and free.
  */
-interface AttributeOverlay {
-    isRequired?: boolean;
-    isReadOnly?: boolean;
-    isVisible?: boolean;
-    rules?: ValidationRule[];
-    query?: string;
-    /** `undefined` means the hook did not touch the options; an empty array means there are none. */
-    options?: RefreshedOption[];
+export interface AttributeOverlay {
+  isRequired?: boolean;
+  isReadOnly?: boolean;
+  isVisible?: boolean;
+  rules?: ValidationRule[];
+  query?: string;
+  /** `undefined` means the hook did not touch the options; an empty array means there are none. */
+  options?: RefreshedOption[];
 }
-type RefreshOverlay = Record<string, AttributeOverlay>;
+export type RefreshOverlay = Record<string, AttributeOverlay>;
 /** Applies an overlay to one attribute definition, returning a new object when anything changed. */
-declare function applyOverlay(attr: EntityAttributeDefinition, overlay: AttributeOverlay | undefined): EntityAttributeDefinition;
+export declare function applyOverlay(attr: EntityAttributeDefinition, overlay: AttributeOverlay | undefined): EntityAttributeDefinition;
 /**
  * Reads a refresh response into an overlay.
  *
  * 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.
  */
-declare function overlayFromResponse(response: PersistentObject): RefreshOverlay;
+export declare function overlayFromResponse(response: PersistentObject): RefreshOverlay;
 /**
  * Merges a refresh response's values into the live form.
  *
@@ -915,19 +1027,18 @@ declare function overlayFromResponse(response: PersistentObject): RefreshOverlay
  * @param current   values as they are now, which may have moved on
  * @param response  the reshaped object
  */
-declare function mergeRefreshValues(sent: Record<string, any>, current: Record<string, any>, response: PersistentObject): Record<string, any>;
-
+export declare function mergeRefreshValues(sent: Record<string, any>, current: Record<string, any>, response: PersistentObject): Record<string, any>;
 /** One rule failure, in the shape the form already renders per field. */
-interface RuleFailure {
-    attributeName: string;
-    ruleType: string;
-    message: string;
+export interface RuleFailure {
+  attributeName: string;
+  ruleType: string;
+  message: string;
 }
-interface EvaluableAttribute {
-    name: string;
-    label?: TranslatedString;
-    isRequired?: boolean;
-    rules?: ValidationRule[];
+export interface EvaluableAttribute {
+  name: string;
+  label?: TranslatedString;
+  isRequired?: boolean;
+  rules?: ValidationRule[];
 }
 /**
  * Evaluates an attribute's rules against a value, mirroring the server's `ValidationService`.
@@ -941,7 +1052,4 @@ interface EvaluableAttribute {
  * This exists because a refresh hook that imposes a rule needs it to bite before Save — previously
  * `rules` was carried on the wire and never evaluated in the browser at all.
  */
-declare function evaluateRules(attr: EvaluableAttribute, value: any): RuleFailure[];
-
-export { AS_DETAIL_BREADCRUMBS_KEY, AS_DETAIL_ORIGINAL_DATES_KEY, AS_DETAIL_ROW_KEY, AS_DETAIL_SELF_BREADCRUMB_KEY, ELookupDisplayType, EReferenceDisplayType, ShowedOn, applyOverlay, currentLanguage, dictToNestedPo, evaluateRules, filterQueryActions, fromDateInput, fromDateInputValue, fromDateTimeLocalInput, hasShowedOnFlag, isDateDataType, isPersistentObject, isQueryRow, isReservedAsDetailKey, mergeRefreshValues, nestedPoToDict, nestedPoToDisplayRow, overlayFromResponse, parseSelectionRule, parseWireDate, resolveTranslation, resolvedBreadcrumb, selectionModeFor, selfBreadcrumb, toDateInput, toDateInputValue, toDateTimeLocalInput, valueFor, wireDatesEqual };
-export type { AttributeGroup, AttributeOverlay, AttributeTab, CustomActionDefinition, DistinctValue, DistinctValuesResult, EntityAttributeDefinition, EntityPermissions, EntityType, EntityTypeResolver, EvaluableAttribute, LookupReference, LookupReferenceListItem, LookupReferenceValue, PersistentObject, PersistentObjectAttribute, PersistentObjectPermissions, ProgramUnit, ProgramUnitGroup, ProgramUnitsConfiguration, QueryColumn, QueryColumnFilter, QueryResult, QueryResultItem, QueryResultItemValue, RefreshOverlay, RefreshedOption, RetryActionPayload, RetryActionResult, RuleFailure, SparkCellColumn, SparkQuery, SparkQueryRenderMode, SparkQuerySortColumn, SparkRow, SparkSelectionMode, StreamingErrorMessage, StreamingMessage, StreamingPatchItem, StreamingPatchMessage, StreamingSnapshotMessage, TranslatedString, ValidationError, ValidationErrorResponse, ValidationRule };
+export declare function evaluateRules(attr: EvaluableAttribute, value: any): RuleFailure[];