@yuuvis/client-framework 3.4.2 → 3.6.0

package/renderer/README.md

@@ -1,5 +1,215 @@
 # @yuuvis/client-framework/renderer
 
-Secondary entry point of `@yuuvis/client-framework`. It can be used by importing from `@yuuvis/client-framework/renderer`.
+Secondary entry point of `@yuuvis/client-framework`. Import everything from `@yuuvis/client-framework/renderer`.
 
-Provides default renderers for object type properties. Also comes with the `renderer.service` that allows to register custom renderers.
+Provides a pluggable rendering layer for two distinct things:
+
+1. **Property renderers** — components that render a single object-type property value (string, integer, datetime, file size, organization, table, …) inside list rows, summary panels, tile slots, smart-search results, and detail headers.
+2. **Audit renderers** — components that render the inner content of a single entry in the audit timeline (`ObjectAuditComponent`), keyed by the audit `action` (and optionally `subaction`).
+
+Both subsystems share the same shape: a service that maintains a registry, an abstract base component that consumers extend, and a directive that resolves and instantiates the right component for a given input.
+
+## Public API
+
+| Export | Kind | Purpose |
+|---|---|---|
+| `RendererService` | service (`providedIn: 'root'`) | Registry for property renderers. |
+| `RendererDirective` (`*yuvRenderer`) | structural directive | Renders a `ResolvedObjectConfigItem` using the registered renderer. |
+| `AbstractRendererComponent<T, U>` | abstract component | Base class for custom property renderers. |
+| `RendererComponent` | type | Union of the built-in property renderer components. |
+| `RendererDirectiveInput` | type alias of `ResolvedObjectConfigItem` | Input shape for `*yuvRenderer`. |
+| `AuditRendererService` | service (`providedIn: 'root'`) | Registry for audit-entry renderers. |
+| `AuditRendererDirective` (`[yuvAuditRenderer]`) | attribute directive | Renders an `AuditEntry` using the registered renderer. |
+| `AbstractAuditRendererComponent` | abstract component | Base class for custom audit renderers. |
+| `DefaultAuditRendererComponent` | component | Built-in fallback that resolves localized audit labels for all known actions (100, 200, 300, 400, custom 10000). |
+| Built-in property renderers | components | `StringRendererComponent`, `IntegerRendererComponent`, `DecimalRendererComponent`, `BooleanRendererComponent`, `DateTimeRendererComponent`, `FileSizeRendererComponent`, `IconRendererComponent`, `OrganizationRendererComponent`, `TableRendererComponent`, `UnknownRendererComponent` (fallback). |
+
+---
+
+## Property renderers
+
+### Rendering a property — `*yuvRenderer`
+
+`*yuvRenderer` takes a `ResolvedObjectConfigItem` and instantiates the matching renderer into the host view. The host owns the layout; the directive owns the value cell.
+
+```html
+@for (property of object.properties; track property.propertyName) {
+  <div class="row">
+    <div class="label">{{ property.label }}</div>
+    <div class="value">
+      <ng-container *yuvRenderer="property.value" />
+    </div>
+  </div>
+}
+```
+
+Input shape:
+
+```ts
+interface ResolvedObjectConfigItem {
+  propertyName: string;              // schema property name (e.g. 'system:contentStreamLength')
+  rendererType?: RendererType;       // optional explicit renderer key — wins over propertyName lookup
+  value?: unknown;                   // the value passed to the renderer
+  meta?: Record<string, unknown>;    // additional context (e.g. *_title for user fields)
+}
+```
+
+Resolution order inside `RendererService`:
+
+1. If `rendererType` is set → look up by that key (`getRendererByType`).
+2. Otherwise look up by `propertyName` (`getRenderer`). If not registered, fall back to the property's internal field type derived from `SystemService`.
+3. If nothing matches → `UnknownRendererComponent`.
+
+The directive re-renders only when the input object actually changes (deep equality via `JSON.stringify`).
+
+### Built-in registrations
+
+`RendererService` ships with these defaults (in `RendererService` constructor):
+
+| Key | Component |
+|---|---|
+| `integer` | `IntegerRendererComponent` |
+| `decimal` | `DecimalRendererComponent` |
+| `datetime` | `DateTimeRendererComponent` |
+| `icon` | `IconRendererComponent` |
+| `string` | `StringRendererComponent` |
+| `boolean` | `BooleanRendererComponent` |
+| `table` | `TableRendererComponent` |
+| `InternalFieldType.STRING_ORGANIZATION` / `STRING_ORGANIZATION_SET` | `OrganizationRendererComponent` |
+| `ContentStreamField.LENGTH` | `FileSizeRendererComponent` |
+
+### Registering a custom renderer
+
+Get the service and call one of the registration methods. Either overrides the default for that key.
+
+```ts
+import { inject, Injectable } from '@angular/core';
+import { RendererService } from '@yuuvis/client-framework/renderer';
+import { MyHashRendererComponent } from './my-hash.renderer';
+
+@Injectable({ providedIn: 'root' })
+export class MyAppRendererSetup {
+  #renderers = inject(RendererService);
+
+  init(): void {
+    // Override by renderer type (matches `rendererType` on ResolvedObjectConfigItem)
+    this.#renderers.registerRendererByType('string', MyHashRendererComponent);
+
+    // Or scope to a single property — and optionally to a specific object type
+    this.#renderers.registerRenderer(MyHashRendererComponent, 'document:sha256');
+    this.#renderers.registerRenderer(MyHashRendererComponent, 'document:sha256', 'system:document');
+  }
+}
+```
+
+Call this from `APP_INITIALIZER` or any service that runs before the views using the directive are constructed. Registrations are stored in a signal, so consumers that re-resolve their renderer will pick up changes; however the directive only re-resolves when its input changes — switching renderers at runtime requires re-pushing the input.
+
+### Writing a custom property renderer
+
+Extend `AbstractRendererComponent<T, U>`. `T` is the value type, `U` is the meta-shape (defaults to `null`).
+
+```ts
+import { ChangeDetectionStrategy, Component, computed } from '@angular/core';
+import { AbstractRendererComponent } from '@yuuvis/client-framework/renderer';
+
+@Component({
+  selector: 'app-hash-renderer',
+  standalone: true,
+  template: `<code class="hash" [title]="value()">{{ short() }}</code>`,
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class MyHashRendererComponent extends AbstractRendererComponent<string> {
+  protected short = computed(() => this.value()?.slice(0, 12) ?? '');
+}
+```
+
+The base class exposes:
+
+- `propertyName = input.required<string>()`
+- `value = input.required<T | null>()`
+- `meta = input<Record<string, unknown> | U>()`
+- `getProperty(): SchemaResponseFieldDefinition | undefined` — schema definition for the property from `SystemService`.
+
+All renderers must be `standalone: true` and should use `ChangeDetectionStrategy.OnPush`.
+
+---
+
+## Audit renderers
+
+### Rendering an audit entry — `[yuvAuditRenderer]`
+
+`[yuvAuditRenderer]` is the attribute-directive twin for the audit timeline. The host component (`ObjectAuditComponent`) owns the date column, timeline line, version badge, and creator label; the renderer owns the *inner content* of the entry.
+
+```html
+@for (item of items(); track item.creationDate + '-' + item.action) {
+  <li class="audit">
+    <time>{{ item.creationDate | localeDate }}</time>
+    <div class="content"><ng-container [yuvAuditRenderer]="item" /></div>
+    <span class="version">v{{ item.version }}</span>
+    <div class="creator">{{ item.createdBy.title }}</div>
+  </li>
+}
+```
+
+Resolution order inside `AuditRendererService.getAuditRenderer(action, subaction)`:
+
+1. `(action, subaction)` — if `subaction` is provided and a renderer is registered for the exact pair.
+2. `(action)` — action-only registration.
+3. `DefaultAuditRendererComponent` — built-in fallback that translates the well-known audit labels (`yuv.audit.label.*`) for actions 100/200/300/400 and custom action 10000.
+
+### Registering a custom audit renderer
+
+```ts
+import { inject, Injectable } from '@angular/core';
+import { AuditRendererService } from '@yuuvis/client-framework/renderer';
+import { CreatedAuditRendererComponent } from './created-audit.renderer';
+import { UpdatedAuditRendererComponent } from './updated-audit.renderer';
+
+@Injectable({ providedIn: 'root' })
+export class MyAppAuditSetup {
+  #audit = inject(AuditRendererService);
+
+  init(): void {
+    // Override every CREATE_METADATA (action 100) entry
+    this.#audit.registerAuditRenderer(CreatedAuditRendererComponent, 100);
+
+    // Override one specific (action, subaction) pair
+    this.#audit.registerAuditRenderer(UpdatedAuditRendererComponent, 300, 42);
+  }
+}
+```
+
+### Writing a custom audit renderer
+
+Extend `AbstractAuditRendererComponent`. The directive sets one input: `auditEntry: AuditEntry`.
+
+```ts
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { AbstractAuditRendererComponent } from '@yuuvis/client-framework/renderer';
+
+@Component({
+  selector: 'app-created-audit',
+  standalone: true,
+  template: `
+    <span class="title">📄 Document created</span>
+    <small class="meta">action {{ auditEntry().action }}</small>
+  `,
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class CreatedAuditRendererComponent extends AbstractAuditRendererComponent {}
+```
+
+The base class exposes:
+
+- `auditEntry = input.required<AuditEntry>()` — the full entry, including `action`, `subaction`, `detail`, `creationDate`, `createdBy`, `version`.
+
+If you want to extend (rather than replace) the default labelling, you can compose `DefaultAuditRendererComponent` inside your own template, or read `auditEntry().detail` directly — its format is action-specific (the default renderer parses `[a,b]`-style payloads for tag/restore actions).
+
+---
+
+## Conventions
+
+- Both directives, both services, and both abstract base classes are tree-shakable per sub-library — import only what you need.
+- Renderers are looked up at directive instantiation time. Registering after the view exists is fine but only affects later input changes.
+- All built-in renderers use OnPush and are standalone — follow the same in custom renderers.
+- `RendererService` integrates with `SystemService` to fall back to the property's internal field type; custom renderers do not need to replicate this — register against the field-type key (`registerRendererByType`) to opt in.

