@mintplayer/ng-spark 22.31.0 → 22.33.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mintplayer/ng-spark",
   "private": false,
-  "version": "22.31.0",
+  "version": "22.33.0",
   "description": "Angular component library for MintPlayer.Spark CRUD applications",
   "repository": {
     "type": "git",
@@ -160,6 +160,18 @@
       "types": "./types/mintplayer-ng-spark-moderation.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-moderation.mjs"
     },
+    "./notifications": {
+      "types": "./types/mintplayer-ng-spark-notifications.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-notifications.mjs"
+    },
+    "./organizations": {
+      "types": "./types/mintplayer-ng-spark-organizations.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-organizations.mjs"
+    },
+    "./organizations/accept": {
+      "types": "./types/mintplayer-ng-spark-organizations-accept.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-organizations-accept.mjs"
+    },
     "./panels": {
       "types": "./types/mintplayer-ng-spark-panels.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-panels.mjs"
@@ -204,10 +216,22 @@
       "types": "./types/mintplayer-ng-spark-routes.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-routes.mjs"
     },
+    "./score-renderers": {
+      "types": "./types/mintplayer-ng-spark-score-renderers.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-score-renderers.mjs"
+    },
     "./services": {
       "types": "./types/mintplayer-ng-spark-services.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-services.mjs"
     },
