@blotch/angular-lynx 22.2.3 → 22.2.5

package/types/blotch-angular-lynx.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from "@angular/core";
-import { ApplicationConfig, ApplicationRef, ComponentRef, EmbeddedViewRef, EnvironmentInjector, EnvironmentProviders, ErrorDetails, ErrorHandler, Injector, OnChanges, OnDestroy, SimpleChanges, TemplateRef, Type, ViewContainerRef, signal } from "@angular/core";
+import { ApplicationConfig, ApplicationRef, ComponentRef, EmbeddedViewRef, EnvironmentInjector, EnvironmentProviders, ErrorDetails, ErrorHandler, InjectionToken, Injector, OnChanges, OnDestroy, OutputRef, Signal, SimpleChanges, TemplateRef, Type, ViewContainerRef, signal } from "@angular/core";
 import { Animation, AnimationOptions, Element as Element$1 } from "@lynx-js/types/main-thread";
 import { AnyObject } from "@lynx-js/types/common";
 import { ControlValueAccessor } from "@angular/forms";
@@ -55,6 +55,115 @@ export declare class LynxAccessibility {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxAccessibility, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+/**
+ * The user's accessibility display settings, as signals: Reduce Motion,
+ * Reduce Transparency and Increase Contrast.
+ *
+ * Lynx has no API for them on any platform, so they come from the host app,
+ * in its global props, like the theme does: `reduceMotion`,
+ * `reduceTransparency` and `increaseContrast`, each `true` when on. The apps
+ * `ng build --platform` makes send them, and send them again when the user
+ * changes one:
+ *
+ * - **iOS:** `UIAccessibility.isReduceMotionEnabled`,
+ *   `isReduceTransparencyEnabled` and `isDarkerSystemColorsEnabled`
+ *   (Increase Contrast).
+ * - **Android:** Remove animations (an animator duration scale of 0) for
+ *   Reduce Motion, and contrast above standard (Android 14) or high contrast
+ *   text (Android 16) for Increase Contrast. Android has no Reduce
+ *   Transparency setting.
+ *
+ * In the web preview they follow the browser's `prefers-reduced-motion`,
+ * `prefers-reduced-transparency` and `prefers-contrast: more` too. Lynx
+ * Explorer sends none of them, so they're off there, unless you add them to
+ * the bundle URL: `?reduceMotion=true`.
+ *
+ * iOS 27's Liquid Glass appearance setting (clear or tinted glass) has no
+ * public API, so it isn't here. UIKit's glass follows it, and Reduce
+ * Transparency and Increase Contrast, by itself.
+ *
+ * @usageNotes
+ * ```typescript
+ * const settings = inject(LynxAccessibilitySettings);
+ *
+ * // Jump instead of sliding when the user asked for less motion.
+ * const duration = computed(() => (settings.reduceMotion() ? 0 : 250));
+ * ```
+ */
+export declare class LynxAccessibilitySettings {
+  #private;
+  /**
+   * The user asked for less motion. Replace movement, such as a slide or a
+   * bounce, with a fade or an instant change.
+   */
+  readonly reduceMotion: Signal<boolean>;
+  /**
+   * The user asked for less transparency. Draw blurred and translucent
+   * surfaces opaque.
+   */
+  readonly reduceTransparency: Signal<boolean>;
+  /**
+   * The user asked for more contrast: iOS's Increase Contrast. Strengthen
+   * borders and use full-strength text colors.
+   */
+  readonly increaseContrast: Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxAccessibilitySettings, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * One trait of `accessibility-traits`, each of which iOS turns into a
+ * UIAccessibilityTraits flag (`LynxConverter+UI.m`).
+ */
+type AccessibilityTrait = 'text' | 'image' | 'button' | 'link' | 'header' | 'search' | 'selected' | 'playable' | 'keyboard' | 'summary' | 'disabled' | 'updating' | 'adjustable' | 'tabbar' | 'none';
+/**
+ * Which traits LynxAccessibilityTraits adds, by name. `none` isn't one: it
+ * says the element has no traits, so there's nothing to add.
+ */
+type AccessibilityTraitStates = Partial<Record<Exclude<AccessibilityTrait, 'none'>, boolean>>;
+/**
+ * Adds accessibility traits to an element's own `accessibility-traits` while
+ * a binding says so, such as `selected` on the chosen one of several options,
+ * or `disabled` on an item that can't be used now.
+ *
+ * Writing the state into the attribute instead,
+ * `accessibility-traits="button,selected"`, works only on iOS. Android reads
+ * the attribute as a single trait, so a list stops being a button there. The
+ * element merges these traits into its own instead (see
+ * LynxElement.setAccessibilityTrait): `button` reads `button,selected` on iOS,
+ * and stays `button` on Android, which has no selected trait to add. The
+ * element can still set its own traits at any time, and neither undoes the
+ * other.
+ *
+ * A trait that turns false, or that the map leaves out, is taken away again.
+ * Only the traits this directive added are: the element's own stay.
+ *
+ * It's part of LYNX_ELEMENTS, so a component that imports LYNX_ELEMENTS can
+ * bind it on any element.
+ *
+ * @usageNotes
+ * ```html
+ * <view
+ *   [accessibility-element]="true"
+ *   accessibility-traits="button"
+ *   [accessibility-label]="label()"
+ *   [lynxAccessibilityTraits]="{ selected: selected() }"
+ *   (bindtap)="chosen.emit()"
+ * >
+ * ```
+ */
+export declare class LynxAccessibilityTraits {
+  #private;
+  readonly lynxAccessibilityTraits: import("@angular/core").InputSignal<Partial<Record<"text" | "search" | "link" | "image" | "button" | "header" | "selected" | "playable" | "keyboard" | "summary" | "disabled" | "updating" | "adjustable" | "tabbar", boolean>> | null | undefined>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxAccessibilityTraits, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxAccessibilityTraits, "[lynxAccessibilityTraits]", never, {
+    "lynxAccessibilityTraits": {
+      "alias": "lynxAccessibilityTraits";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /**
  * Phantom brand symbol — makes each ElementRef variant nominally distinct at
  * the type level even though Lynx PAPI handles have no runtime structure.
@@ -1163,9 +1272,12 @@ declare class LynxElementBase implements OnChanges {
   'accessibility-label'?: string;
   /**
    * The kind of element a screen reader announces. Plural, as Lynx reads it:
-   * iOS, Android and Harmony ignore `accessibility-trait`. @default 'none'
+   * iOS, Android and Harmony ignore `accessibility-trait`. iOS also reads a
+   * comma-separated list with no spaces, such as `button,selected`, which
+   * is what LynxRouterLinkActive and LynxAccessibilityTraits write; Android
+   * and Harmony read a single trait. @default 'none'
    */
-  'accessibility-traits'?: 'text' | 'image' | 'button' | 'link' | 'header' | 'search' | 'selected' | 'playable' | 'keyboard' | 'summary' | 'disabled' | 'updating' | 'adjustable' | 'tabbar' | 'none';
+  'accessibility-traits'?: AccessibilityTrait | `${AccessibilityTrait},${string}`;
   /**
    * Comma-separated `id`s of the child elements a screen reader visits, in
    * order. iOS and Android look each one up as an `id` selector.
@@ -1488,6 +1600,16 @@ export declare class LynxBlurView extends LynxElementBase {
    * gets a tint that approximates it. @default 'light'
    */
   'blur-effect'?: 'light' | 'extra-light' | 'dark' | 'glass' | 'glass-container';
+  /**
+   * One of UIKit's adaptive blur materials, which follow
+   * `ios-user-interface-style` (iOS 13+, in apps built with
+   * `ng build --platform ios`): `systemUltraThinMaterial` to
+   * `systemThickMaterial`, or `systemChromeMaterial`, the bars'. While it's
+   * set it replaces `blur-effect` and `blur-radius`. Lynx's own blur-view
+   * doesn't have it, so Lynx Explorer and other hosts ignore it and draw the
+   * `blur-effect`.
+   */
+  'blur-material'?: 'ultra-thin' | 'thin' | 'regular' | 'thick' | 'chrome';
   /**
    * Distance at which glass elements inside a `glass-container` start to merge (iOS). @default 0
    */
@@ -1534,6 +1656,10 @@ export declare class LynxBlurView extends LynxElementBase {
       "alias": "blur-effect";
       "required": false;
     };
+    "blur-material": {
+      "alias": "blur-material";
+      "required": false;
+    };
     "spacing": {
       "alias": "spacing";
       "required": false;
@@ -2996,11 +3122,118 @@ export declare class LynxWebView extends LynxElementBase {
     };
   }, {}, never, never, true, never>;
 }
+/**
+ * Finds the `isActiveChange` output of Angular's `RouterLinkActive` on the
+ * element being created, or null if it has none. Called in the injection
+ * context of that element's LynxRouterLinkActive.
+ *
+ * `provideRouter()` provides it, rather than LynxRouterLinkActive importing
+ * `RouterLinkActive` itself, because LynxRouterLinkActive is part of
+ * LYNX_ELEMENTS, which every component imports: referring to the router from
+ * there would put the whole router in the bundle of an app without routes.
+ * Without `provideRouter()` there's no router to follow, and the token is
+ * missing.
+ */
+declare const ROUTER_LINK_ACTIVE_CHANGE: InjectionToken<() => OutputRef<boolean> | null>;
+/**
+ * Tells screen readers which router link is the current one: while Angular's
+ * `RouterLinkActive` on the same element says its route is active, the
+ * element has the `selected` accessibility trait, as the selected tab of a
+ * native tab bar does. On the web, `routerLinkActive` only changes classes, or
+ * `aria-current` with `ariaCurrentWhenActive`; Lynx elements have no ARIA,
+ * and `accessibility-traits` is how they say this.
+ *
+ * It keeps the element's own traits: `accessibility-traits="button"` becomes
+ * `button,selected` while the link is active. On Android, which reads one
+ * trait and has no selected trait, the element keeps its own traits as they
+ * are.
+ *
+ * It's part of LYNX_ELEMENTS, so a component that imports LYNX_ELEMENTS and
+ * Angular's `RouterLinkActive` gets it on every `routerLinkActive` element.
+ * To add it to a component's host instead, list it in `hostDirectives` next
+ * to `RouterLinkActive`.
+ *
+ * @usageNotes
+ * ```ts
+ * @Component({
+ *   imports: [LYNX_ELEMENTS, RouterLink, RouterLinkActive],
+ *   template: `
+ *     <view routerLink="/settings" routerLinkActive="active">
+ *       <text>Settings</text>
+ *     </view>
+ *   `,
+ * })
+ * ```
+ */
+export declare class LynxRouterLinkActive {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxRouterLinkActive, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxRouterLinkActive, "[routerLinkActive]", never, {}, {}, never, never, true, never>;
+}
 /**
  * All Lynx native element directives as a single importable array.
  * Add to the `imports` of any component whose template uses Lynx elements.
  */
-export declare const LYNX_ELEMENTS: readonly [typeof LynxView, typeof LynxText, typeof LynxInlineTruncation, typeof LynxImage, typeof LynxScrollView, typeof LynxList, typeof LynxListItem, typeof LynxBlock, typeof LynxIf, typeof LynxFor, typeof LynxFrame, typeof LynxInput, typeof LynxTextarea, typeof LynxInputValueAccessor, typeof LynxTextareaValueAccessor, typeof LynxOverlay, typeof LynxRefresh, typeof LynxRefreshHeader, typeof LynxScrollCoordinator, typeof LynxScrollCoordinatorHeader, typeof LynxScrollCoordinatorSlot, typeof LynxScrollCoordinatorSlotDrag, typeof LynxScrollCoordinatorToolbar, typeof LynxSvg, typeof LynxViewPager, typeof LynxViewPagerItem, typeof LynxBlurView, typeof LynxVideo, typeof LynxWebView, typeof LynxCoverView, typeof LynxTitleBarView];
+export declare const LYNX_ELEMENTS: readonly [typeof LynxView, typeof LynxText, typeof LynxInlineTruncation, typeof LynxImage, typeof LynxScrollView, typeof LynxList, typeof LynxListItem, typeof LynxBlock, typeof LynxIf, typeof LynxFor, typeof LynxFrame, typeof LynxInput, typeof LynxTextarea, typeof LynxInputValueAccessor, typeof LynxTextareaValueAccessor, typeof LynxOverlay, typeof LynxRefresh, typeof LynxRefreshHeader, typeof LynxScrollCoordinator, typeof LynxScrollCoordinatorHeader, typeof LynxScrollCoordinatorSlot, typeof LynxScrollCoordinatorSlotDrag, typeof LynxScrollCoordinatorToolbar, typeof LynxSvg, typeof LynxViewPager, typeof LynxViewPagerItem, typeof LynxBlurView, typeof LynxVideo, typeof LynxWebView, typeof LynxCoverView, typeof LynxTitleBarView, typeof LynxRouterLinkActive, typeof LynxAccessibilityTraits];
+type LynxEventType = 'bindEvent' | 'catchEvent' | 'capture-bindEvent' | 'capture-catchEvent' | 'global-bindEvent';
+declare const EVENT_PREFIXES: [string, LynxEventType][];
+/**
+ * DOM event names whose Lynx event has another name. A listener for one of
+ * them hears the Lynx event, bubbling, as if it were bound with `bind`: a
+ * `(click)` listener runs on a tap. This is the mapping Lynx for Web makes
+ * between the two (web-core's `W3cEventNameToLynx` turns a DOM `click` into
+ * `tap`), and it's what lets Angular's own directives that listen for
+ * `click`, such as `RouterLink`, work on Lynx elements.
+ */
+declare const DOM_EVENT_ALIASES: ReadonlyMap<string, string>;
+/**
+ * The `nativeElement` of a Lynx element's `ElementRef`: AngularLynx's
+ * wrapper around the native element, not a DOM element. Type an
+ * `ElementRef` with it to call its methods, such as `animate()`, `invoke()`
+ * or `setAccessibilityTrait()`.
+ *
+ * @usageNotes
+ * ```ts
+ * readonly option = viewChild.required<ElementRef<BaseLynxElement>>('option');
+ * ```
+ */
+type BaseLynxElement = Pick<Element$1, 'setAttribute'> & {
+  tagName: string;
+  setProperty(name: string, value: any): void;
+  getAttribute(name: string): string | null;
+  removeAttribute(name: string): void;
+  setStyle(key: string, value: unknown): void;
+  removeStyle(key: string): void;
+  setInlineStyles(inlineStyle: string): void;
+  insertBefore(newChild: BaseLynxElement, refChild: BaseLynxElement | null): void;
+  appendChild(newChild: BaseLynxElement): void;
+  addClass(name: string): void;
+  /**
+   * Adds a class that stays when the whole class list is replaced, for
+   * ViewEncapsulation.Emulated's scope classes (see EmulatedLynxRenderer).
+   */
+  addScopeClass(name: string): void;
+  removeClass(name: string): void;
+  /**
+   * Adds a trait to the element's own `accessibility-traits`, or takes it
+   * away, keeping the traits the app sets. For state that changes, such as
+   * `selected` on an active router link (see LynxRouterLinkActive). In a
+   * template, LynxAccessibilityTraits does it from a binding.
+   */
+  setAccessibilityTrait(trait: string, on: boolean): void;
+  remove(): void;
+  parentNode(): BaseLynxElement | null;
+  nextSibling(): BaseLynxElement | null;
+  querySelector(selector: string): BaseLynxElement | null;
+  querySelectorAll(selector: string): BaseLynxElement[];
+  addEventListener(name: string, cb: (event: any) => any): () => void;
+  animate(keyframes: Record<string, string | number>[], options?: number | LynxAnimationOptions): BaseLynxAnimation;
+  /**
+   * Invokes a native UI method on this element (e.g. setValue, scrollTo).
+   * LynxElement implements it via __InvokeUIMethod.
+   */
+  invoke(methodName: string, params?: Record<string, unknown>): void;
+};
 export declare class LynxLogger {
   #private;
   log(...args: unknown[]): void;
@@ -3153,38 +3386,6 @@ export declare class LynxNativeModule {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxNativeModule, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-type LynxEventType = 'bindEvent' | 'catchEvent' | 'capture-bindEvent' | 'capture-catchEvent' | 'global-bindEvent';
-declare const EVENT_PREFIXES: [string, LynxEventType][];
-type BaseLynxElement = Pick<Element$1, 'setAttribute'> & {
-  tagName: string;
-  setProperty(name: string, value: any): void;
-  getAttribute(name: string): string | null;
-  removeAttribute(name: string): void;
-  setStyle(key: string, value: unknown): void;
-  removeStyle(key: string): void;
-  setInlineStyles(inlineStyle: string): void;
-  insertBefore(newChild: BaseLynxElement, refChild: BaseLynxElement | null): void;
-  appendChild(newChild: BaseLynxElement): void;
-  addClass(name: string): void;
-  /**
-   * Adds a class that stays when the whole class list is replaced, for
-   * ViewEncapsulation.Emulated's scope classes (see EmulatedLynxRenderer).
-   */
-  addScopeClass(name: string): void;
-  removeClass(name: string): void;
-  remove(): void;
-  parentNode(): BaseLynxElement | null;
-  nextSibling(): BaseLynxElement | null;
-  querySelector(selector: string): BaseLynxElement | null;
-  querySelectorAll(selector: string): BaseLynxElement[];
-  addEventListener(name: string, cb: (event: any) => any): () => void;
-  animate(keyframes: Record<string, string | number>[], options?: number | LynxAnimationOptions): BaseLynxAnimation;
-  /**
-   * Invokes a native UI method on this element (e.g. setValue, scrollTo).
-   * LynxElement implements it via __InvokeUIMethod.
-   */
-  invoke(methodName: string, params?: Record<string, unknown>): void;
-};
 declare class LynxElement implements BaseLynxElement {
   #private;
   get element(): ElementRef;
@@ -3228,6 +3429,12 @@ declare class LynxElement implements BaseLynxElement {
    * creates one, and setAttribute whenever an attribute it depends on changes.
    */
   updateBlurMaterial(): void;
+  /**
+   * Adds `trait` to the app's own `accessibility-traits`, or takes it away.
+   * The app can still set its traits at any time: setAttribute merges the two
+   * (see withAddedTraits), so neither undoes the other.
+   */
+  setAccessibilityTrait(trait: string, on: boolean): void;
   getAttribute(name: string): string;
   removeAttribute(name: string): void;
   setStyle(key: string, value: unknown): void;
@@ -3265,6 +3472,13 @@ declare class LynxElement implements BaseLynxElement {
    * itself from the set via #cancelPendingRemoval, so only genuine destroys
    * remain.
    */
+  /**
+   * Sends Lynx the attribute removals that weren't taken back this cycle
+   * (see #removedAttributes). Called by `LynxRendererFactory2.end()` and the
+   * settle flush, after removals and before `__FlushElementTree()`, so the
+   * removals land in the same flush as the cycle's other mutations.
+   */
+  static commitPendingAttributeRemovals(): void;
   static commitPendingRemovals(): void;
   /**
    * Re-derives displayed whitespace for every text touched this cycle. Each dirty
@@ -3308,11 +3522,26 @@ declare class LynxElement implements BaseLynxElement {
    * Angular's renderer.listen() calls this with event names like 'bindtap',
    * 'catchtouchstart', 'bindscroll', etc. We strip the Lynx event prefix
    * (bind/catch/capture-bind/capture-catch) to extract the native event name
-   * and determine the event type for __AddEvent.
-   * Events that don't match any prefix (e.g. DOM-style 'click') are silently
-   * ignored — Lynx has no equivalent event system for arbitrary names.
+   * and determine the event type for __AddEvent. A DOM name Lynx calls
+   * something else (see DOM_EVENT_ALIASES) listens for the Lynx event, so
+   * `(click)`, and Angular's RouterLink with it, runs on a tap.
+   * Other names (e.g. `mouseover`) are ignored: Lynx has no event for them.
+   *
+   * An element can have any number of listeners for one event, as on the
+   * web: a template's `(bindtap)` next to a directive's host listener for
+   * `click`, say. Native Lynx keeps one handler per event name, so each name
+   * gets one native handler that runs all of them (see #syncNativeHandler).
    */
   addEventListener(name: string, cb: (event: any) => any): () => void;
+  /**
+   * Removes a listener added with addEventListener, as the DOM method does,
+   * for code that pairs the two on the element itself rather than going
+   * through the renderer's cleanup function. Angular's `@defer` interaction
+   * and hover triggers do, for their `click`, `keydown` and `mouseenter`
+   * listeners; without it, their cleanup would throw. A name Lynx has no
+   * event for was never added, so removing it does nothing.
+   */
+  removeEventListener(name: string, cb: (event: any) => any): void;
 }
 /**
  * Commits all queued genuine element removals — a free-function wrapper over
@@ -3321,6 +3550,14 @@ declare class LynxElement implements BaseLynxElement {
  * keeping removals in the same flush as the cycle's other mutations.
  */
 declare const processPendingRemovals: () => void;
+/**
+ * Commits this cycle's attribute removals (see LynxElement's
+ * `#removedAttributes`). A free-function wrapper over
+ * `LynxElement.commitPendingAttributeRemovals()` so
+ * `LynxRendererFactory2.end()` can drain them (via the lynx-element barrel)
+ * right after element removals and before `__FlushElementTree()`.
+ */
+declare const processPendingAttributeRemovals: () => void;
 /**
  * Re-derives positional edge whitespace for every text touched this cycle — a
  * free-function wrapper over `LynxElement.commitPendingTextNormalization()` so
@@ -4093,7 +4330,8 @@ export declare class LynxSessionStorage {
  *
  * On iOS and Android (Lynx 4.1), the main thread has no global `SystemInfo`,
  * only `lynx.SystemInfo`, so that's read first. The background thread and the
- * web have the global.
+ * web have the global. The main thread's copy has no `osVersion` either: see
+ * {@link LynxSystemInfo.osVersion} for where that comes from instead.
  *
  * @usageNotes
  * ```typescript
@@ -4124,7 +4362,13 @@ export declare class LynxSystemInfo {
    */
   get engineVersion(): string;
   /**
-   * The current operating system version.
+   * The current operating system version, such as `'26.1'` on iOS or `'15'`
+   * on Android. Empty while it isn't known.
+   *
+   * The native main thread's SystemInfo lacks it, so there it comes from the
+   * host app's `osVersion` global prop, or else from the background thread,
+   * which answers shortly after the first frame. It reads a signal, so a
+   * `computed()` that reads it updates when the answer arrives.
    */
   get osVersion(): string;
   /**
@@ -4184,6 +4428,22 @@ export declare class LynxTextMeasure {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxTextMeasure, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+/**
+ * The Material 3 color roles that dynamic color gives, by Material's names.
+ * The error roles aren't here: Material keeps them red whatever the
+ * wallpaper.
+ */
+export declare const DYNAMIC_COLOR_ROLES: readonly ["primary", "onPrimary", "primaryContainer", "onPrimaryContainer", "inversePrimary", "secondary", "onSecondary", "secondaryContainer", "onSecondaryContainer", "tertiary", "onTertiary", "tertiaryContainer", "onTertiaryContainer", "background", "onBackground", "surface", "onSurface", "surfaceVariant", "onSurfaceVariant", "surfaceDim", "surfaceBright", "surfaceContainerLowest", "surfaceContainerLow", "surfaceContainer", "surfaceContainerHigh", "surfaceContainerHighest", "inverseSurface", "inverseOnSurface", "outline", "outlineVariant"];
+type DynamicColorRole = (typeof DYNAMIC_COLOR_ROLES)[number];
+/**
+ * Each role's color, as a hex color such as `#6750a4`.
+ */
+type DynamicColorScheme = { readonly [R in DynamicColorRole]: string; };
+/** The color scheme for each appearance: the app can be in either. */
+type DynamicColors = {
+  readonly light: DynamicColorScheme;
+  readonly dark: DynamicColorScheme;
+};
 /**
  * Provides reactive access to the current Lynx theme ('Dark' or 'Light').
  *
@@ -4211,6 +4471,22 @@ export declare class LynxTheme {
    * Whether the current theme is dark mode. Reactive.
    */
   readonly isDarkMode: import("@angular/core").Signal<boolean>;
+  /**
+   * The colors Android 12 and later take from the user's wallpaper (Material
+   * You's dynamic color), as Material 3's color roles in light and dark, or
+   * `null` where the host sends none.
+   *
+   * Lynx has no API for them, so they come from the host app, in its
+   * `dynamicColors` global prop: `{ light, dark }`, each with a hex color,
+   * such as `#6750a4`, for every role in {@link DYNAMIC_COLOR_ROLES}. The
+   * Android app `ng build --platform android` makes sends them, and new ones
+   * when the user changes their wallpaper or colors. iOS, the web preview and
+   * Lynx Explorer have none.
+   *
+   * Both schemes come at once, so an app with a dark mode of its own can
+   * follow it rather than the phone's.
+   */
+  readonly dynamicColors: import("@angular/core").Signal<DynamicColors | null>;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxTheme, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
@@ -4642,6 +4918,12 @@ declare const handlers: {
    */
   callModule: (kind: ModuleKind, name: string, method: string, args: unknown[]) => unknown;
   registerJSModule: (name: string, module: unknown) => void;
+  /**
+   * The OS version, for LynxSystemInfo on the main thread: native Lynx builds
+   * that thread's SystemInfo without one, and the background thread's global
+   * has it.
+   */
+  osVersion: () => string | undefined;
   /** The main thread's `fetch` (network/fetch.ts) sends its requests here. */
   fetch: (id: number, request: RelayedRequest) => Promise<RelayedResponse>;
   abortFetch: (id: number) => void;
@@ -4786,4 +5068,4 @@ declare global {
     catchmouseleave: MouseEvent;
   }
 }
-export type { BackgroundFnHandle, BaseLynxAnimation, DataProcessorDefinition, DevToolsStats, ExposureEventDetail, FlingGestureEvent, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, InitData, InitDataRaw, LongPressGestureEvent, LynxAnimationOptions, LynxFontEntry, LynxFontFaceConfig, LynxFontStatus, LynxTraceOptions, MainThread, MainThreadFnHandle, NativeModuleMap, NativeModuleProxy, ObserverFrameRateOptions, PanGestureEvent, PinchGestureEvent, PortalConfig, PrefetchCacheTarget, PrefetchPriority, PrefetchRequest, PrefetchResultDetail, ResourcePrefetchData, ResourcePrefetchResult, RotationGestureEvent, SessionStorageSubscription, TapGestureEvent };
+export type { AccessibilityTrait, AccessibilityTraitStates, BackgroundFnHandle, BaseLynxAnimation, BaseLynxElement, DataProcessorDefinition, DevToolsStats, DynamicColorRole, DynamicColorScheme, DynamicColors, ExposureEventDetail, FlingGestureEvent, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, InitData, InitDataRaw, LongPressGestureEvent, LynxAnimationOptions, LynxFontEntry, LynxFontFaceConfig, LynxFontStatus, LynxTraceOptions, MainThread, MainThreadFnHandle, NativeModuleMap, NativeModuleProxy, ObserverFrameRateOptions, PanGestureEvent, PinchGestureEvent, PortalConfig, PrefetchCacheTarget, PrefetchPriority, PrefetchRequest, PrefetchResultDetail, ResourcePrefetchData, ResourcePrefetchResult, RotationGestureEvent, SessionStorageSubscription, TapGestureEvent };