package/types/yuuvis-client-framework-object-details.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { TemplateRef, OnDestroy, PipeTransform } from '@angular/core';
 import * as _yuuvis_client_core from '@yuuvis/client-core';
-import { AuditQueryResult, AuditEntry, DmsObject, AuditService, EventService, SystemService, TranslateService, VirtualObjectType, RetentionState, ObjectTypeFlavor, Situation, FlavoredDmsObject, ObjectTypeField } from '@yuuvis/client-core';
+import { AuditQueryResult, AuditEntry, DmsObject, VirtualObjectType, RetentionState, TranslateService, ObjectTypeFlavor, Situation, FlavoredDmsObject, ObjectTypeField } from '@yuuvis/client-core';
 import { RendererDirectiveInput } from '@yuuvis/client-framework/renderer';
 import { ObjectFormComponent, IObjectFormElementExtension, ObjectFormOptions, FormStatusChangedEvent } from '@yuuvis/client-framework/object-form';
 import * as i7 from '@yuuvis/client-framework/common';
@@ -9,26 +9,14 @@ import { FormGroup } from '@angular/forms';
 
 declare class ObjectAuditComponent {
     #private;
-    private auditService;
-    private eventService;
-    private system;
-    private translate;
-    private FILTER_CACHE_KEY;
-    private _objectID?;
-    private _objectTypeID?;
     icons: {
         filter: any;
         arrowNext: any;
     };
     auditsRes: _angular_core.WritableSignal<AuditQueryResult | undefined>;
-    resolvedItems: _angular_core.WritableSignal<ResolvedAuditEntry[]>;
+    items: _angular_core.Signal<AuditEntry[]>;
     error: _angular_core.WritableSignal<boolean>;
     busy: _angular_core.WritableSignal<boolean>;
-    searchActions: {
-        label: string;
-        actions: string[];
-    }[];
-    auditLabels: any;
     dmsObject: _angular_core.InputSignal<DmsObject | undefined>;
     /**
      * A list of audits that should not be shown. Use the audit codes (like 100, 301, etc.).
@@ -40,19 +28,15 @@ declare class ObjectAuditComponent {
      */
     allActions: _angular_core.InputSignal<boolean>;
     get objectID(): string | undefined;
-    constructor(auditService: AuditService, eventService: EventService, system: SystemService, translate: TranslateService);
+    constructor();
     /**
      * Execute a query from the search panel.
      */
     query(): void;
     goToPage(page: number): void;
-    private onError;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectAuditComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ObjectAuditComponent, "yuv-object-audit", never, { "dmsObject": { "alias": "dmsObject"; "required": false; "isSignal": true; }; "skipActions": { "alias": "skipActions"; "required": false; "isSignal": true; }; "allActions": { "alias": "allActions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-interface ResolvedAuditEntry extends AuditEntry {
-    label: string;
-}
 
 interface HeaderData {
     title: RendererDirectiveInput;

package/types/yuuvis-client-framework-renderer.d.ts

@@ -1,8 +1,68 @@
 import * as i0 from '@angular/core';
-import { Type, ComponentRef } from '@angular/core';
-import { SchemaResponseFieldDefinition, TranslateService, ResolvedObjectConfigItem, RendererType } from '@yuuvis/client-core';
+import { ComponentRef, Type } from '@angular/core';
+import { AuditEntry, SchemaResponseFieldDefinition, TranslateService, ResolvedObjectConfigItem, RendererType } from '@yuuvis/client-core';
 import * as dist_libs_yuuvis_client_core_types_yuuvis_client_core from 'dist/libs/yuuvis/client-core/types/yuuvis-client-core';
 
+/**
+ * Abstract class to be extended by audit-entry renderers. The renderer controls the
+ * inner content of an audit timeline entry; the surrounding framing (date column,
+ * timeline line, version badge, creator) stays with the host component.
+ */
+declare abstract class AbstractAuditRendererComponent {
+    auditEntry: i0.InputSignal<AuditEntry>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractAuditRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractAuditRendererComponent, "yuv-abstract-audit-renderer", never, { "auditEntry": { "alias": "auditEntry"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ResolvedAuditLabel {
+    label: string;
+    more?: string;
+}
+declare class DefaultAuditRendererComponent extends AbstractAuditRendererComponent {
+    #private;
+    protected resolved: i0.Signal<ResolvedAuditLabel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultAuditRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultAuditRendererComponent, "yuv-default-audit-renderer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Attribute directive that renders an `AuditEntry` using the component registered with
+ * `AuditRendererService` for the entry's `action` (and optionally `subaction`). Falls
+ * back to `DefaultAuditRendererComponent` when no override is registered.
+ */
+declare class AuditRendererDirective {
+    #private;
+    component: ComponentRef<AbstractAuditRendererComponent>;
+    yuvAuditRenderer: i0.InputSignal<AuditEntry>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditRendererDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AuditRendererDirective, "[yuvAuditRenderer]", never, { "yuvAuditRenderer": { "alias": "yuvAuditRenderer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Service for managing audit-entry renderers. Renderers are components that render the
+ * inner content of an audit entry in the timeline view of `ObjectAuditComponent`.
+ *
+ * Register a renderer for an `action` to override the default rendering of all audit
+ * entries with that action, or for an `action` + `subaction` pair to override a specific
+ * variant. Lookup prefers the subaction-specific renderer over the action-only renderer;
+ * if neither is registered, `DefaultAuditRendererComponent` is used.
+ */
+declare class AuditRendererService {
+    #private;
+    /**
+     * Register a renderer for a specific audit `action`. Pass `subaction` to scope the
+     * renderer to a particular (action, subaction) pair.
+     */
+    registerAuditRenderer(cmp: Type<AbstractAuditRendererComponent>, action: number, subaction?: number): void;
+    /**
+     * Resolve the renderer for an audit entry. Tries `(action, subaction)` first, falls
+     * back to `(action)`, then to `DefaultAuditRendererComponent`.
+     */
+    getAuditRenderer(action: number, subaction?: number): Type<AbstractAuditRendererComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditRendererService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuditRendererService>;
+}
+
 /**
  * Abstract class to be extended by property renderers
  */
@@ -31,6 +91,12 @@ declare class DecimalRendererComponent extends AbstractRendererComponent<number>
     static ɵcmp: i0.ɵɵComponentDeclaration<DecimalRendererComponent, "yuv-decimal-renderer", never, {}, {}, never, never, true, never>;
 }
 
+declare class FileSizeRendererComponent extends AbstractRendererComponent {
+    parsedValue: i0.Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizeRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileSizeRendererComponent, "yuv-string-renderer", never, {}, {}, never, never, true, never>;
+}
+
 declare class IconRendererComponent extends AbstractRendererComponent {
     #private;
     protected readonly customId: `${string}-${string}-${string}-${string}-${string}`;
@@ -49,7 +115,7 @@ declare class OrganizationRendererComponent extends AbstractRendererComponent {
     userAndRole: i0.WritableSignal<{
         type: string;
         label: string | undefined;
-    }[] | undefined>;
+    }[]>;
     userAndRoleLoading: i0.Signal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationRendererComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<OrganizationRendererComponent, "yuv-organization-renderer", never, {}, {}, never, never, true, never>;
@@ -70,7 +136,7 @@ declare class TableRendererComponent extends AbstractRendererComponent<any[]> {
     }[]>;
     protected tableData: i0.Signal<any[]>;
     protected reducedData: i0.Signal<boolean>;
-    protected getCellValue(row: any[], key: string): any;
+    protected getCellValue(row: any[], key: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableRendererComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TableRendererComponent, "yuv-table-renderer", never, {}, {}, never, never, true, never>;
 }
@@ -125,5 +191,5 @@ declare class RendererDirective {
     static ɵdir: i0.ɵɵDirectiveDeclaration<RendererDirective, "[yuvRenderer]", never, { "yuvRenderer": { "alias": "yuvRenderer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { AbstractRendererComponent, DateTimeRendererComponent, DecimalRendererComponent, IconRendererComponent, IntegerRendererComponent, OrganizationRendererComponent, RendererDirective, RendererService, StringRendererComponent, UnknownRendererComponent };
+export { AbstractAuditRendererComponent, AbstractRendererComponent, AuditRendererDirective, AuditRendererService, BooleanRendererComponent, DateTimeRendererComponent, DecimalRendererComponent, DefaultAuditRendererComponent, FileSizeRendererComponent, IconRendererComponent, IntegerRendererComponent, OrganizationRendererComponent, RendererDirective, RendererService, StringRendererComponent, TableRendererComponent, UnknownRendererComponent };
 export type { RendererComponent, RendererDirectiveInput };

package/types/yuuvis-client-framework.d.ts

@@ -109,6 +109,22 @@ declare const defaultHaloFocusOffset = 3;
  */
 declare const haloFocusStyles: Partial<CSSStyleDeclaration>;
 
+/**
+ * Default interval (in milliseconds) for periodic PWA update checks.
+ *
+ * After the application stabilizes, {@link PwaUpdateService} polls the service
+ * worker for a newer deployed version on this interval. This complements the
+ * `VERSION_READY` event, which only fires while the tab is open and the service
+ * worker happens to detect a change — long-running sessions would otherwise
+ * never learn about a new release.
+ *
+ * Override via `providePwaUpdate({ checkInterval })`. Set `checkInterval` to `0`
+ * to disable polling and rely solely on `VERSION_READY`.
+ *
+ * @default 6 hours (21600000 milliseconds)
+ */
+declare const pwaUpdateDefaultCheckInterval: number;
+
 /**
  * Default session duration (in milliseconds) when no explicit duration is provided.
  *
@@ -303,6 +319,35 @@ interface HaloFocusConfig {
     outerColor?: string;
 }
 
+/**
+ * Configuration for the PWA update feature wired up by `providePwaUpdate()`.
+ *
+ * All label/message fields are passed through `TranslateService.instant()`, so
+ * you may supply either an i18n key or a literal string. When omitted, the
+ * built-in `yuv.pwa.update.*` keys are used.
+ */
+interface PwaUpdateConfig {
+    /**
+     * Interval (in milliseconds) for periodic update checks after the app becomes
+     * stable. Defaults to {@link pwaUpdateDefaultCheckInterval} (6 hours).
+     * Set to `0` to disable polling and rely solely on the `VERSION_READY` event.
+     */
+    checkInterval?: number;
+    /** Title shown in the update confirm dialog. @default 'yuv.pwa.update.title' */
+    title?: string;
+    /** Message shown when a new version is ready to activate. @default 'yuv.pwa.update.message' */
+    message?: string;
+    /**
+     * Message shown when the service worker enters an unrecoverable state and the
+     * page must be reloaded. @default 'yuv.pwa.update.unrecoverable.message'
+     */
+    unrecoverableMessage?: string;
+    /** Confirm button label. @default 'yuv.pwa.update.confirm' */
+    confirmLabel?: string;
+    /** Cancel button label. @default 'yuv.pwa.update.cancel' */
+    cancelLabel?: string;
+}
+
 type ChannelPayload = {
     type: ChannelMessage;
     expiresAt?: number;
@@ -389,6 +434,42 @@ interface SnackBarData {
  */
 declare function provideHaloFocus(config?: HaloFocusConfig): EnvironmentProviders;
 
+/**
+ * Provides and initializes PWA update detection for the application.
+ *
+ * On startup it boots {@link PwaUpdateService}, which watches for newly deployed
+ * versions of the app and, instead of reloading silently, asks the user to
+ * confirm before activating the update and reloading the page.
+ *
+ * **Detection:** reacts to the service worker `VERSION_READY` event and also
+ * polls `checkForUpdate()` on an interval (default 6 hours) once the app is
+ * stable, so long-running sessions still pick up new releases.
+ *
+ * **Prerequisite:** the service worker must be registered separately via
+ * `provideServiceWorker('ngsw-worker.js', { enabled: !isDevMode() })`. When the
+ * service worker is disabled (e.g. dev mode) this provider is a harmless no-op.
+ *
+ * @param config - Optional configuration (check interval, custom dialog labels/messages).
+ * @returns EnvironmentProviders for the PWA update feature.
+ *
+ * @example
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideServiceWorker('ngsw-worker.js', { enabled: !isDevMode() }),
+ *     providePwaUpdate()
+ *   ]
+ * };
+ *
+ * @example
+ * // Custom check interval (1 hour) and labels
+ * providePwaUpdate({
+ *   checkInterval: 60 * 60 * 1000,
+ *   message: 'A new version is available. Reload now?'
+ * });
+ */
+declare function providePwaUpdate(config?: PwaUpdateConfig): EnvironmentProviders;
+
 /**
  * Provides and initializes the SessionService at application startup.
  *
@@ -770,6 +851,44 @@ declare class HaloUtilityService {
     static ɵprov: i0.ɵɵInjectableDeclaration<HaloUtilityService>;
 }
 
+/**
+ * Detects newly deployed versions of the application (PWA) and lets the user
+ * decide when to apply them.
+ *
+ * **Flow (per the Angular `SwUpdate` documentation):**
+ * 1. **Check** — listens for the `VERSION_READY` event and, additionally, polls
+ *    `checkForUpdate()` on an interval once the app is stable. The update is
+ *    *not* applied automatically.
+ * 2. **Ask** — when a new version is ready, prompts the user via the framework
+ *    {@link ConfirmService} dialog instead of reloading silently.
+ * 3. **Apply** — only after the user confirms, calls `activateUpdate()` and then
+ *    reloads the page so the new version takes effect.
+ *
+ * The service is a no-op when the service worker is disabled (e.g. dev mode),
+ * so it is safe to provide unconditionally.
+ *
+ * Wire it up via `providePwaUpdate()` in `app.config.ts`. The service worker
+ * itself must still be registered separately via `provideServiceWorker(...)`.
+ *
+ * @see https://angular.dev/ecosystem/service-workers/communications
+ */
+declare class PwaUpdateService {
+    #private;
+    /**
+     * Starts listening for updates. Called automatically by `providePwaUpdate()`.
+     * Does nothing when the service worker is not enabled.
+     */
+    init(config?: PwaUpdateConfig): void;
+    /**
+     * Manually triggers an update check (e.g. from a "check for updates" button).
+     * Resolves to `true` when a new version was found. Network errors are swallowed
+     * and resolve to `false`.
+     */
+    checkForUpdate(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PwaUpdateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PwaUpdateService>;
+}
+
 /**
  * Manages client-side session expiry: persists expiration, tracks user and HTTP activity,
  * shows a pre-expiry popup with an extend CTA, and syncs state across tabs via BroadcastChannel.
@@ -924,5 +1043,5 @@ declare class YuuvisClientFrameworkModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<YuuvisClientFrameworkModule>;
 }
 
-export { ChannelMessage, HaloFocusService, HaloUtilityService, SessionService, SnackBarComponent, SnackBarService, YuuvisClientFrameworkModule, defaultHaloFocusOffset, haloExcludedElementsInMatFormField, haloFocusNavigationKeys, haloFocusStyles, provideHaloFocus, provideSession, sessionActivityWindowBeforeEnd, sessionDefaultDuration, sessionPopupBeforeEnd };
-export type { ChannelPayload, HaloFocusConfig, SnackBarData, SnackBarLevel, SnackBarMessage, SnackBarOptions };
+export { ChannelMessage, HaloFocusService, HaloUtilityService, PwaUpdateService, SessionService, SnackBarComponent, SnackBarService, YuuvisClientFrameworkModule, defaultHaloFocusOffset, haloExcludedElementsInMatFormField, haloFocusNavigationKeys, haloFocusStyles, provideHaloFocus, providePwaUpdate, provideSession, pwaUpdateDefaultCheckInterval, sessionActivityWindowBeforeEnd, sessionDefaultDuration, sessionPopupBeforeEnd };
+export type { ChannelPayload, HaloFocusConfig, PwaUpdateConfig, SnackBarData, SnackBarLevel, SnackBarMessage, SnackBarOptions };