+    "./share": {
+      "types": "./types/mintplayer-ng-spark-share.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-share.mjs"
+    },
+    "./share/page": {
+      "types": "./types/mintplayer-ng-spark-share-page.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-share-page.mjs"
+    },
     "./shell": {
       "types": "./types/mintplayer-ng-spark-shell.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark-shell.mjs"

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

@@ -219,23 +219,22 @@ export declare function sparkActionClass(definition: CustomActionDefinition, siz
  * The one Spark grid: a `<bs-datatable>` rendering a query or a sub-query.
  *
  * This replaces two components that were the same grid written twice — and, counting
- * `spark-query-list`'s streaming and paged branches, the `<bs-datatable>` element itself written
- * three times. The duplication had already produced four user-visible bugs, each fixed on one
- * side and not the other: `[indeterminate]` on null booleans, permission state surviving a failed
+ * `spark-query-list`'s former streaming and paged branches, the `<bs-datatable>` element itself
+ * written three times. The duplication had already produced four user-visible bugs, each fixed on
+ * one side and not the other: `[indeterminate]` on null booleans, permission state surviving a failed
  * reload, a swallowed fetch failure, and virtual-scroll sizing. `SparkGridRenderers` was
  * extracted to stop that and could only take the stateless helpers with it; this takes the rest.
  *
- * ## What it deliberately does NOT own: streaming
+ * ## Where the rows come from
  *
- * `spark-grid-renderers.ts` records why — a websocket dependency graph must not reach the bundle
- * of every PO detail page, none of which stream. So rows can come from **either** side:
- *
- *  - unbound `data` — the grid fetches for itself, paging and sorting server-side;
+ *  - unbound `data` — the grid fetches for itself, paging and sorting server-side: over HTTP, or over
+ *    `/spark/live` when the grid is live (see {@link live});
  *  - bound `data` — the grid renders what it is given and never fetches.
  *
- * `spark-query-list` keeps the socket and feeds its snapshot in. This is the line `bs-datatable`
- * itself draws: `[data]` and `[fetch]` are mutually exclusive, and binding both makes `[fetch]`
- * win silently.
+ * This is the line `bs-datatable` itself draws: `[data]` and `[fetch]` are mutually exclusive, and
+ * binding both makes `[fetch]` win silently. Live rides on `[fetch]`, so server-side paging, sort,
+ * search and filters work the same live or not; every embedded grid, sub-query and card follows a live
+ * query, not only the query page.
  *
  * ## Reading its state
  *
@@ -246,6 +245,7 @@ export declare function sparkActionClass(definition: CustomActionDefinition, siz
  */
 export declare class SparkQueryGridComponent {
   private readonly sparkService;
+  private readonly liveService;
   private readonly gridRenderers;
   private readonly queryRefresh;
   private readonly injector;
@@ -282,11 +282,31 @@ export declare class SparkQueryGridComponent {
   /**
    * Rows supplied from outside. When bound, the grid renders these and runs no fetch.
    *
-   * This is how streaming stays out of this component (see the class comment). `null` — the
-   * default — means "fetch for yourself"; an empty array means "you have been given no rows",
-   * which is a different statement and renders an empty grid rather than triggering a load.
+   * `null` — the default — means "fetch for yourself"; an empty array means "you have been given no
+   * rows", which is a different statement and renders an empty grid rather than triggering a load.
+   * Bound rows are never live.
    */
   data: import("@angular/core").InputSignal<QueryResultItem[] | null>;
+  /**
+   * Whether this grid follows its query over `/spark/live` (X4): `undefined` — the default — follows the
+   * query's own `live` flag; `true`/`false` overrides it (`[live]="false"` on a dashboard tile).
+   *
+   * Live, the grid's current request (page, sort, search, column filters, parent, deleted modes — exactly
+   * the `/execute` body) is ONE server subscription, sent again as an `update` on every page, sort, search
+   * or filter change, and every pushed page is rendered as it arrives: rows that change, appear or leave.
+   * A subscription `error` clears the rows and shows the message; it is not retried (see {@link isLive}).
+   * A virtual-scrolling query is never live: its blocks are separate pages fetched as the user scrolls, and
+   * one subscription follows one page.
+   */
+  live: import("@angular/core").InputSignal<boolean | undefined>;
+  /**
+   * The live subscription ended with an error for the query loaded now. Reset by a new load; a live grid
+   * does not resubscribe by itself after an error (the answer would not change).
+   */
+  private readonly liveFailed;
+  /** Whether rows arrive over `/spark/live` right now: the query page shows its LIVE badge from this. */
+  readonly isLive: import("@angular/core").Signal<boolean>;
+  private liveWanted;
   /**
    * Server-side search term, passed through to the query.
    *
@@ -539,10 +559,9 @@ export declare class SparkQueryGridComponent {
   deleteRows(rows: QueryResultItem[], definition?: CustomActionDefinition): Promise<void>;
   isVirtualScrolling: import("@angular/core").Signal<boolean>;
   /**
-   * Columns as sent with the most recent fetched page.
+   * Columns as sent with the most recent fetched (or pushed) page.
    *
-   * A host binding `data` (streaming) supplies its own via the `columns` input instead — the
-   * snapshot carries them once, exactly as a paged result does.
+   * A host binding `data` supplies its own via the `columns` input instead.
    */
   private readonly fetchedColumns;
   /**
@@ -557,15 +576,7 @@ export declare class SparkQueryGridComponent {
    * each string names comes from `bsDatatableColumnLabel` in the template. See `sparkDatatableLabels`.
    */
   datatableLabels: import("@angular/core").Signal<import("@mintplayer/ng-spark/services").SparkDatatableLabels>;
-  /**
-   * True when rows do not come from this component's own fetch.
-   *
-   * Either because the host bound `data`, or because the query streams — a streaming query's rows
-   * arrive over a socket and `/execute` is not a way to get them. The grid recognises the second
-   * case itself rather than waiting to be told, because it resolves the query before the host can
-   * see it: left to `data` alone, every streaming grid would fire one pointless fetch on mount,
-   * before the host had anything to bind.
-   */
+  /** True when rows do not come from this component's own fetch: the host bound `data`. */
   hasExternalData: import("@angular/core").Signal<boolean>;
   /**
    * Whether an action can run right now: its selection rule is satisfied, and the client method it
@@ -578,6 +589,22 @@ export declare class SparkQueryGridComponent {
    */
   actionUnavailableReason(action: CustomActionDefinition): string | null;
   constructor();
+  /** The live subscription of the query loaded now, while the grid is live. */
+  private liveSession;
+  private disposeLive;
+  /**
+   * A pushed page: re-fetch through the datatable, which lands in the live fetch and is served from
+   * memory. Through `reload()` rather than a new `[fetch]` identity, so page, sort and scroll stay.
+   */
+  private onLivePush;
+  /**
+   * A live subscription error (defect 4): clear the rows — a stale page must never stay up looking current
+   * — and say why. Not retried: `unavailable` (unknown, forbidden, not live, missing parent — one answer),
+   * `invalid`, `limit` and `failed` would answer the same again, and a socket-level failure (4429, a
+   * repeated 4401) is the socket's to surface. No HTTP fallback either: `unavailable` is the same answer
+   * `/execute` gives as a 404, and an app stream's rows exist only on the socket.
+   */
+  private onLiveError;
   /**
    * Re-run the query, keeping the current page, sort and scroll position.
    *
@@ -689,7 +716,26 @@ export declare class SparkQueryGridComponent {
    * rendered correctly as a page. Both grids are this one now, so there is one answer.
    */
   private resolveEntityType;
+  /** The datatable's `[fetch]`: over `/spark/live` when the grid is live (see {@link live}), else HTTP. */
   private makeFetch;
+  /**
+   * The `/execute` body for one datatable request — the same for HTTP and live. Read at call time, so
+   * what forces a refetch is the fetch identity `reload()` creates, not the value captured when the
+   * closure was built.
+   */
+  private requestFor;
+  /**
+   * One page as the datatable takes it, recording what the chrome reads off a result: count, columns,
+   * the result's withheld actions, the ids on screen.
+   */
+  private toPage;
+  /**
+   * Live: the request goes to this grid's {@link LiveGridSession} — subscribed on the first fetch, sent as
+   * an `update` when it changes, answered from the latest push when it does not. After an error every fetch
+   * is an empty page and the error stays shown.
+   */
+  private makeLiveFetch;
+  private makeHttpFetch;
   private loadLookupReferenceOptions;
   /**
    * The underlying value a custom renderer receives, which is not the printable one.
@@ -730,6 +776,11 @@ export declare class SparkQueryGridComponent {
       "required": false;
       "isSignal": true;
     };
+    "live": {
+      "alias": "live";
+      "required": false;
+      "isSignal": true;
+    };
     "search": {
       "alias": "search";
       "required": false;

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

@@ -341,6 +341,12 @@ export interface EntityType {
    */
   canRead?: boolean;
   alias?: string;
+  /**
+   * Whether an object of this type is followed over `/spark/live` (X4): `spark-po-detail` replaces the
+   * shown object when it changes and shows the unavailable state when it is deleted, and `spark-po-edit`
+   * adopts a newer version (or offers a merge when the form is dirty). Opt-in per type.
+   */
+  live?: boolean;
   /**
    * Breadcrumb template: literal text plus `{AttributeName}` placeholders. A scalar placeholder
    * renders its value; a reference placeholder renders the referenced entity's breadcrumb.
@@ -409,8 +415,12 @@ export interface SparkQuery {
   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 grids showing this query follow it over `/spark/live` (X4): the page re-renders when a row in
+   * it changes, appears or disappears, with server-side paging, sort, search and filters intact. Opt-in
+   * per query; a grid's `[live]` input overrides it. See `docs/guide-live-updates.md`.
+   */
+  live?: 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.
@@ -734,30 +744,153 @@ export interface EntityPermissions {
   canRevertContribution?: boolean;
 }
 /**
- * The opening message of a stream: the column metadata plus the rows so far.
+ * The live-updates protocol (`/spark/live`, X4), as `docs/guide-live-updates.md` "The protocol" fixes it.
  *
- * 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.
+ * One WebSocket per browser tab carries every subscription; one JSON object per text frame. Subscriptions
+ * are reads only: mutations stay on HTTP.
  */
-export interface StreamingSnapshotMessage {
-  type: 'snapshot';
-  columns: QueryColumn[];
-  data: QueryResultItem[];
-}
-export interface StreamingPatchItem {
+/** A subscription to one persistent object: exactly the body of `POST /spark/po/load`. */
+export interface LivePoRequest {
+  objectTypeId: string;
   id: string;
-  /** Changed cell values, keyed by column name. Never metadata — the snapshot fixed that. */
-  values: Record<string, any>;
+  deleted?: SparkDeletedFilter | null;
+}
+/** A sort column as `/spark/queries/execute` takes it. */
+export interface LiveSortColumn {
+  property: string;
+  direction: 'asc' | 'desc';
+}
+/**
+ * A subscription to one page of a query: exactly the body of `POST /spark/queries/execute`
+ * (`retryResults` is ignored by the server — a push cannot prompt).
+ */
+export interface LiveQueryRequest {
+  queryId: string;
+  skip?: number | null;
+  take?: number | null;
+  sortColumns?: LiveSortColumn[] | null;
+  search?: string | null;
+  columns?: QueryColumnFilter[] | null;
+  parentId?: string | null;
+  parentType?: string | null;
+  deleted?: SparkDeletedFilter | null;
+  parentDeleted?: SparkDeletedFilter | null;
+}
+export interface LiveSubscribePoOp {
+  op: 'subscribe';
+  sub: string;
+  po: LivePoRequest;
+}
+export interface LiveSubscribeQueryOp {
+  op: 'subscribe';
+  sub: string;
+  query: LiveQueryRequest;
+}
+/** The same query subscription with a new page, sort, search or filters; the server keeps the sub. */
+export interface LiveUpdateOp {
+  op: 'update';
+  sub: string;
+  query: LiveQueryRequest;
+}
+export interface LiveUnsubscribeOp {
+  op: 'unsubscribe';
+  sub: string;
 }
-export interface StreamingPatchMessage {
+export type LiveClientOp = LiveSubscribePoOp | LiveSubscribeQueryOp | LiveUpdateOp | LiveUnsubscribeOp;
+/** `error` codes. Every one ends its subscription; the socket stays open. */
+export type LiveErrorCode = 'unavailable' | 'invalid' | 'limit' | 'failed';
+/** The changes to a held persistent object: top-level fields (`null` = removed) and whole attributes, by `name`. */
+export interface LivePoPatch {
+  set?: Record<string, unknown>;
+  attributes?: PersistentObjectAttribute[];
+}
+/**
+ * The changes to a held query page. Apply: index the held rows by `id`; drop `remove`; replace or add each
+ * `upsert`; the rows are `order` mapped through the index when present, otherwise the held order minus the
+ * removed rows; then assign `set` (`totalItems`, `skip`, `take`, `disabledActions`, `typeHints`, …).
+ */
+export interface LiveQueryPatch {
+  upsert?: QueryResultItem[];
+  remove?: string[];
+  order?: string[];
+  set?: Record<string, unknown>;
+}
+/** The first state of an object, or one whose set or order of attributes changed. Replace. */
+export interface LivePoFrame {
+  type: 'po';
+  sub: string;
+  po: PersistentObject;
+}
+export interface LivePoPatchFrame {
+  type: 'poPatch';
+  sub: string;
+  patch: LivePoPatch;
+}
+/** Deleted or no longer readable (one answer). The subscription has ended. */
+export interface LiveGoneFrame {
+  type: 'gone';
+  sub: string;
+}
+/** The first page, a page whose columns changed, or a change a patch would not make smaller. Replace. */
+export interface LiveResultFrame {
+  type: 'result';
+  sub: string;
+  result: QueryResult;
+}
+export interface LivePatchFrame {
   type: 'patch';
-  updated: StreamingPatchItem[];
+  sub: string;
+  patch: LiveQueryPatch;
 }
-export interface StreamingErrorMessage {
+/** The subscription has ended. Without `sub` it answers an unparseable frame. */
+export interface LiveErrorFrame {
   type: 'error';
+  sub?: string;
+  code: LiveErrorCode;
   message: string;
 }
-export type StreamingMessage = StreamingSnapshotMessage | StreamingPatchMessage | StreamingErrorMessage;
+/** Heartbeat. Nothing to answer. */
+export interface LivePingFrame {
+  type: 'ping';
+}
+export type LiveServerFrame = LivePoFrame | LivePoPatchFrame | LiveGoneFrame | LiveResultFrame | LivePatchFrame | LiveErrorFrame | LivePingFrame;
+/** Close codes with a meaning of their own; any other code is reconnected with backoff. */
+export declare const LIVE_CLOSE_REAUTHENTICATE = 4401;
+export declare const LIVE_CLOSE_TOO_MANY_SOCKETS = 4429;
+export declare const LIVE_CLOSE_MESSAGE_TOO_LARGE = 1009;
+/**
+ * Why a watcher's subscription ended, beyond the server's own {@link LiveErrorCode}s — the socket-level
+ * failures the client surfaces instead of retrying:
+ * - `tooManySockets`: closed with 4429; not reconnected until a new watcher asks.
+ * - `unauthenticated`: closed with 4401 again within seconds of reconnecting for a 4401.
+ * - `messageTooLarge`: closed with 1009, a client bug; not retried blindly.
+ */
+export type LiveFailureCode = LiveErrorCode | 'tooManySockets' | 'unauthenticated' | 'messageTooLarge';
+export interface LiveErrorEvent {
+  type: 'error';
+  code: LiveFailureCode;
+  message: string;
+}
+/** `po`: the object with every patch applied. `gone` and `error` end the stream (it completes after them). */
+export type LivePoEvent = {
+  type: 'po';
+  po: PersistentObject;
+} | {
+  type: 'gone';
+} | LiveErrorEvent;
+/** `result`: the page with every patch applied. `error` ends the stream (it completes after it). */
+export type LiveQueryEvent = {
+  type: 'result';
+  result: QueryResult;
+} | LiveErrorEvent;
+/**
+ * Applies a `patch` frame to a held page, exactly as the protocol says. A new id in `upsert` that `order`
+ * does not place (the server always sends `order` when membership changes, so this is defensive) is
+ * appended rather than dropped.
+ */
+export declare function applyLiveQueryPatch(held: QueryResult, patch: LiveQueryPatch): QueryResult;
+/** Applies a `poPatch` frame to a held object: `set` assigned, changed attributes replaced by `name`. */
+export declare function applyLivePoPatch(held: PersistentObject, patch: LivePoPatch): PersistentObject;
 /**
  * Conversions between the wire format for a timestamp and what an `<input type="datetime-local">`
  * or `<input type="date">` will accept.

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

@@ -0,0 +1,188 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Provider, Signal } from "@angular/core";
+import { QueryResultItem } from "@mintplayer/ng-spark/models";
+import { ConnectedPosition } from "@angular/cdk/overlay";
+import { Color } from "@mintplayer/ng-bootstrap";
+/** The `Notification` entity type of `MintPlayer.Spark.Notifications` (`App_Data/Model/Notification.json`). */
+export declare const SPARK_NOTIFICATION_TYPE_ID = "411e3be6-5da0-5d84-bc21-001888fafc6d";
+/** `MyNotifications` (alias `notifications`): the caller's notifications, newest first. Live. */
+export declare const SPARK_MY_NOTIFICATIONS_QUERY_ID = "7123c201-9aed-50f9-9d9a-ede2491af7f9";
+/** `UnreadNotifications` (alias `unread-notifications`): the caller's unread ones. Live. */
+export declare const SPARK_UNREAD_NOTIFICATIONS_QUERY_ID = "a205d3e5-ff6e-5260-ac9e-e5c6b16644c9";
+/** One notification as the bell lists it: a row of `MyNotifications`. */
+export interface SparkNotification {
+  id: string;
+  title: string;
+  body: string | null;
+  /**
+   * The link, when the row carries it. `Url` is a detail-only attribute in the shipped model, so a row
+   * usually does not, and {@link SparkNotificationsService.open} loads it from the object instead.
+   */
+  url: string | null;
+  isRead: boolean;
+  createdAt: Date | null;
+}
+/** A query row of `MyNotifications` as a {@link SparkNotification}. */
+export declare function toSparkNotification(item: QueryResultItem): SparkNotification;
+/** Options of the notification bell and service. */
+export interface SparkNotificationsOptions {
+  /** How many of the latest notifications the bell lists. Default 8. */
+  recentCount: number;
+  /** Where "All notifications" goes: a router link. Default `['/query', 'notifications']` (the `MyNotifications` alias). */
+  listLink: string | readonly unknown[];
+}
+export declare const SPARK_NOTIFICATIONS_OPTIONS: InjectionToken<SparkNotificationsOptions>;
+/** Overrides {@link SparkNotificationsOptions}; anything left out keeps its default. */
+export declare function provideSparkNotifications(options?: Partial<SparkNotificationsOptions>): Provider;
+/** The browser's Notification API, as far as push needs it. */
+export interface SparkNotificationPermissions {
+  readonly permission: NotificationPermission;
+  requestPermission(): Promise<NotificationPermission>;
+}
+/**
+ * What the browser offers for Web Push: the Notification API, or `null` when there is no Notification,
+ * no `PushManager` or no service worker. That is the case in Safari on iPhone and iPad until the app is
+ * added to the Home Screen, so `null` reads as "install the app first". Replaceable for tests.
+ */
+export declare const SPARK_PUSH_PERMISSIONS: InjectionToken<SparkNotificationPermissions | null>;
+/**
+ * Web Push on this device: `unsupported` (no service worker, no PushManager or no Notification API:
+ * an iPhone/iPad needs the app on its Home Screen), `denied` (blocked in the browser's settings),
+ * `off` or `on`.
+ */
+export type SparkPushState = 'unsupported' | 'denied' | 'off' | 'on';
+/**
+ * The client of `MintPlayer.Spark.Notifications` (`docs/seo_analyzer_PRD.md` X10, D20, D30).
+ *
+ * - **In-app**: {@link unreadCount} and {@link recent} follow the live queries `UnreadNotifications`
+ *   (one row, for its `totalItems`) and `MyNotifications` (the latest few) over the ONE `/spark/live`
+ *   socket of {@link SparkLiveService}. Nothing polls and there is no second channel: a new, read or
+ *   deleted notification arrives as a patch. The subscriptions start again whenever `SPARK_AUTH_STATE`
+ *   changes (sign-in, sign-out), so a page opened before signing in still counts afterwards.
+ * - **Web Push**: {@link enablePush} / {@link disablePush} subscribe this device through Angular's
+ *   `SwPush` and register it at `/spark/notifications/push/*`. It needs `provideSparkServiceWorker()`
+ *   (or `provideServiceWorker`) with the worker enabled; without it {@link pushState} is `unsupported`.
+ */
+export declare class SparkNotificationsService {
+  private readonly http;
+  private readonly live;
+  private readonly spark;
+  private readonly router;
+  private readonly location;
+  private readonly document;
+  private readonly swPush;
+  private readonly permissions;
+  private readonly options;
+  private readonly baseUrl;
+  private readonly browser;
+  private readonly unread;
+  private readonly latest;
+  /** Unread notifications of the signed-in user; 0 until the first result and while signed out. */
+  readonly unreadCount: Signal<number>;
+  /** The latest notifications (read or not), newest first; empty until the first result. */
+  readonly recent: Signal<SparkNotification[]>;
+  /** Whether {@link recent} holds a result yet. */
+  readonly loaded: Signal<boolean>;
+  /** Whether this browser can receive Web Push here at all (see {@link SparkPushState}). */
+  readonly pushSupported: boolean;
+  private readonly permission;
+  private readonly subscribed;
+  private readonly configured;
+  private readonly busy;
+  private publicKey;
+  /** Web Push on this device. */
+  readonly pushState: Signal<SparkPushState>;
+  /**
+   * Whether the server sends Web Push (`GET /spark/notifications/push/key` answered a key): `null` while
+   * unknown, `false` when Web Push is not configured or nobody is signed in. Offer no push UI unless `true`.
+   */
+  readonly pushConfigured: Signal<boolean | null>;
+  /** True while {@link enablePush} or {@link disablePush} runs. */
+  readonly pushBusy: Signal<boolean>;
+  constructor();
+  /**
+   * Marks notifications read: the given ids, or every unread one of the caller when `ids` is omitted.
+   * Resolves to how many changed. The live queries then deliver the new state; nothing is set locally.
+   */
+  markRead(ids?: readonly string[]): Promise<number>;
+  /**
+   * Opens a notification: marks it read when it is not, then follows its link, in-app through the router
+   * for a URL on this origin, as a page load for another `http(s)` URL. A row without its `Url` (a
+   * detail-only attribute in the shipped model) is loaded once for it.
+   */
+  open(notification: SparkNotification): Promise<void>;
+  /**
+   * Turns Web Push on for this device. Call it straight from a click handler: the permission prompt is
+   * requested before anything is awaited, because Safari only grants it to a user gesture. Resolves to
+   * whether the device is now subscribed; a refusal, a missing key or a subscription the server rejects
+   * (400: a push service outside its allow-list) is `false`.
+   */
+  enablePush(): Promise<boolean>;
+  /** Turns Web Push off for this device: the server forgets it, then the browser unsubscribes. */
+  disablePush(): Promise<void>;
+  private follow;
+  private loadPublicKey;
+  private loadUrl;
+  private navigate;
+  /** A full page load (overridden in specs: jsdom cannot navigate). */
+  protected assign(href: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkNotificationsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** English fallbacks of `notifications.spa.*`, shown until the server's translations arrive. */
+export declare const SPARK_NOTIFICATION_TEXTS: Record<string, string>;
+/**
+ * The Web Push opt-in for this device, on its own (an account or settings page); the notification bell
+ * shows the same control. Renders nothing unless the server sends Web Push. Otherwise: a button to turn
+ * it on or off, or why it cannot be (blocked in the browser, or a browser without push: on iPhone and
+ * iPad the app must be on the Home Screen first).
+ */
+export declare class SparkPushToggleComponent {
+  protected readonly notifications: SparkNotificationsService;
+  private readonly language;
+  protected t(key: string): string;
+  /** Synchronous up to the permission prompt: this is the click handler the prompt needs. */
+  protected enable(): void;
+  protected disable(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkPushToggleComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkPushToggleComponent, "spark-push-toggle", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The notification bell for an app's top bar (`docs/seo_analyzer_PRD.md` X10): the unread count as a
+ * badge, live; a menu with the latest notifications (title, message, relative time), "Mark all as read",
+ * a link to the full list and, where this browser can receive it, the Web Push opt-in. Choosing a
+ * notification marks it read and follows its link.
+ */
+export declare class SparkNotificationBellComponent {
+  protected readonly notifications: SparkNotificationsService;
+  private readonly language;
+  private readonly options;
+  protected readonly colors: typeof Color;
+  /** Where "All notifications" goes. Default: `provideSparkNotifications({ listLink })`, else the `notifications` query page. */
+  readonly allLink: import("@angular/core").InputSignal<string | readonly unknown[] | null>;
+  readonly open: import("@angular/core").WritableSignal<boolean>;
+  protected readonly listLink: import("@angular/core").Signal<string | readonly unknown[]>;
+  protected readonly countText: import("@angular/core").Signal<string>;
+  protected readonly ariaLabel: import("@angular/core").Signal<string>;
+  readonly positions: ConnectedPosition[];
+  protected t(key: string): string;
+  protected when(notification: SparkNotification): string;
+  close(): void;
+  /** A click outside closes the menu, except on the bell itself, whose own handler toggles it. */
+  onOutsideClick(event: MouseEvent, toggle: HTMLElement): void;
+  choose(notification: SparkNotification): Promise<void>;
+  markAllRead(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkNotificationBellComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkNotificationBellComponent, "spark-notification-bell", never, {
+    "allLink": {
+      "alias": "allLink";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * `date` relative to `now` in `language` ("5 minutes ago", "il y a 5 minutes", "5 minuten geleden"),
+ * through `Intl.RelativeTimeFormat`; "now" under a minute. Empty for a missing date.
+ */
+export declare function sparkRelativeTime(date: Date | null | undefined, now: number, language: string): string;

package/types/mintplayer-ng-spark-organizations-accept.d.ts

@@ -0,0 +1,40 @@
+import { Color } from "@mintplayer/ng-bootstrap";
+import * as i0 from "@angular/core";
+/** What `POST /spark/organizations/accept` answers. */
+export interface SparkOrganizationAcceptance {
+  accepted: boolean;
+  organizationId: string | null;
+  organization: string | null;
+  problem: string | null;
+  /** Which refusal: `invalid` (any unknown, used or expired link) or `otherAddress` (D43). */
+  reason?: 'invalid' | 'otherAddress' | null;
+}
+/**
+ * The target of a mailed organization invitation or join request
+ * (`/organizations/accept/:token?id=<invitationId>`, `docs/seo_analyzer_PRD.md` D18). Accepting is an
+ * explicit click, never a side effect of opening the link (mail scanners open links). An invitation
+ * makes the signed-in account a member; a join request lets its requester in and needs an Owner or
+ * Admin. Every failure reads the same, except a valid invitation opened by an account that does not own
+ * the invited address (D43): the page says so, so the user can sign in with the right account.
+ */
+export declare class SparkAcceptOrganizationInvitationComponent {
+  private readonly http;
+  private readonly route;
+  private readonly translations;
+  protected readonly colors: typeof Color;
+  private readonly token;
+  private readonly invitationId;
+  /** A link without both values cannot be an invitation. */
+  protected readonly valid: boolean;
+  readonly busy: import("@angular/core").WritableSignal<boolean>;
+  readonly failed: import("@angular/core").WritableSignal<boolean>;
+  /** The refusal to show: a translation key under `organizations.spa`. */
+  readonly reason: import("@angular/core").WritableSignal<"invalid" | "otherAddress">;
+  /** The organization joined, once accepted. */
+  readonly joined: import("@angular/core").WritableSignal<SparkOrganizationAcceptance | null>;
+  /** The page's texts: `organizations.spa.*` in the organizations library's `translations.json`. */
+  protected t(key: string): string;
+  accept(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkAcceptOrganizationInvitationComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkAcceptOrganizationInvitationComponent, "spark-accept-organization-invitation", never, {}, {}, never, never, true, never>;
+}