@blotch/angular-lynx 22.2.1 → 22.2.3

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

@@ -0,0 +1,4789 @@
+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 { Animation, AnimationOptions, Element as Element$1 } from "@lynx-js/types/main-thread";
+import { AnyObject } from "@lynx-js/types/common";
+import { ControlValueAccessor } from "@angular/forms";
+import { BaseAnimationEvent, BaseKeyEvent, BaseMouseEvent, BaseTouchEvent, BaseTransitionEvent, BaseWheelEvent, LayoutChangeDetailEvent, UIAppearanceDetailEvent } from "@lynx-js/types/events";
+import { MouseEvent, PlatformType, ResourcePrefetchData, ResourcePrefetchResult, TextInfo, TextMetrics, TouchEvent } from "@lynx-js/types";
+import { LocationChangeListener, LocationStrategy, PlatformLocation } from "@angular/common";
+import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy, RouterFeatures, Routes } from "@angular/router";
+import { Subject } from "rxjs";
+/**
+ * Programmatic accessibility control for screen readers on Lynx.
+ *
+ * Provides two imperative APIs that complement the declarative accessibility
+ * attributes (`accessibility-element`, `accessibility-label`, etc.) already
+ * available on Lynx element directives.
+ *
+ * @usageNotes
+ * ```typescript
+ * const a11y = inject(LynxAccessibility);
+ *
+ * // Announce a state change to screen readers
+ * await a11y.announce('Item added to cart');
+ *
+ * // Move accessibility focus to a specific element
+ * await a11y.requestFocus('#confirmation-message');
+ * ```
+ */
+export declare class LynxAccessibility {
+  /**
+   * Makes screen readers announce the specified text content.
+   *
+   * Use this to notify visually impaired users of state changes or
+   * operation results that aren't reflected by focus movement alone
+   * (e.g. toast messages, background task completion, live counters).
+   *
+   * Wraps `lynx.accessibilityAnnounce()`. Only the background thread's `lynx`
+   * has it, and event handlers run on the main thread, so the call goes
+   * through the background thread (see background-call.ts).
+   */
+  announce(content: string): Promise<void>;
+  /**
+   * Programmatically moves accessibility focus (screen reader cursor)
+   * to the element matching the given selector.
+   *
+   * The target element should have `accessibility-element="true"` set.
+   * Only ID selectors are reliably supported (e.g. `'#myElement'`).
+   *
+   * Wraps `lynx.createSelectorQuery().select(selector).invoke({ method: 'requestAccessibilityFocus' }).exec()`.
+   * The main thread's `lynx` has no createSelectorQuery, but it's where event
+   * handlers run and where the native elements live, so there the element is
+   * found and called directly.
+   */
+  requestFocus(selector: string): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxAccessibility, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Phantom brand symbol — makes each ElementRef variant nominally distinct at
+ * the type level even though Lynx PAPI handles have no runtime structure.
+ */
+declare const __brand: unique symbol;
+/**
+ * Generic opaque handle returned by every __Create* PAPI function.
+ * The Tag parameter narrows the type to a specific native element kind,
+ * preventing accidental cross-element assignments (e.g. ListElementRef ≠ ViewElementRef).
+ */
+type ElementRef<Tag extends string = string> = {
+  readonly [__brand]?: Tag;
+};
+/**
+ * ComponentElementRef accepts both 'component' and 'page' so that
+ * PageElementRef (which is ElementRef<'page'>) remains assignable to it,
+ * preserving the original hierarchy: Page ⊆ Component ⊆ ElementRef.
+ */
+type ComponentElementRef = ElementRef<'component' | 'page'>;
+type PageElementRef = ElementRef<'page'>;
+type ListElementRef = ElementRef<'list'>;
+type ViewElementRef = ElementRef<'view'>;
+type TextElementRef = ElementRef<'text'>;
+type RawTextElementRef = ElementRef<'raw-text'>;
+type ImageElementRef = ElementRef<'image'>;
+type ScrollElementRef = ElementRef<'scroll'>;
+type WrapperElementRef = ElementRef<'wrapper'>;
+type NoneElementRef = ElementRef<'none'>;
+type IfElementRef = ElementRef<'if'>;
+type ForElementRef = ElementRef<'for'>;
+type BlockElementRef = ElementRef<'block'>;
+type FrameElementRef = ElementRef<'frame'>;
+/**
+ * AnyObject = Record<string, any>, sourced from @lynx-js/types rather than
+ * duplicating the definition locally.
+ */
+type ElementInfo = AnyObject;
+type SelectorParams = {
+  onlyCurrentComponent?: boolean;
+};
+type DynamicComponentResult = {
+  code: number;
+  data: {
+    evalResult: (url: string) => {
+      name: string;
+    };
+  };
+};
+/**
+ * Global PAPI declarations — these __* functions are injected by the Lynx
+ * native engine and are not part of @lynx-js/types (which covers the
+ * high-level JS API layer only).
+ */
+declare global {
+  function __CreatePage(componentId: string, cssId: number, info?: ElementInfo): PageElementRef;
+  function __CreateComponent(parentComponentUniId: number, componentId: string, cssId: number, entryName: string, name: string, path: string, config?: Record<string, unknown>): ComponentElementRef;
+  function __CreateView(parentComponentUniId: number, info?: ElementInfo): ViewElementRef;
+  function __CreateScrollView(parentComponentUniId: number, info?: ElementInfo): ScrollElementRef;
+  function __CreateText(parentComponentUniId: number, info?: ElementInfo): TextElementRef;
+  function __CreateRawText(text: string, info?: ElementInfo): RawTextElementRef;
+  function __CreateImage(parentComponentUniId: number, info?: ElementInfo): ImageElementRef;
+  function __CreateWrapperElement(parentComponentUniId: number): WrapperElementRef;
+  function __CreateNonElement(parentComponentUniId: number): ElementRef;
+  function __CreateIf(parentComponentUniId: number, info?: ElementInfo): IfElementRef;
+  function __CreateFor(parentComponentUniId: number, info?: ElementInfo): ForElementRef;
+  function __CreateBlock(parentComponentUniId: number, info?: ElementInfo): BlockElementRef;
+  function __CreateList(parentComponentUniId: number, componentAtIndex: (listRef: ListElementRef, listId: number, cellIndex: number, opId: number) => number | undefined, enqueueComponent: (listRef: ListElementRef, listId: number, eleId: number) => void, info?: ElementInfo, componentAtIndexes?: (listRef: ListElementRef, listId: number, cellIndexes: number[], opIds: number[], enableReuseNotification: boolean, asyncFlush: boolean) => void): ListElementRef;
+  function __UpdateListCallbacks(node: ListElementRef, componentAtIndex: (listRef: ListElementRef, listId: number, cellIndex: number, opId: number) => number | undefined, enqueueComponent: (listRef: ListElementRef, listId: number, eleId: number) => void, componentAtIndexes?: (listRef: ListElementRef, listId: number, cellIndexes: number[], opIds: number[], enableReuseNotification: boolean, asyncFlush: boolean) => void | null): void;
+  function __CreateFrame(parentComponentUniId: number, info?: ElementInfo): FrameElementRef;
+  function __CreateElement(tag: string, comParentUniID: number, info?: ElementInfo): ElementRef;
+  function __AppendElement(parent: ElementRef, current: ElementRef): ElementRef;
+  function __RemoveElement(parent: ElementRef, current: ElementRef): ElementRef;
+  function __InsertElementBefore(parent: ElementRef, current: ElementRef, marker: ElementRef): ElementRef;
+  function __SwapElement(a: ElementRef, b: ElementRef): void;
+  function __ReplaceElement(a: ElementRef, b: ElementRef): void;
+  function __ReplaceElements(parent: ElementRef, a: ElementRef | ElementRef[] | undefined, b: ElementRef | ElementRef[] | undefined): void;
+  function __GetParent(current: ElementRef): ElementRef | null;
+  function __GetChildren(current: ElementRef): ElementRef[];
+  function __FirstElement(current: ElementRef): ElementRef;
+  function __LastElement(current: ElementRef): ElementRef;
+  function __NextElement(node: ElementRef): ElementRef;
+  function __GetTag(node: ElementRef): string;
+  function __SetAttribute(current: ElementRef, attrName: string, value: any): void;
+  function __AddClass(current: ElementRef, className: string): void;
+  function __SetClasses(current: ElementRef, className: string | undefined): void;
+  function __GetClasses(current: ElementRef): string[];
+  function __SetStaticStyle(node: ElementRef, key: number, value: unknown): void;
+  function __SetInlineStyles(node: ElementRef, value: unknown): void;
+  function __GetInlineStyle(node: ElementRef, propertyId: number): string;
+  function __GetInlineStyles(node: ElementRef): string;
+  function __SetID(node: ElementRef, id: string | undefined): void;
+  function __GetID(node: ElementRef): string;
+  function __SetCSSId(node: ElementRef, cssId: number, entryName?: string): void;
+  function __AddEvent(node: ElementRef, type: string, name: string, func: string | Record<string, unknown> | undefined): void;
+  function __SetEvents(node: ElementRef, events: Record<string, unknown>[] | undefined): void;
+  function __GetEvent(node: ElementRef, name: string, type: string): Record<string, any>;
+  function __GetEvents(node: ElementRef): Record<string, any>[];
+  function __AddDataset(node: ElementRef, key: string, value: unknown): void;
+  function __SetDataset(node: ElementRef, value: Record<string, unknown> | undefined): void;
+  function __GetDataset(node: ElementRef): Record<string, unknown>;
+  function __GetDataByKey(node: ElementRef, key: string): any;
+  function __GetElementUniqueID(node: ElementRef): number;
+  function __ElementIsEqual(left: ElementRef, right: ElementRef): boolean;
+  function __UpdateComponentID(node: ElementRef, id: string): void;
+  function __GetComponentID(node: ElementRef): string;
+  function __UpdateComponentInfo(node: ElementRef, params: {
+    componentID?: string;
+    name?: string;
+    path?: string;
+    entry?: string;
+    cssID?: number;
+  }): void;
+  function __FlushElementTree(element?: ElementRef, options?: {
+    triggerLayout?: boolean;
+    triggerDataUpdated?: boolean;
+    operationID?: number;
+    operationIDs?: number[];
+    nativeUpdateDataOrder?: number;
+    __lynx_timing_flag?: string;
+    elementID?: number;
+    elementIDs?: number[];
+    reloadTemplate?: boolean;
+    listID?: number;
+    pipelineOptions?: Record<string, any>;
+    /**
+     * Delegate async scheduling to the native engine (used in componentAtIndexes batch path).
+     */
+    asyncFlush?: boolean;
+  }): void;
+  function __AsyncResolveElement(element: ElementRef): void;
+  function __OnLifecycleEvent(args: any[]): void;
+  function _ReportError(err: Error, info: {
+    errorCode: number;
+  }): void;
+  function __ElementFromBinary(elementTemplateKey: string, parentComponentUniId: number): ElementRef[];
+  function __GetTemplateParts(ele: ElementRef): Record<string, ElementRef>;
+  function __CloneElement(ele: ElementRef, options: Record<string, any>): ElementRef;
+  function __IsTemplateElement(ele: ElementRef): boolean;
+  function __MarkTemplateElement(ele: ElementRef): void;
+  function __MarkPartElement(ele: ElementRef, key: string): void;
+  function __QuerySelector(root: ElementRef, cssSelector: string, params: SelectorParams): ElementRef;
+  function __QuerySelectorAll(root: ElementRef, cssSelector: string, params: SelectorParams): ElementRef[];
+  function __AddConfig(ele: ElementRef, key: string, value: any): void;
+  function __SetConfig(ele: ElementRef, config: Record<string, any>): void;
+  function __GetElementConfig(ele: ElementRef): Record<string, unknown>;
+  function __QueryComponent(source: string, callback: (evalResult: DynamicComponentResult) => void): {
+    evalResult: unknown;
+  };
+  function __AddInlineStyle(e: ElementRef, key: number | string, value: unknown): void;
+  function __ElementAnimate(element: ElementRef, args: [operation: 0, name: string, keyframes: Record<string, string | number>[], options?: LynxAnimationOptions] | [operation: 1 | 2 | 3, name: string]): void;
+  function __GetAttributeByName(e: ElementRef, name: string): any;
+  function __GetAttributeNames(e: ElementRef): string[];
+  function __GetAttributes(e: ElementRef): Record<string, any>;
+  function __GetComputedStyleByKey(e: ElementRef, key: string): string;
+  function __GetPageElement(): ElementRef;
+  function __InvokeUIMethod(e: ElementRef, method: string, params: Record<string, unknown>, callback: (res: {
+    code: number;
+    data: unknown;
+  }) => void): ElementRef[];
+  function __LoadLepusChunk(name: string, cfg: {
+    chunkType: number;
+  }): void;
+  function __CreateGestureDetector(node: ElementRef, gestureID: number, gestureType: number, config: {
+    callbacks: Array<{
+      name: string;
+      callback: unknown;
+    }>;
+    config?: Record<string, unknown>;
+  }, relationMap: Record<string, number[]>): void;
+  function __SetGestureDetector(node: ElementRef, gestureID: number, gestureType: number, config: {
+    callbacks: Array<{
+      name: string;
+      callback: unknown;
+    }>;
+    config?: Record<string, unknown>;
+  }, relationMap: Record<string, number[]>): void;
+  function __RemoveGestureDetector(node: ElementRef, gestureID: number): void;
+  function __SetGestureState(node: ElementRef, gestureID: number, state: number): void;
+  function __ConsumeGesture(node: ElementRef, gestureID: number, options: Record<string, boolean>): void;
+  function __GeneratePipelineOptions(): Record<string, any>;
+  function __OnPipelineStart(pipeLineId: string, pipeLineOrigin: string): void;
+  function __BindPipelineIDWithTimingFlag(pipeLineId: string, timingFlag: string): void;
+  function __MarkTiming(pipeLineId: string, timingFlag: string): void;
+  function __AddTimingListener(): void;
+  function __SetLepusInitData(initData: Record<string, unknown>): void;
+  function __GetElementByUniqueID(elementId: number): ElementRef | undefined;
+  function __UpdateIfNodeIndex(node: IfElementRef, ifIndex: number): void;
+  function __UpdateForChildCount(node: ForElementRef, childCount: number): void;
+}
+/**
+ * Extends the official AnimationOptions with Lynx-native property aliases
+ * and relaxed types that accept string values (e.g. "300ms").
+ */
+type LynxAnimationOptions = AnimationOptions & {
+  iterationCount?: number | string;
+  fillMode?: string;
+  timingFunction?: string;
+};
+/**
+ * The public API of an animation, which `BaseLynxElement.animate()` returns.
+ * LynxAnimation uses ES private fields (#element, #count), which brand the
+ * class, so a structural type lets other implementations, such as a test
+ * double, satisfy it.
+ */
+type BaseLynxAnimation = Pick<Animation, 'id' | 'cancel' | 'pause' | 'play'>;
+/**
+ * Represents a running animation on a Lynx element.
+ * Created by calling `element.animate()` on a LynxElement.
+ * Mirrors the Animation class from React Lynx's worklet-runtime, except for
+ * the key a named animation is controlled by (see the constructor).
+ */
+export declare class LynxAnimation implements Pick<Animation, 'id' | 'cancel' | 'pause' | 'play'> {
+  #private;
+  readonly id: string;
+  constructor(element: ElementRef, keyframes: Record<string, string | number>[], options: LynxAnimationOptions);
+  play(): void;
+  pause(): void;
+  cancel(): void;
+}
+/**
+ * Profiling counters collected by the renderer during a session.
+ * Only populated in development builds, where `__PROFILE__` is true — in
+ * production, instrumentation is dead-code-eliminated and all values stay 0.
+ */
+type DevToolsStats = {
+  cdCycles: number;
+  elementCreated: number;
+  elementRemoved: number;
+  flushCount: number;
+  lastCdDurationMs: number;
+};
+/**
+ * Options for `LynxPerformance.profileStart()` and `profileMark()`. The same
+ * shape as Lynx's own `TraceOption`; `performance.ts` passes it to Lynx as
+ * one, so the compiler keeps the two in step.
+ */
+type LynxTraceOptions = {
+  flowId?: number;
+  flowIds?: number[];
+  args?: Record<string, string>;
+};
+/**
+ * Wraps Lynx's native performance tracing APIs (`lynx.performance`).
+ *
+ * All methods are no-ops when `lynx.performance` is unavailable (e.g. in tests
+ * or non-Lynx environments) or when profiling is not actively recording.
+ *
+ * Unlike the `LynxDevTools` counters, the calls aren't gated by `__PROFILE__`,
+ * so they stay in production builds. A trace is worth recording from the build
+ * you ship, without development mode's extra work in it. They cost little
+ * there: release builds of the Lynx engine compile tracing out, so each call
+ * returns at once.
+ *
+ * @usageNotes
+ * ```typescript
+ * const perf = inject(LynxPerformance);
+ *
+ * perf.profileStart('MyComponent::render', { args: { itemCount: '42' } });
+ * // ... do work ...
+ * perf.profileEnd();
+ *
+ * perf.profileMark('dataLoaded', { args: { source: 'cache' } });
+ * ```
+ */
+export declare class LynxPerformance {
+  #private;
+  /**
+   * Whether profiling is actively recording traces.
+   * Returns false when `lynx.performance` is unavailable.
+   */
+  isRecording(): boolean;
+  /**
+   * Begin a named trace. Must be paired with `profileEnd()`.
+   * Traces nest — multiple `profileStart` calls create a stack.
+   */
+  profileStart(name: string, options?: LynxTraceOptions): void;
+  /**
+   * End the current trace (top of the trace stack).
+   */
+  profileEnd(): void;
+  /**
+   * Emit a discrete mark event in the trace timeline.
+   */
+  profileMark(name: string, options?: LynxTraceOptions): void;
+  /**
+   * Generate a unique flow ID for correlating multi-threaded traces.
+   */
+  profileFlowId(): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxPerformance, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * High-level DevTools service exposing performance stats as Angular signals.
+ *
+ * Stats are only meaningful in development builds, where the build plugin sets
+ * `__PROFILE__` to true. In production builds, counters are never incremented
+ * (the instrumentation code is dead-code-eliminated), so all values remain
+ * zero.
+ *
+ * @usageNotes
+ * ```typescript
+ * const devtools = inject(LynxDevTools);
+ *
+ * // Read stats reactively in a template
+ * <text>CD cycles: {{ devtools.stats().cdCycles }}</text>
+ *
+ * // Take a one-shot snapshot
+ * const snap = devtools.snapshot();
+ * console.log('Elements created:', snap.elementCreated);
+ *
+ * // Reset counters
+ * devtools.reset();
+ * ```
+ */
+export declare class LynxDevTools {
+  #private;
+  /**
+   * Reactive stats snapshot. Re-reads from `devStats` each time
+   * `refresh()` is called, or automatically after `reset()`.
+   */
+  readonly stats: import("@angular/core").Signal<DevToolsStats>;
+  /**
+   * Take a non-reactive snapshot of current counters.
+   */
+  snapshot(): DevToolsStats;
+  /**
+   * Bump the signal so `stats()` re-evaluates with latest counter values.
+   */
+  refresh(): void;
+  /**
+   * Zero all counters and update the reactive signal.
+   */
+  reset(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxDevTools, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Module-level counters for hot-path instrumentation.
+ * Plain object avoids DI/signal overhead on every element operation.
+ * Only incremented when __PROFILE__ is true (dead-code-eliminated otherwise).
+ */
+declare const devStats: DevToolsStats & {
+  reset(): void;
+};
+/**
+ * Starts timing a change-detection cycle. The renderer factory calls it from
+ * `begin()`, and `endCdTiming()` from `end()`.
+ */
+declare const startCdTiming: () => void;
+/**
+ * Stops timing the innermost change-detection cycle in progress, and records
+ * its duration in `devStats.lastCdDurationMs`.
+ */
+declare const endCdTiming: () => void;
+/**
+ * Extend this interface to type the raw data passed from native before processing.
+ *
+ * @example
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
+ * declare module '@blotch/angular-lynx' {
+ *   interface InitDataRaw { userId: string; }
+ * }
+ */
+interface InitDataRaw extends Record<string, unknown> {}
+/**
+ * Extend this interface to type the processed init data used throughout the app.
+ *
+ * @example
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
+ * declare module '@blotch/angular-lynx' {
+ *   interface InitData { userId: string; }
+ * }
+ */
+interface InitData extends Record<string, unknown> {}
+/**
+ * Extend this interface to type the global data passed from the native host.
+ *
+ * @example
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
+ * declare module '@blotch/angular-lynx' {
+ *   interface GlobalData { theme: 'light' | 'dark'; }
+ * }
+ */
+interface GlobalData extends Record<string, unknown> {}
+type DataProcessorDefinition = {
+  /**
+   * Transform raw native init data before it is stored in LynxInitData.
+   */
+  defaultDataProcessor?: (rawInitData: InitDataRaw) => InitData;
+  /**
+   * Named processors callable by the native side via processData(data, processorName).
+   */
+  dataProcessors?: Record<string, (...args: any[]) => any>;
+};
+/**
+ * Register data processor functions that the native Lynx runtime calls before
+ * delivering init data to the app. Maps to the global `processData` callback.
+ *
+ * Call this before bootstrapApplication. The engine runs the default processor
+ * on the InitData before passing it to renderPage, so its result is what
+ * LynxInitData starts with.
+ *
+ * @example
+ * registerDataProcessors({
+ *   defaultDataProcessor: (raw) => ({ ...raw, theme: raw.theme ?? 'light' }),
+ * });
+ * bootstrapApplication(App, appConfig);
+ */
+export declare const registerDataProcessors: (definition: DataProcessorDefinition) => void;
+export declare class LynxGlobalData {
+  readonly globalData: import("@angular/core").WritableSignal<GlobalData>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxGlobalData, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class LynxInitData {
+  readonly initData: import("@angular/core").WritableSignal<InitData>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxInitData, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Angular ErrorHandler that routes errors to the native Lynx error reporting API.
+ *
+ * Automatically provided by provideRenderer(). Also writes to __lynxLastError
+ * so components can surface errors as <text> elements (no console on device).
+ */
+export declare class LynxErrorHandler implements ErrorHandler {
+  handleError(error: unknown): void;
+  /**
+   * Called by Angular for rendering errors caught by an `@boundary` block.
+   *
+   * Without this override Angular falls back to `handleError`, which reports a
+   * fatal LEPUS error — on device that raises the red error overlay even though
+   * the boundary already swapped in its `@error` fallback and the app is still
+   * usable. A caught error is recoverable by definition, so it goes to
+   * `lynx.reportError` at `warning` level instead: monitoring still sees it,
+   * but it isn't treated as a crash.
+   *
+   * Angular calls this synchronously mid-render, so it must not write to
+   * signals (NG0600) — it only touches a plain global and the native bridge.
+   */
+  onViewError(error: Error, _details: ErrorDetails): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxErrorHandler, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class LynxExposure implements OnDestroy {
+  #private;
+  readonly visible: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxExposure, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxExposure, "[lynxExposure]", ["lynxExposure"], {}, {}, never, never, true, never>;
+}
+/**
+ * Wire format for individual exposure/disexposure event entries.
+ * Dual-cased fields (kebab and camel) match the Lynx engine's output exactly.
+ */
+type ExposureEventDetail = {
+  'exposure-id': string;
+  'exposure-scene': string;
+  exposureID: string;
+  exposureScene: string;
+  /**
+   * Identifies the native element. Lynx documents it as a string, which iOS
+   * and Android send; the web sends the element's numeric unique ID.
+   */
+  'unique-id': string | number;
+};
+/**
+ * The Lynx engine batches element visibility changes at ~20fps and dispatches
+ * them as arrays via GlobalEventEmitter ('exposure' / 'disexposure' events).
+ */
+type GlobalExposureEvent = ExposureEventDetail[];
+type ObserverFrameRateOptions = {
+  forPageRect?: number;
+  forExposureCheck?: number;
+};
+export declare class LynxGlobalExposure {
+  #private;
+  readonly exposures: import("@angular/core").WritableSignal<GlobalExposureEvent>;
+  readonly disexposures: import("@angular/core").WritableSignal<GlobalExposureEvent>;
+  readonly active: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  /**
+   * Pauses global exposure detection. Elements with exposure-id stop generating
+   * exposure/disexposure GlobalEventEmitter events. Element-level
+   * binduiappear/binduidisappear events continue to fire.
+   */
+  stopExposure(options?: {
+    sendEvent: boolean;
+  }): void;
+  resumeExposure(): void;
+  /**
+   * Sets how often Lynx checks for exposure. Only the background thread's
+   * `lynx` has setObserverFrameRate, so a call from an event handler, which
+   * runs on the main thread, goes through the background thread (see
+   * background-call.ts). Resolves once it's applied.
+   */
+  setObserverFrameRate(options?: ObserverFrameRateOptions): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxGlobalExposure, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Configuration for a custom font face to register dynamically via `lynx.addFont()`.
+ *
+ * Only `fontFamily` and `src` are supported by the Lynx engine.
+ * Platform formats: Android (TTF, OTF, TTC), iOS (TTF, OTF, WOFF, WOFF2).
+ */
+type LynxFontFaceConfig = {
+  fontFamily: string;
+  src: string;
+};
+type LynxFontStatus = 'idle' | 'loading' | 'loaded' | 'error';
+type LynxFontEntry = {
+  fontFamily: string;
+  src: string;
+  status: LynxFontStatus;
+  error?: Error;
+};
+/**
+ * Wraps `lynx.addFont()` with a Promise-based API and reactive signal state.
+ * Only the background thread's `lynx` has addFont, so a call from an event
+ * handler, which runs on the main thread, goes through the background thread
+ * (see background-call.ts).
+ *
+ * Use CSS `@font-face` in stylesheets for fonts known at build time (the
+ * standard Angular approach). Use this service only for fonts that must be
+ * loaded dynamically at runtime.
+ *
+ * @usageNotes
+ * ```typescript
+ * const fontService = inject(LynxFont);
+ *
+ * await fontService.addFont({
+ *   fontFamily: 'CustomFont',
+ *   src: 'https://example.com/custom-font.ttf',
+ * });
+ *
+ * // Reactive state
+ * const loaded = fontService.loadedFamilies(); // ReadonlySet<string>
+ * ```
+ */
+export declare class LynxFont {
+  #private;
+  readonly fonts: import("@angular/core").Signal<ReadonlyMap<string, LynxFontEntry>>;
+  readonly loadedFamilies: import("@angular/core").Signal<ReadonlySet<string>>;
+  addFont(config: LynxFontFaceConfig): Promise<void>;
+  isLoaded(fontFamily: string): boolean;
+  getStatus(fontFamily: string): LynxFontStatus;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxFont, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Loads an external Lynx component bundle at runtime and returns the Angular
+ * component type. Wraps the native `__QueryComponent` PAPI — bundles must be
+ * built with `experimental_isLazyBundle: true` in the rsbuild plugin.
+ */
+export declare const loadLazyBundle: (source: string) => Promise<Type<unknown>>;
+/**
+ * The parts of webpack's `module.hot` API that {@link ɵhmrAccept} uses.
+ */
+type HotModule = {
+  accept(): void;
+  dispose(callback: (data: Record<string, unknown>) => void): void;
+  invalidate(): void;
+  /** What the module's previous version passed to its dispose handlers. */
+  data?: Record<string, unknown>;
+};
+/**
+ * Takes a hot update of a module that defines components. The build plugin
+ * adds a call to the end of each such module in a development build, which
+ * reassigns the module's component classes to what it returns.
+ *
+ * On the main thread, where the app runs, a new version of the module either
+ * updates the running app in place or passes the update on:
+ *
+ * - **Only a template or stylesheet changed** (the source `signature`, which
+ *   leaves those out, is the same, and the compiled `code` isn't): each
+ *   component's new definition replaces the old one with Angular's
+ *   `ɵɵreplaceMetadata()`, which Angular's own dev server uses for the same
+ *   edits. It re-renders every view of the component in place and keeps the
+ *   component instances, so their state survives. The module's bindings are
+ *   pointed back at the old classes, so every module keeps using the one
+ *   class the app's instances and injectors know.
+ * - **Anything else changed**, such as the class, an import, or a module this
+ *   one imports: the update can't be applied to the running instances, so
+ *   `hot.invalidate()` passes it on to the modules that import this one, up
+ *   to the app's entry, which bootstraps the app again (see
+ *   `bootstrapApplication`).
+ *
+ * The background thread runs no Angular, only the module-level code that
+ * registers background functions. It accepts every version, which re-runs
+ * the module and registers them again.
+ *
+ * @param hot - The module's `import.meta.webpackHot`.
+ * @param components - The component classes this version of the module defines.
+ * @param signature - A hash of the module's source without its components'
+ *   templates and styles.
+ * @param code - A hash of the module's compiled code.
+ * @returns The classes the module should use from now on.
+ */
+export declare const ɵhmrAccept: (hot: HotModule, components: Type<unknown>[], signature: string, code: string) => Type<unknown>[];
+/**
+ * The app's own locale: `sourceLocale` from angular.json, which the build
+ * injects as `__LYNX_SOURCE_LOCALE__`, or `'en-US'` without one.
+ */
+declare const getSourceLocale: () => string;
+/**
+ * Reads `lynx.__globalProps.appLocale` directly, without Angular DI.
+ *
+ * Use this before `bootstrapApplication()` runs — e.g. to conditionally call
+ * `loadTranslations()` — since no injector exists yet at that point. Once the
+ * app is bootstrapped, prefer injecting `LynxLocale` for reactive access.
+ *
+ * Returns `undefined` outside a Lynx environment or when the host hasn't set
+ * a locale; callers decide their own fallback.
+ *
+ * @usageNotes
+ * ```typescript
+ * if (getLynxAppLocale() === 'fr') {
+ *   loadTranslations({ 'app.greeting': 'Bonjour le monde !' });
+ * }
+ *
+ * bootstrapApplication(App, appConfig);
+ * ```
+ */
+export declare const getLynxAppLocale: () => string | undefined;
+/**
+ * Provides reactive access to the current locale on Lynx.
+ *
+ * Reads `lynx.__globalProps.appLocale` (set by the native host). Falls back to
+ * the `sourceLocale` from angular.json (injected as `__LYNX_SOURCE_LOCALE__`
+ * at build time), then to `'en-US'`.
+ *
+ * @usageNotes
+ * ```typescript
+ * const locale = inject(LynxLocale);
+ *
+ * // Reactive in templates
+ * template: `<text>Current locale: {{ locale.locale() }}</text>`
+ *
+ * // For LOCALE_ID integration, add provideLocale() to your app config
+ * ```
+ */
+export declare class LynxLocale {
+  #private;
+  /**
+   * The current locale. Reactive — updates when global props change.
+   */
+  readonly locale: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxLocale, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Provides Angular's `LOCALE_ID` token from the Lynx runtime locale.
+ *
+ * Add this to your application's providers to automatically configure
+ * Angular's locale-aware features (pipes, i18n) with the locale from
+ * `lynx.__globalProps.appLocale`.
+ *
+ * The apps that `ng build --platform` makes send the phone's language, which
+ * the app may not support. When Angular has no locale data for it (see
+ * `registerLocaleData()`), `LOCALE_ID` is the app's source locale instead, as
+ * a native app shows its own language on a phone set to one it lacks.
+ * Otherwise Angular's date and number pipes would throw.
+ *
+ * @usageNotes
+ * ```typescript
+ * bootstrapApplication(App, {
+ *   providers: [provideRenderer(), provideLocale()],
+ * });
+ * ```
+ */
+export declare const provideLocale: () => EnvironmentProviders;
+/**
+ * Controls gesture state from within a callback.
+ * Wraps __SetGestureState and __ConsumeGesture PAPI calls.
+ * Passed as the second argument to gesture callbacks so handlers can
+ * programmatically drive the gesture state machine (e.g. activate a gesture
+ * only when a condition is met, or fail it early to let a competing gesture win).
+ */
+export declare class GestureStateManager {
+  #private;
+  constructor(element: ElementRef, gestureId: number);
+  /**
+   * State codes match Lynx's native gesture state enum:
+   * 1 = ACTIVE, 2 = FAILED, 3 = END
+   */
+  fail(): void;
+  activate(): void;
+  end(): void;
+  /**
+   * `{ consume }` stops the gesture from bubbling up to ancestor elements.
+   * Use this when this element should handle the gesture exclusively and
+   * parent scroll containers or gesture detectors should not also receive it.
+   */
+  consumeGesture(consume?: boolean): void;
+  /**
+   * `{ inner: intercept }` intercepts gestures from DESCENDANT elements —
+   * the opposite direction of consumeGesture. Use this on a parent to claim
+   * a gesture before children can handle it (e.g. a pull-to-refresh view
+   * intercepting scrolls inside its list child).
+   */
+  interceptGesture(intercept?: boolean): void;
+}
+/**
+ * Gesture type IDs matching the Lynx native engine (from @lynx-js/react gesture-runtime).
+ */
+export declare enum GestureType {
+  PAN = 0,
+  FLING = 1,
+  DEFAULT = 2,
+  TAP = 3,
+  LONGPRESS = 4,
+  ROTATION = 5,
+  PINCH = 6,
+  NATIVE = 7
+}
+export declare enum GestureState {
+  UNDETERMINED = 0,
+  BEGAN = 1,
+  ACTIVE = 2,
+  END = 3,
+  FAILED = 4,
+  CANCELED = 5
+}
+type GestureEvent = {
+  /**
+   * Optional: the native engine conveys the phase through the callback that
+   * fires (onBegin/onStart/onUpdate/onEnd), not a field on the event payload,
+   * so `state` is usually absent at runtime.
+   */
+  state?: GestureState;
+  /**
+   * Absolute (page-relative) coordinates, derived at runtime by mapGestureEvent
+   * from the native `pageX`/`pageY`. Optional (was required) because they're
+   * only present when the gesture's payload carries coordinates — making the
+   * type promise a `number` that isn't always there was a latent footgun.
+   */
+  absoluteX?: number;
+  absoluteY?: number;
+  /**
+   * The untouched native params dict (Lynx field names: scrollX, pageX, x, y,
+   * isAtStart, …). Escape hatch for reading fields that have no flat alias —
+   * the flat properties above are derived from it. See mapGestureEvent.
+   */
+  params?: Record<string, unknown>;
+};
+type PanGestureEvent = {
+  translationX: number;
+  translationY: number;
+  velocityX: number;
+  velocityY: number;
+} & GestureEvent;
+type TapGestureEvent = {
+  x: number;
+  y: number;
+} & GestureEvent;
+type FlingGestureEvent = {
+  velocityX: number;
+  velocityY: number;
+} & GestureEvent;
+type PinchGestureEvent = {
+  scale: number;
+  velocity: number;
+} & GestureEvent;
+type RotationGestureEvent = {
+  rotation: number;
+  velocity: number;
+} & GestureEvent;
+type LongPressGestureEvent = {
+  x: number;
+  y: number;
+  duration: number;
+} & GestureEvent;
+/**
+ * Bitmask values — combine with bitwise OR for multi-direction fling:
+ * e.g. FlingDirection.LEFT | FlingDirection.RIGHT for horizontal fling.
+ */
+export declare enum FlingDirection {
+  RIGHT = 1,
+  LEFT = 2,
+  UP = 4,
+  DOWN = 8
+}
+type GestureCallback<TEvent extends GestureEvent = GestureEvent> = (event: TEvent) => void;
+type GestureCallbackWithState<TEvent extends GestureEvent = GestureEvent> = (event: TEvent, stateManager: GestureStateManager) => void;
+export declare abstract class BaseGesture<TEvent extends GestureEvent = GestureEvent, TSelf extends BaseGesture<TEvent, any> = any> {
+  readonly id: number;
+  abstract readonly type: GestureType;
+  /**
+   * @internal — accessed by the directive to build the PAPI config.
+   * GestureCallback<any> avoids an invariance error when assigning concrete gesture
+   * subclasses (e.g. PanGesture) to BaseGesture<GestureEvent, any>. The directive
+   * already casts callbacks to any when invoking them, so the wider type is safe.
+   */
+  _callbacks: Record<string, GestureCallback<any>>;
+  /**
+   * @internal
+   *
+   * Starts as `{ enabled: true }`, like React Lynx's gesture-runtime, so every
+   * gesture sends a config, even one with no options of its own (Fling, Pinch,
+   * Rotation). Gestures whose native handler reads options seed the rest of
+   * their defaults too: once a config is present, iOS reads each key it leaves
+   * out as `0` (see ./const).
+   */
+  _config: Record<string, unknown>;
+  /**
+   * @internal
+   */
+  _waitFor: BaseGesture[];
+  /**
+   * @internal
+   */
+  _simultaneousWith: BaseGesture[];
+  /**
+   * @internal
+   */
+  _continueWith: BaseGesture[];
+  /**
+   * Fires when the gesture starts tracking a touch, before it's recognized:
+   * at touch-down for most gestures, and when the finger lifts for a fling.
+   *
+   * A continuous gesture doesn't need one for its `onStart` and `onEnd` to
+   * fire. LynxGestureDetector registers an empty `onBegin` when you don't, since
+   * Lynx's native handlers skip those callbacks without it. See
+   * gesture-detector.ts.
+   */
+  onBegin(cb: GestureCallbackWithState<TEvent>): TSelf;
+  /**
+   * Fires when the gesture is RECOGNIZED (transitions to active). For a tap this
+   * is the only callback that fires exclusively on success — see `onEnd`.
+   */
+  onStart(cb: GestureCallbackWithState<TEvent>): TSelf;
+  /**
+   * Fires when the gesture ends.
+   *
+   * For discrete gestures (tap, long-press) LynxGestureDetector normalizes this
+   * to fire ONLY when the gesture was actually recognized. Lynx's native engine
+   * emits `onEnd` on failure too — the iOS `fail` path calls it — so a drag that
+   * overshoots a tap's `maxDistance` would otherwise still trigger `onEnd`. The
+   * directive suppresses that failed-gesture `onEnd`; continuous gestures pass
+   * through unchanged. See gesture-detector.ts.
+   */
+  onEnd(cb: GestureCallbackWithState<TEvent>): TSelf;
+  onTouchesDown(cb: GestureCallbackWithState<TEvent>): TSelf;
+  onTouchesUp(cb: GestureCallbackWithState<TEvent>): TSelf;
+  /**
+   * Delays this gesture until all listed gestures have failed.
+   * Use to give higher-priority gestures (e.g. double-tap) first right of refusal.
+   * `as unknown as TSelf` is needed because TypeScript can't prove that `this`
+   * satisfies the concrete TSelf bound — the double cast is intentional.
+   */
+  waitFor(...gestures: BaseGesture[]): TSelf;
+  /**
+   * Allows this gesture and the listed gestures to be active at the same time.
+   * Without this, Lynx's gesture system lets only one gesture be active per element.
+   */
+  simultaneousWith(...gestures: BaseGesture[]): TSelf;
+  /**
+   * This gesture activates after the listed gestures END (not fail).
+   * Useful for chaining: e.g. a long-press followed by a drag.
+   */
+  continueWith(...gestures: BaseGesture[]): TSelf;
+  /**
+   * ⚠️ Not read by Lynx's native gesture handlers yet (as of Lynx 4.1, no
+   * handler looks up `enabled`), so a disabled gesture still fires on a
+   * device. Unbind the gesture from `[lynxGesture]` to turn it off. Kept for
+   * API parity with Lynx's gesture-runtime.
+   */
+  enabled(value: boolean): TSelf;
+}
+/**
+ * Continuous gestures (pan, fling, rotation, pinch) have an onUpdate callback
+ * that fires on every frame while the gesture is active.
+ */
+export declare abstract class ContinuousGesture<TEvent extends GestureEvent = GestureEvent, TSelf extends ContinuousGesture<TEvent, any> = any> extends BaseGesture<TEvent, TSelf> {
+  onUpdate(cb: GestureCallbackWithState<TEvent>): TSelf;
+}
+type AnyGesture$1 = BaseGesture<any, any>;
+export declare class ComposedGesture {
+  readonly gestures: AnyGesture$1[];
+  readonly compositionType: 'simultaneous' | 'exclusive' | 'race';
+  constructor(gestures: AnyGesture$1[], compositionType: 'simultaneous' | 'exclusive' | 'race');
+}
+export declare const Gesture: {
+  Simultaneous(...gestures: AnyGesture$1[]): ComposedGesture;
+  Exclusive(...gestures: AnyGesture$1[]): ComposedGesture;
+  Race(...gestures: AnyGesture$1[]): ComposedGesture;
+};
+/**
+ * Lynx's fling follows the momentum of a drag after the finger lifts: `onBegin`
+ * fires on release, `onUpdate` on every frame (with `deltaX`/`deltaY` in the
+ * params), and `onEnd` when it stops. Lynx starts that fling in its BEGAN
+ * state and never activates it, so `onStart` doesn't fire
+ * (LynxFlingGestureHandler.m / FlingGestureHandler.java). Lynx also flings only
+ * the element that won the touch, and a fling ignores the touch until the
+ * finger lifts, so it needs a pan on the same element (`Gesture.Simultaneous`).
+ */
+export declare class FlingGesture extends ContinuousGesture<FlingGestureEvent, FlingGesture> {
+  readonly type = GestureType.FLING;
+  /**
+   * FlingDirection is a bitmask — combine values with | for multi-direction:
+   * e.g. FlingDirection.LEFT | FlingDirection.RIGHT recognizes horizontal flings.
+   *
+   * ⚠️ Not read by Lynx's native fling handlers yet: as of Lynx 4.1, iOS's
+   * `handleConfigMap` is a TODO and Android's is empty, so every fling fires,
+   * in any direction. Kept for API parity with Lynx's gesture-runtime.
+   */
+  direction(dir: FlingDirection): this;
+  /**
+   * The gesture only recognizes when exactly `count` fingers are involved.
+   * Defaults to 1 if not set.
+   *
+   * ⚠️ Not read by Lynx's native fling handlers yet (see `direction`).
+   */
+  numberOfPointers(count: number): this;
+}
+type AnyGesture = BaseGesture<any, any>;
+type GestureInput = AnyGesture | AnyGesture[] | ComposedGesture;
+/**
+ * Directive that bridges Angular's gesture binding to Lynx's native gesture
+ * system (__SetGestureDetector / __RemoveGestureDetector). Accepts a single
+ * gesture, an array of gestures, or a ComposedGesture (simultaneous/exclusive).
+ * Each gesture is registered with the native engine via its unique numeric ID.
+ *
+ * Cross-package prerequisite (easy to miss when debugging): the native engine
+ * silently ignores every __SetGestureDetector call unless the compiled page
+ * config has `enableNewGesture: true`. @blotch/rsbuild-plugin-angular-lynx
+ * defaults that flag ON, so this directive works out of the box — but if
+ * gestures ever go dead app-wide with no error, that build flag is the first
+ * thing to check, not this directive.
+ */
+export declare class LynxGestureDetector implements OnChanges, OnDestroy {
+  #private;
+  lynxGesture: GestureInput;
+  constructor();
+  /**
+   * Full teardown + re-register on every input change. This is safe because
+   * gesture IDs are stable (assigned once in BaseGesture constructor), so
+   * inter-gesture relationships (waitFor, simultaneousWith) stay valid.
+   */
+  ngOnChanges(_changes: SimpleChanges): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxGestureDetector, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxGestureDetector, "[lynxGesture]", never, {
+    "lynxGesture": {
+      "alias": "lynxGesture";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class LongPressGesture extends BaseGesture<LongPressGestureEvent, LongPressGesture> {
+  readonly type = GestureType.LONGPRESS;
+  /**
+   * Seed the FULL default config on construction. Without an explicit
+   * `maxDistance`, calling only `minDuration()` would send a partial config and
+   * the native handler would read `maxDistance` back as `0` — failing the
+   * long-press on the tiniest finger jitter. Mirrors Lynx's own gesture-runtime
+   * LongPressGesture defaults. See ./const for the full explanation.
+   */
+  _config: Record<string, unknown>;
+  /**
+   * Minimum hold time in ms before the gesture is recognized.
+   * Shorter presses are treated as taps and ignored.
+   */
+  minDuration(ms: number): this;
+  /**
+   * If the finger drifts more than `px` pixels from the initial touch point
+   * during the hold, the gesture fails — allowing a scroll to take over.
+   */
+  maxDistance(px: number): this;
+}
+export declare class PanGesture extends ContinuousGesture<PanGestureEvent, PanGesture> {
+  readonly type = GestureType.PAN;
+  /**
+   * Seed the default config on construction so a complete config is always sent
+   * to native, keeping behavior consistent with the other gestures. Mirrors
+   * Lynx's own gesture-runtime PanGesture defaults. See ./const.
+   */
+  _config: Record<string, unknown>;
+  minDistance(distance: number): this;
+  /**
+   * activeOffset: the gesture activates once the finger moves past this
+   * threshold. A number means "any direction" (symmetrical); a tuple [min, max]
+   * means the offset must be within that range. Example: activeOffsetX(20)
+   * activates after 20px of horizontal movement.
+   *
+   * ⚠️ Not read by Lynx's native pan handlers yet: as of Lynx 4.1 they read
+   * only `minDistance` (LynxPanGestureHandler.m / PanGestureHandler.java
+   * `handleConfigMap`). The same goes for activeOffsetY, failOffsetX/Y and
+   * min/maxPointers. Kept for API parity with Lynx's gesture-runtime.
+   */
+  activeOffsetX(offset: number | [number, number]): this;
+  activeOffsetY(offset: number | [number, number]): this;
+  /**
+   * failOffset: if the finger moves past this threshold in the perpendicular
+   * direction, the gesture fails (ceding to a competing gesture). Example:
+   * failOffsetY(10) on a horizontal pan: if the user moves >10px vertically
+   * before activating, the gesture fails and a vertical scroll can take over.
+   *
+   * ⚠️ Not read by Lynx's native pan handlers yet (see `activeOffsetX`). Call
+   * the state manager's `fail()` from `onUpdate` instead.
+   */
+  failOffsetX(offset: number | [number, number]): this;
+  failOffsetY(offset: number | [number, number]): this;
+  minPointers(count: number): this;
+  maxPointers(count: number): this;
+}
+export declare class PinchGesture extends ContinuousGesture<PinchGestureEvent, PinchGesture> {
+  readonly type = GestureType.PINCH;
+}
+export declare class RotationGesture extends ContinuousGesture<RotationGestureEvent, RotationGesture> {
+  readonly type = GestureType.ROTATION;
+}
+export declare class TapGesture extends BaseGesture<TapGestureEvent, TapGesture> {
+  readonly type = GestureType.TAP;
+  /**
+   * Seed the FULL default config on construction. The native iOS handler reads
+   * any absent config key as `0` once a config is present, so shipping a partial
+   * config (e.g. only `numberOfTaps`) would zero out `maxDuration`/`maxDistance`
+   * and make every tap fail instantly. Mirrors Lynx's own gesture-runtime
+   * TapGesture defaults. See ./const for the full explanation.
+   */
+  _config: Record<string, unknown>;
+  /**
+   * For double/triple tap, pair with waitFor on the single-tap gesture so
+   * the single-tap handler doesn't fire prematurely before the count is met.
+   *
+   * ⚠️ NOT enforced by the Lynx native runtime — no platform handler implements
+   * multi-tap counting (a whole-tree search of the Lynx source turns up nothing
+   * that reads `numberOfTaps`), so setting this is currently a no-op on-device.
+   * To detect a double-tap, time successive taps yourself in the callback. Kept
+   * for API parity with Lynx's gesture-runtime.
+   */
+  numberOfTaps(count: number): this;
+  /**
+   * Maximum time between finger-down and finger-up for a tap to register.
+   * Touches held longer than this are treated as a long-press.
+   */
+  maxDuration(ms: number): this;
+  /**
+   * If the finger travels more than `px` pixels before lifting, the tap fails.
+   * Keeps a tap distinct from a small drag.
+   */
+  maxDistance(px: number): this;
+}
+/**
+ * A length Lynx's exposure detection parses, such as `'20px'` or `'-10rpx'`.
+ * Lynx reads the margins as strings, so a bare number has no effect.
+ */
+type ExposureMargin = `${number}px` | `${number}rpx`;
+/**
+ * @Directive() is required so that ng-packagr's Angular partial compiler
+ * recognizes this base class as an Angular artifact. The selector is left
+ * empty — the class is never used directly as a directive.
+ *
+ * DESIGN NOTES — why these are directives, not components:
+ *
+ * 1. No @Component: Components have their own template (<ng-content/>). When a
+ *    component wraps content, Angular treats that content as "projected" — the
+ *    native parent is not yet established while Angular initializes projected
+ *    nodes. Any directive inside the projected content that injects
+ *    ViewContainerRef (e.g. RouterOutlet) will crash because insertAnchorNode
+ *    calls renderer.insertBefore(null, anchor) — null being the not-yet-resolved
+ *    native parent. Using @Directive avoids projection entirely; children are
+ *    rendered as direct element children just like without LYNX_ELEMENTS.
+ *
+ * 2. Properties are declared as inputs so that Angular's template checker
+ *    accepts property bindings like [src]="url" without errors. Angular
+ *    intercepts these bindings and sets them on the directive instance. The
+ *    ngOnChanges hook forwards every input change to the native Lynx element
+ *    via BaseLynxElement.setAttribute(), which calls __SetAttribute — the same
+ *    endpoint that renderer.setProperty() would reach.
+ *
+ * 3. Events (bindtap, catchtap, bindinput, bindscroll, …) are NOT declared as
+ *    @Output() because Angular would intercept them and skip the renderer's
+ *    listen() call, breaking native Lynx event delivery. They continue to work
+ *    via renderer.listen() which handles all unrecognized event names.
+ */
+declare class LynxElementBase implements OnChanges {
+  #private;
+  ngOnChanges(changes: SimpleChanges): void;
+  id?: string;
+  /**
+   * Named reference accessible via lynx.getElementById / findViewByName.
+   */
+  name?: string;
+  /**
+   * Whether this element is an accessibility node.
+   */
+  'accessibility-element'?: boolean;
+  /**
+   * Text read aloud by screen readers.
+   */
+  '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'
+   */
+  'accessibility-traits'?: 'text' | 'image' | 'button' | 'link' | 'header' | 'search' | 'selected' | 'playable' | 'keyboard' | 'summary' | 'disabled' | 'updating' | 'adjustable' | 'tabbar' | 'none';
+  /**
+   * 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.
+   */
+  'accessibility-elements'?: string;
+  'accessibility-elements-hidden'?: boolean;
+  /**
+   * Whether this element exclusively captures accessibility focus.
+   */
+  'accessibility-exclusive-focus'?: boolean;
+  /**
+   * Accessibility identifier (separate from name).
+   */
+  'a11y-id'?: string;
+  /**
+   * Whether the element receives touch events (default: true).
+   */
+  'user-interaction-enabled'?: boolean;
+  /**
+   * Whether the element receives platform-native gestures.
+   */
+  'native-interaction-enabled'?: boolean;
+  /**
+   * Whether touch events pass through to elements below.
+   */
+  'event-through'?: boolean;
+  /**
+   * Extends the touch target area. Object or CSS-shorthand string.
+   */
+  'hit-slop'?: string | object;
+  /**
+   * Whether the element consumes native iOS/Android gestures.
+   */
+  'block-native-event'?: boolean;
+  /**
+   * Whether focus events are suppressed.
+   */
+  'ignore-focus'?: boolean;
+  /**
+   * Allow simultaneous touch recognition (iOS).
+   */
+  'ios-enable-simultaneous-touch'?: boolean;
+  /**
+   * Lets Lynx draw the element into its parent's native view instead of
+   * creating its own (Android). `false` gives it its own view, which sticky
+   * positioning, text selection and reliable clipping need. @default true
+   */
+  flatten?: boolean;
+  /**
+   * Direction in which the element takes pan gestures from native views
+   * outside Lynx: 0 = horizontal, 1 = vertical.
+   */
+  'pan-intercept-direction'?: 0 | 1;
+  /**
+   * Which views `pan-intercept-direction` takes pans from: 0 = self,
+   * 1 = ancestors, 2 = descendants, 3 = self and ancestors, 4 = self and
+   * descendants, 5 = all.
+   */
+  'pan-intercept-scope'?: 0 | 1 | 2 | 3 | 4 | 5;
+  /**
+   * Swipe angle ranges, `[start, end]` in degrees, that the element keeps
+   * from platform gestures.
+   */
+  'consume-slide-event'?: [number, number][];
+  /**
+   * Whether `:active` also applies to the ancestors on the touch's event path.
+   */
+  'enable-touch-pseudo-propagation'?: boolean;
+  /**
+   * Unique ID used for impression/exposure analytics.
+   */
+  'exposure-id'?: string;
+  /**
+   * Scene identifier grouping exposure events.
+   */
+  'exposure-scene'?: string;
+  /**
+   * How much of the element must be visible to count as exposed, as a
+   * percentage string such as `'50%'`. @default '0%'
+   */
+  'exposure-area'?: `${number}%`;
+  /**
+   * Extends/shrinks the viewport detection zone (top edge).
+   */
+  'exposure-screen-margin-top'?: ExposureMargin;
+  /**
+   * Extends/shrinks the viewport detection zone (bottom edge).
+   */
+  'exposure-screen-margin-bottom'?: ExposureMargin;
+  /**
+   * Extends/shrinks the viewport detection zone (left edge).
+   */
+  'exposure-screen-margin-left'?: ExposureMargin;
+  /**
+   * Extends/shrinks the viewport detection zone (right edge).
+   */
+  'exposure-screen-margin-right'?: ExposureMargin;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (top).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
+   */
+  'exposure-ui-margin-top'?: ExposureMargin;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (bottom).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
+   */
+  'exposure-ui-margin-bottom'?: ExposureMargin;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (left).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
+   */
+  'exposure-ui-margin-left'?: ExposureMargin;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (right).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
+   */
+  'exposure-ui-margin-right'?: ExposureMargin;
+  /**
+   * Turns on `exposure-ui-margin-*` on iOS and Android (always on for Harmony
+   * and the web). It also changes how they apply `exposure-screen-margin-*`.
+   * @default false
+   */
+  'enable-exposure-ui-margin'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxElementBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxElementBase, never, never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+    };
+    "accessibility-element": {
+      "alias": "accessibility-element";
+      "required": false;
+    };
+    "accessibility-label": {
+      "alias": "accessibility-label";
+      "required": false;
+    };
+    "accessibility-value": {
+      "alias": "accessibility-value";
+      "required": false;
+    };
+    "accessibility-actions": {
+      "alias": "accessibility-actions";
+      "required": false;
+    };
+    "accessibility-traits": {
+      "alias": "accessibility-traits";
+      "required": false;
+    };
+    "accessibility-elements": {
+      "alias": "accessibility-elements";
+      "required": false;
+    };
+    "accessibility-elements-hidden": {
+      "alias": "accessibility-elements-hidden";
+      "required": false;
+    };
+    "accessibility-exclusive-focus": {
+      "alias": "accessibility-exclusive-focus";
+      "required": false;
+    };
+    "a11y-id": {
+      "alias": "a11y-id";
+      "required": false;
+    };
+    "user-interaction-enabled": {
+      "alias": "user-interaction-enabled";
+      "required": false;
+    };
+    "native-interaction-enabled": {
+      "alias": "native-interaction-enabled";
+      "required": false;
+    };
+    "event-through": {
+      "alias": "event-through";
+      "required": false;
+    };
+    "hit-slop": {
+      "alias": "hit-slop";
+      "required": false;
+    };
+    "block-native-event": {
+      "alias": "block-native-event";
+      "required": false;
+    };
+    "ignore-focus": {
+      "alias": "ignore-focus";
+      "required": false;
+    };
+    "ios-enable-simultaneous-touch": {
+      "alias": "ios-enable-simultaneous-touch";
+      "required": false;
+    };
+    "flatten": {
+      "alias": "flatten";
+      "required": false;
+    };
+    "pan-intercept-direction": {
+      "alias": "pan-intercept-direction";
+      "required": false;
+    };
+    "pan-intercept-scope": {
+      "alias": "pan-intercept-scope";
+      "required": false;
+    };
+    "consume-slide-event": {
+      "alias": "consume-slide-event";
+      "required": false;
+    };
+    "enable-touch-pseudo-propagation": {
+      "alias": "enable-touch-pseudo-propagation";
+      "required": false;
+    };
+    "exposure-id": {
+      "alias": "exposure-id";
+      "required": false;
+    };
+    "exposure-scene": {
+      "alias": "exposure-scene";
+      "required": false;
+    };
+    "exposure-area": {
+      "alias": "exposure-area";
+      "required": false;
+    };
+    "exposure-screen-margin-top": {
+      "alias": "exposure-screen-margin-top";
+      "required": false;
+    };
+    "exposure-screen-margin-bottom": {
+      "alias": "exposure-screen-margin-bottom";
+      "required": false;
+    };
+    "exposure-screen-margin-left": {
+      "alias": "exposure-screen-margin-left";
+      "required": false;
+    };
+    "exposure-screen-margin-right": {
+      "alias": "exposure-screen-margin-right";
+      "required": false;
+    };
+    "exposure-ui-margin-top": {
+      "alias": "exposure-ui-margin-top";
+      "required": false;
+    };
+    "exposure-ui-margin-bottom": {
+      "alias": "exposure-ui-margin-bottom";
+      "required": false;
+    };
+    "exposure-ui-margin-left": {
+      "alias": "exposure-ui-margin-left";
+      "required": false;
+    };
+    "exposure-ui-margin-right": {
+      "alias": "exposure-ui-margin-right";
+      "required": false;
+    };
+    "enable-exposure-ui-margin": {
+      "alias": "enable-exposure-ui-margin";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+  static "ngAcceptInputType_accessibility-element": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_accessibility-elements-hidden": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_accessibility-exclusive-focus": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_user-interaction-enabled": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_native-interaction-enabled": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_event-through": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_block-native-event": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_ignore-focus": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_ios-enable-simultaneous-touch": boolean | "" | "true" | "false" | undefined;
+  static ngAcceptInputType_flatten: boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_pan-intercept-direction": 0 | 1 | "0" | "1" | undefined;
+  static "ngAcceptInputType_pan-intercept-scope": 0 | 1 | 2 | 3 | 4 | 5 | "0" | "1" | "2" | "3" | "4" | "5" | undefined;
+  static "ngAcceptInputType_enable-touch-pseudo-propagation": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_enable-exposure-ui-margin": boolean | "" | "true" | "false" | undefined;
+}
+/**
+ * Backdrop blur: blurs the content rendered behind the element, like CSS
+ * `backdrop-filter: blur()`. On iOS, `blur-effect="glass"` renders the
+ * Liquid Glass material.
+ *
+ * Android only has the plain blur, a Gaussian blur of `blur-radius`. There
+ * the runtime approximates `blur-effect`, `glass-style` and
+ * `glass-tint-color` with a translucent background and rim over the blur,
+ * which a background, background image or shadow the app sets replaces.
+ * Nothing refracts, and `glass-interactive` and `spacing` do nothing.
+ */
+export declare class LynxBlurView extends LynxElementBase {
+  /**
+   * Gaussian blur radius (Android/iOS/Harmony). @default '0px'
+   */
+  'blur-radius'?: string;
+  /**
+   * Downsampling ratio of the blurred area. Higher is faster but softer (Android). @default 6
+   */
+  'blur-sampling'?: number;
+  /**
+   * Whether the blur updates automatically as content behind it changes (Android). @default true
+   */
+  'enable-auto-blur'?: boolean;
+  /**
+   * Raw id of the view to capture and blur; it must have `flatten="false"`
+   * (Android). The runtime points it at the page, so a blur-view inside
+   * another blur-view still blurs what's behind it; an empty string restores
+   * Android's own choice, the nearest ancestor that clips or contains it.
+   */
+  'android-capture-target'?: string;
+  /**
+   * Switches the internal blur-buffer refresh path (Android, experimental).
+   */
+  'experimental-update-blur-radius'?: boolean;
+  /**
+   * Blur material (iOS). `glass` renders Liquid Glass; `glass-container`
+   * merges nested glass `<blur-view>`s into one combined effect. Android
+   * gets a tint that approximates it. @default 'light'
+   */
+  'blur-effect'?: 'light' | 'extra-light' | 'dark' | 'glass' | 'glass-container';
+  /**
+   * Distance at which glass elements inside a `glass-container` start to merge (iOS). @default 0
+   */
+  spacing?: number;
+  /**
+   * Whether the glass reacts to touches (iOS). @default false
+   */
+  'glass-interactive'?: boolean;
+  /**
+   * Tint color applied to the glass (iOS; approximated on Android). @default 'transparent'
+   */
+  'glass-tint-color'?: string;
+  /**
+   * Glass variant (iOS; approximated on Android). @default 'regular'
+   */
+  'glass-style'?: 'regular' | 'clear';
+  /**
+   * Forces a light or dark appearance for the material (iOS, Lynx 4.1+).
+   */
+  'ios-user-interface-style'?: 'dark' | 'light';
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxBlurView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxBlurView, "blur-view", never, {
+    "blur-radius": {
+      "alias": "blur-radius";
+      "required": false;
+    };
+    "blur-sampling": {
+      "alias": "blur-sampling";
+      "required": false;
+    };
+    "enable-auto-blur": {
+      "alias": "enable-auto-blur";
+      "required": false;
+    };
+    "android-capture-target": {
+      "alias": "android-capture-target";
+      "required": false;
+    };
+    "experimental-update-blur-radius": {
+      "alias": "experimental-update-blur-radius";
+      "required": false;
+    };
+    "blur-effect": {
+      "alias": "blur-effect";
+      "required": false;
+    };
+    "spacing": {
+      "alias": "spacing";
+      "required": false;
+    };
+    "glass-interactive": {
+      "alias": "glass-interactive";
+      "required": false;
+    };
+    "glass-tint-color": {
+      "alias": "glass-tint-color";
+      "required": false;
+    };
+    "glass-style": {
+      "alias": "glass-style";
+      "required": false;
+    };
+    "ios-user-interface-style": {
+      "alias": "ios-user-interface-style";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Renders its children above embedded native views such as `<webview>`
+ * (Clay Windows/macOS only). Has no element-specific attributes.
+ */
+export declare class LynxCoverView extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxCoverView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxCoverView, "cover-view", never, {}, {}, never, never, true, never>;
+}
+/**
+ * ControlValueAccessor for <input> elements. Bridges Angular's form model
+ * (reactive forms, template-driven NgModel, Signal Forms [formField]) to Lynx's
+ * native events (bindinput, bindblur) instead of the standard DOM input/change events.
+ *
+ * Activated only when a form directive is present (formControl, formControlName,
+ * ngModel, or formField) — bare <input> elements continue to use LynxInput alone.
+ */
+export declare class LynxInputValueAccessor implements ControlValueAccessor {
+  #private;
+  onInput(event: Event): void;
+  onBlur(): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxInputValueAccessor, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxInputValueAccessor, "input[formControlName],input[formControl],input[ngModel],input[formField]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * ControlValueAccessor for <textarea> elements. Bridges Angular's form model
+ * (reactive forms, template-driven NgModel, Signal Forms [formField]) to Lynx's
+ * native events (bindinput, bindblur) instead of the standard DOM input/change events.
+ *
+ * Activated only when a form directive is present (formControl, formControlName,
+ * ngModel, or formField) — bare <textarea> elements continue to use LynxTextarea alone.
+ */
+export declare class LynxTextareaValueAccessor implements ControlValueAccessor {
+  #private;
+  onInput(event: Event): void;
+  onBlur(): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTextareaValueAccessor, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxTextareaValueAccessor, "textarea[formControlName],textarea[formControl],textarea[ngModel],textarea[formField]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Both Lynx form value accessors as a single importable array.
+ */
+export declare const LYNX_FORM_ACCESSORS: readonly [typeof LynxInputValueAccessor, typeof LynxTextareaValueAccessor];
+/**
+ * Embeds a separate Lynx bundle as a nested page.
+ */
+export declare class LynxFrame extends LynxElementBase {
+  /**
+   * URL of the `.lynx.bundle` file to embed.
+   */
+  src?: string;
+  /**
+   * Initial data passed into the embedded page.
+   */
+  data?: Record<string, unknown>;
+  /**
+   * Global props forwarded to the embedded page's global scope.
+   */
+  'global-props'?: Record<string, unknown>;
+  /**
+   * Size the frame to match its content width.
+   */
+  'auto-width'?: boolean;
+  /**
+   * Size the frame to match its content height.
+   */
+  'auto-height'?: boolean;
+  /**
+   * Width used before the embedded page reports its content size (e.g. `'200px'`).
+   */
+  'preset-width'?: string;
+  /**
+   * Height used before the embedded page reports its content size (e.g. `'200px'`).
+   */
+  'preset-height'?: string;
+  /**
+   * Override the host's multi-async-thread setting for the embedded page.
+   */
+  'enable-multi-async-thread'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxFrame, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxFrame, "frame", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+    };
+    "data": {
+      "alias": "data";
+      "required": false;
+    };
+    "global-props": {
+      "alias": "global-props";
+      "required": false;
+    };
+    "auto-width": {
+      "alias": "auto-width";
+      "required": false;
+    };
+    "auto-height": {
+      "alias": "auto-height";
+      "required": false;
+    };
+    "preset-width": {
+      "alias": "preset-width";
+      "required": false;
+    };
+    "preset-height": {
+      "alias": "preset-height";
+      "required": false;
+    };
+    "enable-multi-async-thread": {
+      "alias": "enable-multi-async-thread";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Displays raster images, base64 data URIs, and animated GIFs.
+ */
+export declare class LynxImage extends LynxElementBase {
+  /**
+   * Remote URL, local asset path, or base64 data URI.
+   */
+  src?: string;
+  /**
+   * How the image is scaled to fit its container.
+   * @default 'scaleToFill'
+   */
+  mode?: 'scaleToFill' | 'aspectFit' | 'aspectFill' | 'center';
+  /**
+   * Placeholder image shown while the main image loads.
+   */
+  placeholder?: string;
+  /**
+   * Gaussian blur radius applied to the image.
+   */
+  'blur-radius'?: string;
+  /**
+   * Nine-slice cap insets for stretching images (CSS shorthand, e.g. "10px 10px 10px 10px").
+   */
+  'cap-insets'?: string;
+  'cap-insets-scale'?: number;
+  /**
+   * Automatically size the element to the image's intrinsic dimensions.
+   */
+  'auto-size'?: boolean;
+  /**
+   * Auto-play for animated GIF images.
+   */
+  autoplay?: boolean;
+  /**
+   * Number of times to loop the animation (0 = infinite).
+   */
+  'loop-count'?: number;
+  /**
+   * Tint color applied over the image (CSS color string).
+   */
+  'tint-color'?: string;
+  /**
+   * Bitmap color format hint (Android).
+   */
+  'image-config'?: 'ARGB_8888' | 'RGB_565';
+  /**
+   * Pre-declared width for prefetch optimization.
+   */
+  'prefetch-width'?: string;
+  'prefetch-height'?: string;
+  /**
+   * Keep showing the current image while the new src loads.
+   */
+  'defer-src-invalidation'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxImage, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxImage, "image", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+    };
+    "blur-radius": {
+      "alias": "blur-radius";
+      "required": false;
+    };
+    "cap-insets": {
+      "alias": "cap-insets";
+      "required": false;
+    };
+    "cap-insets-scale": {
+      "alias": "cap-insets-scale";
+      "required": false;
+    };
+    "auto-size": {
+      "alias": "auto-size";
+      "required": false;
+    };
+    "autoplay": {
+      "alias": "autoplay";
+      "required": false;
+    };
+    "loop-count": {
+      "alias": "loop-count";
+      "required": false;
+    };
+    "tint-color": {
+      "alias": "tint-color";
+      "required": false;
+    };
+    "image-config": {
+      "alias": "image-config";
+      "required": false;
+    };
+    "prefetch-width": {
+      "alias": "prefetch-width";
+      "required": false;
+    };
+    "prefetch-height": {
+      "alias": "prefetch-height";
+      "required": false;
+    };
+    "defer-src-invalidation": {
+      "alias": "defer-src-invalidation";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Single-line text input field.
+ */
+export declare class LynxInput extends LynxElementBase {
+  #private;
+  ngOnChanges(changes: SimpleChanges): void;
+  /**
+   * Keyboard type shown when this input gains focus.
+   */
+  type?: 'text' | 'number' | 'digit' | 'password' | 'tel' | 'email';
+  /**
+   * Greyed-out hint text shown when the field is empty.
+   */
+  placeholder?: string;
+  /**
+   * Current value of the field.
+   */
+  value?: string;
+  /**
+   * Maximum character count (-1 = unlimited).
+   */
+  maxlength?: number;
+  /**
+   * Whether the field is read-only.
+   */
+  readonly?: boolean;
+  /**
+   * Whether the field and keyboard are disabled.
+   */
+  disabled?: boolean;
+  /**
+   * Label for the soft-keyboard confirm button. @default 'done'
+   */
+  'confirm-type'?: 'search' | 'send' | 'go' | 'done' | 'next';
+  /**
+   * Input character whitelist — a regular expression pattern string.
+   */
+  'input-filter'?: string;
+  /**
+   * Whether tapping the field shows the soft keyboard. @default true
+   */
+  'show-soft-input-on-focus'?: boolean;
+  /**
+   * Enable auto-correction on iOS.
+   */
+  'ios-auto-correct'?: boolean;
+  /**
+   * Enable spell-checking on iOS.
+   */
+  'ios-spell-check'?: boolean;
+  /**
+   * Enter full-screen editing mode on Android.
+   */
+  'android-fullscreen-mode'?: boolean;
+  /**
+   * Initial content. Applied on first render only and doesn't fire `bindinput`.
+   * Prefer `value` (or a form control) when the text must stay in sync.
+   */
+  'default-value'?: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxInput, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxInput, "input", never, {
+    "type": {
+      "alias": "type";
+      "required": false;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+    };
+    "maxlength": {
+      "alias": "maxlength";
+      "required": false;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+    };
+    "confirm-type": {
+      "alias": "confirm-type";
+      "required": false;
+    };
+    "input-filter": {
+      "alias": "input-filter";
+      "required": false;
+    };
+    "show-soft-input-on-focus": {
+      "alias": "show-soft-input-on-focus";
+      "required": false;
+    };
+    "ios-auto-correct": {
+      "alias": "ios-auto-correct";
+      "required": false;
+    };
+    "ios-spell-check": {
+      "alias": "ios-spell-check";
+      "required": false;
+    };
+    "android-fullscreen-mode": {
+      "alias": "android-fullscreen-mode";
+      "required": false;
+    };
+    "default-value": {
+      "alias": "default-value";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Multi-line text input field.
+ */
+export declare class LynxTextarea extends LynxElementBase {
+  #private;
+  ngOnChanges(changes: SimpleChanges): void;
+  type?: 'text' | 'number' | 'digit' | 'tel' | 'email';
+  placeholder?: string;
+  value?: string;
+  maxlength?: number;
+  /**
+   * Maximum number of visible lines.
+   */
+  maxlines?: number;
+  /**
+   * Extra spacing between lines in px.
+   */
+  'line-spacing'?: number;
+  readonly?: boolean;
+  disabled?: boolean;
+  'confirm-type'?: 'search' | 'send' | 'go' | 'done' | 'next';
+  'input-filter'?: string;
+  'show-soft-input-on-focus'?: boolean;
+  bounces?: boolean;
+  'enable-scroll-bar'?: boolean;
+  'ios-auto-correct'?: boolean;
+  'ios-spell-check'?: boolean;
+  'android-fullscreen-mode'?: boolean;
+  /**
+   * Initial content. Applied on first render only and doesn't fire `bindinput`.
+   * Prefer `value` (or a form control) when the text must stay in sync.
+   */
+  'default-value'?: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTextarea, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxTextarea, "textarea", never, {
+    "type": {
+      "alias": "type";
+      "required": false;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+    };
+    "maxlength": {
+      "alias": "maxlength";
+      "required": false;
+    };
+    "maxlines": {
+      "alias": "maxlines";
+      "required": false;
+    };
+    "line-spacing": {
+      "alias": "line-spacing";
+      "required": false;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+    };
+    "confirm-type": {
+      "alias": "confirm-type";
+      "required": false;
+    };
+    "input-filter": {
+      "alias": "input-filter";
+      "required": false;
+    };
+    "show-soft-input-on-focus": {
+      "alias": "show-soft-input-on-focus";
+      "required": false;
+    };
+    "bounces": {
+      "alias": "bounces";
+      "required": false;
+    };
+    "enable-scroll-bar": {
+      "alias": "enable-scroll-bar";
+      "required": false;
+    };
+    "ios-auto-correct": {
+      "alias": "ios-auto-correct";
+      "required": false;
+    };
+    "ios-spell-check": {
+      "alias": "ios-spell-check";
+      "required": false;
+    };
+    "android-fullscreen-mode": {
+      "alias": "android-fullscreen-mode";
+      "required": false;
+    };
+    "default-value": {
+      "alias": "default-value";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * High-performance virtualized list, equivalent to RecyclerView / UITableView.
+ *
+ * Gaps between items aren't attributes: `list-main-axis-gap` and
+ * `list-cross-axis-gap` are CSS properties, which Lynx's list reads from its
+ * computed style, so set them in `style` (`[style.list-main-axis-gap]`).
+ */
+export declare class LynxList extends LynxElementBase {
+  /**
+   * Layout algorithm.
+   * - `'single'`    — one item per row/column
+   * - `'flow'`      — fixed column count, items fill left-to-right
+   * - `'waterfall'` — Pinterest-style varying-height columns
+   */
+  'list-type'?: 'single' | 'flow' | 'waterfall';
+  /**
+   * Number of columns (flow/waterfall) or rows (horizontal single).
+   */
+  'span-count'?: number;
+  /**
+   * Scroll axis. @default 'vertical'
+   */
+  'scroll-orientation'?: 'vertical' | 'horizontal';
+  'enable-scroll'?: boolean;
+  'enable-nested-scroll'?: boolean;
+  bounces?: boolean;
+  sticky?: boolean;
+  /**
+   * Offset in px for sticky items.
+   */
+  'sticky-offset'?: number;
+  'scroll-bar-enable'?: boolean;
+  /**
+   * Scroll to this item index on first render.
+   */
+  'initial-scroll-index'?: number;
+  /**
+   * Number of items from the top that triggers bindscrolltoupper.
+   */
+  'upper-threshold-item-count'?: number;
+  /**
+   * Number of items from the bottom that triggers bindscrolltolower.
+   */
+  'lower-threshold-item-count'?: number;
+  /**
+   * Minimum interval in ms between scroll events.
+   */
+  'scroll-event-throttle'?: number;
+  /**
+   * Include visible item info in scroll event payloads.
+   */
+  'need-visible-item-info'?: boolean;
+  /**
+   * Include layout completion info in events.
+   */
+  'need-layout-complete-info'?: boolean;
+  /**
+   * Number of items to preload beyond the visible area.
+   */
+  'preload-buffer-count'?: number;
+  /**
+   * Snap behavior: `{ factor: 0–1, offset: px }`.
+   */
+  'item-snap'?: {
+    factor: number;
+    offset: number;
+  };
+  /**
+   * Insert/remove animation style.
+   */
+  'update-animation'?: 'default' | 'none';
+  /**
+   * Required by Lynx's native list UI whenever the app uses the standard
+   * dual-thread engine strategy (always true for AngularLynx) — without it
+   * the native list silently never applies its data source, so
+   * `componentAtIndex` is never called and no items render. The renderer
+   * sets this to `true` by default at element creation; bind it explicitly
+   * only to opt back into the sync (all-on-UI) engine strategy.
+   * @default true
+   */
+  'enable-async-list'?: boolean;
+  /**
+   * Insert list-item platform views via the C++ list's operations. Recommended
+   * with multi-thread engine strategies. @default false
+   */
+  'enable-insert-platform-view-operation'?: boolean;
+  /**
+   * How the list picks a reference anchor when on-screen items are removed:
+   * 0 = none, 1 = toward start, 2 = toward end (experimental). @default 0
+   */
+  'experimental-search-ref-anchor-strategy'?: 0 | 1 | 2;
+  /**
+   * Allow scrolling when the content is smaller than the list (Harmony). @default false
+   */
+  'harmony-scroll-edge-effect'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxList, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxList, "list", never, {
+    "list-type": {
+      "alias": "list-type";
+      "required": false;
+    };
+    "span-count": {
+      "alias": "span-count";
+      "required": false;
+    };
+    "scroll-orientation": {
+      "alias": "scroll-orientation";
+      "required": false;
+    };
+    "enable-scroll": {
+      "alias": "enable-scroll";
+      "required": false;
+    };
+    "enable-nested-scroll": {
+      "alias": "enable-nested-scroll";
+      "required": false;
+    };
+    "bounces": {
+      "alias": "bounces";
+      "required": false;
+    };
+    "sticky": {
+      "alias": "sticky";
+      "required": false;
+    };
+    "sticky-offset": {
+      "alias": "sticky-offset";
+      "required": false;
+    };
+    "scroll-bar-enable": {
+      "alias": "scroll-bar-enable";
+      "required": false;
+    };
+    "initial-scroll-index": {
+      "alias": "initial-scroll-index";
+      "required": false;
+    };
+    "upper-threshold-item-count": {
+      "alias": "upper-threshold-item-count";
+      "required": false;
+    };
+    "lower-threshold-item-count": {
+      "alias": "lower-threshold-item-count";
+      "required": false;
+    };
+    "scroll-event-throttle": {
+      "alias": "scroll-event-throttle";
+      "required": false;
+    };
+    "need-visible-item-info": {
+      "alias": "need-visible-item-info";
+      "required": false;
+    };
+    "need-layout-complete-info": {
+      "alias": "need-layout-complete-info";
+      "required": false;
+    };
+    "preload-buffer-count": {
+      "alias": "preload-buffer-count";
+      "required": false;
+    };
+    "item-snap": {
+      "alias": "item-snap";
+      "required": false;
+    };
+    "update-animation": {
+      "alias": "update-animation";
+      "required": false;
+    };
+    "enable-async-list": {
+      "alias": "enable-async-list";
+      "required": false;
+    };
+    "enable-insert-platform-view-operation": {
+      "alias": "enable-insert-platform-view-operation";
+      "required": false;
+    };
+    "experimental-search-ref-anchor-strategy": {
+      "alias": "experimental-search-ref-anchor-strategy";
+      "required": false;
+    };
+    "harmony-scroll-edge-effect": {
+      "alias": "harmony-scroll-edge-effect";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Child of `<list>`; represents a single virtualized cell.
+ */
+export declare class LynxListItem extends LynxElementBase {
+  /**
+   * Stable unique key for this item — used for diffing and recycling.
+   * Must be unique within the list.
+   */
+  'item-key'?: string;
+  /**
+   * Whether this item spans all columns (full-width in flow/waterfall).
+   */
+  'full-span'?: boolean;
+  /**
+   * Stick this item to the top of the list while scrolling.
+   */
+  'sticky-top'?: boolean;
+  /**
+   * Stick this item to the bottom of the list while scrolling.
+   */
+  'sticky-bottom'?: boolean;
+  /**
+   * Whether this item's view can be recycled. @default true
+   */
+  recyclable?: boolean;
+  /**
+   * Reuse pool identifier — items with the same identifier share views.
+   */
+  'reuse-identifier'?: string;
+  /**
+   * Estimated item size in px for layout pre-calculation.
+   */
+  'estimated-main-axis-size-px'?: number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxListItem, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxListItem, "list-item", never, {
+    "item-key": {
+      "alias": "item-key";
+      "required": false;
+    };
+    "full-span": {
+      "alias": "full-span";
+      "required": false;
+    };
+    "sticky-top": {
+      "alias": "sticky-top";
+      "required": false;
+    };
+    "sticky-bottom": {
+      "alias": "sticky-bottom";
+      "required": false;
+    };
+    "recyclable": {
+      "alias": "recyclable";
+      "required": false;
+    };
+    "reuse-identifier": {
+      "alias": "reuse-identifier";
+      "required": false;
+    };
+    "estimated-main-axis-size-px": {
+      "alias": "estimated-main-axis-size-px";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Anonymous grouping element with no visual output.
+ */
+export declare class LynxBlock extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxBlock, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxBlock, "block", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Lynx native conditional element.
+ * Note: Angular's `@if` control flow is a separate, unrelated construct.
+ */
+export declare class LynxIf extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxIf, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxIf, "if", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Lynx native iteration element.
+ * Note: Angular's `@for` control flow is a separate, unrelated construct.
+ */
+export declare class LynxFor extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxFor, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxFor, "for", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Floating layer rendered above the main document flow.
+ */
+export declare class LynxOverlay extends LynxElementBase {
+  /**
+   * Whether the overlay is shown.
+   */
+  visible?: boolean;
+  /**
+   * The layer the overlay sits in when several are open: 1 is the top layer
+   * and 4 the lowest. Within a layer the last one shown is on top. Lynx reads
+   * it only while the overlay is hidden. @default 1
+   */
+  level?: 1 | 2 | 3 | 4;
+  /**
+   * Presentation mode on iOS (`'window'` | `'top'` | `'page'`).
+   */
+  mode?: string;
+  /**
+   * Whether the iOS swipe-back gesture dismisses the overlay.
+   */
+  'ios-enable-swipe-back'?: boolean;
+  /**
+   * Android navigation bar background/appearance while the overlay is shown.
+   * `transparent` also requires `android-adapt-edge-to-edge`. (Lynx 4.1+) @default 'auto'
+   */
+  'android-navigation-bar-style'?: 'auto' | 'light' | 'dark' | 'transparent';
+  /**
+   * Limit the overlay to the Fragment that owns its LynxView (Android, Lynx 4.3+). @default 'global'
+   */
+  'android-overlay-scope'?: 'global' | 'fragment';
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxOverlay, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxOverlay, "overlay", never, {
+    "visible": {
+      "alias": "visible";
+      "required": false;
+    };
+    "level": {
+      "alias": "level";
+      "required": false;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+    };
+    "ios-enable-swipe-back": {
+      "alias": "ios-enable-swipe-back";
+      "required": false;
+    };
+    "android-navigation-bar-style": {
+      "alias": "android-navigation-bar-style";
+      "required": false;
+    };
+    "android-overlay-scope": {
+      "alias": "android-overlay-scope";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Pull-to-refresh container. Accepts `<refresh-header>` and a scrollable `<view>` as direct children.
+ */
+export declare class LynxRefresh extends LynxElementBase {
+  /**
+   * Whether dragging down or calling autoStartRefresh can trigger the startrefresh event. @default true
+   */
+  'enable-refresh'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxRefresh, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxRefresh, "refresh", never, {
+    "enable-refresh": {
+      "alias": "enable-refresh";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Customizable header revealed during a pull-to-refresh gesture. Must be a direct child of `<refresh>`.
+ */
+export declare class LynxRefreshHeader extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxRefreshHeader, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxRefreshHeader, "refresh-header", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Nested scroll coordination container. Synchronizes a foldable header, sticky toolbar, and scrollable content slot.
+ */
+export declare class LynxScrollCoordinator extends LynxElementBase {
+  /**
+   * Whether the coordinator can scroll vertically. @default true
+   */
+  'enable-scroll'?: boolean;
+  /**
+   * Enable bounce effect when scrolling past boundary (iOS/Harmony). @default true
+   */
+  bounces?: boolean;
+  /**
+   * Event response granularity for bindoffset. @default 0.01
+   */
+  granularity?: number;
+  /**
+   * Whether header appears over slot when overflowing. @default false
+   */
+  'header-over-slot'?: boolean;
+  /**
+   * Refresh mode: 'none', 'page', or 'fold' (iOS). @default 'none'
+   */
+  'refresh-mode'?: 'none' | 'page' | 'fold';
+  /**
+   * Show scrollbar during scrolling (iOS/Harmony). @default false
+   */
+  'enable-scroll-bar'?: boolean;
+  /**
+   * Enable nested scroll as child in other scrolling widgets (Android). @default false
+   */
+  'android-nested-scroll-as-child'?: boolean;
+  /**
+   * Force nested-vertical-scroll-behavior invalid (iOS). @default false
+   */
+  'ios-force-scroll-detach'?: boolean;
+  /**
+   * Scroll to top when tapping status bar (iOS). @default false
+   */
+  'ios-scrolls-to-top'?: boolean;
+  /**
+   * Adjust the offset when the active slot is empty or too short to scroll (Android). @default false
+   */
+  'android-adapt-to-empty-slot'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxScrollCoordinator, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxScrollCoordinator, "scroll-coordinator", never, {
+    "enable-scroll": {
+      "alias": "enable-scroll";
+      "required": false;
+    };
+    "bounces": {
+      "alias": "bounces";
+      "required": false;
+    };
+    "granularity": {
+      "alias": "granularity";
+      "required": false;
+    };
+    "header-over-slot": {
+      "alias": "header-over-slot";
+      "required": false;
+    };
+    "refresh-mode": {
+      "alias": "refresh-mode";
+      "required": false;
+    };
+    "enable-scroll-bar": {
+      "alias": "enable-scroll-bar";
+      "required": false;
+    };
+    "android-nested-scroll-as-child": {
+      "alias": "android-nested-scroll-as-child";
+      "required": false;
+    };
+    "ios-force-scroll-detach": {
+      "alias": "ios-force-scroll-detach";
+      "required": false;
+    };
+    "ios-scrolls-to-top": {
+      "alias": "ios-scrolls-to-top";
+      "required": false;
+    };
+    "android-adapt-to-empty-slot": {
+      "alias": "android-adapt-to-empty-slot";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Header content that scrolls out of view. Must be a direct child of `<scroll-coordinator>`.
+ */
+export declare class LynxScrollCoordinatorHeader extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxScrollCoordinatorHeader, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxScrollCoordinatorHeader, "scroll-coordinator-header", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Sticky toolbar that remains visible at the top. Must be a direct child of `<scroll-coordinator>`.
+ */
+export declare class LynxScrollCoordinatorToolbar extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxScrollCoordinatorToolbar, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxScrollCoordinatorToolbar, "scroll-coordinator-toolbar", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Container for scrollable content (typically a `<list>`). Must be a direct child of `<scroll-coordinator>`.
+ */
+export declare class LynxScrollCoordinatorSlot extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxScrollCoordinatorSlot, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxScrollCoordinatorSlot, "scroll-coordinator-slot", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot variant whose content can be dragged up/down to fold and unfold the
+ * header. Must be a direct child of `<scroll-coordinator>`.
+ */
+export declare class LynxScrollCoordinatorSlotDrag extends LynxElementBase {
+  /**
+   * Whether vertical drag gestures fold/unfold the header. @default true
+   */
+  'enable-drag'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxScrollCoordinatorSlotDrag, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxScrollCoordinatorSlotDrag, "scroll-coordinator-slot-drag", never, {
+    "enable-drag": {
+      "alias": "enable-drag";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Scrollable single-child container.
+ */
+export declare class LynxScrollView extends LynxElementBase {
+  /**
+   * Scroll axis. @default 'vertical'
+   */
+  'scroll-orientation'?: 'vertical' | 'horizontal';
+  /**
+   * Whether scrolling is enabled. @default true
+   */
+  'enable-scroll'?: boolean;
+  /**
+   * Whether the scroll view bounces past the content edge (iOS/Harmony).
+   */
+  bounces?: boolean;
+  /**
+   * Whether the platform scroll indicator is shown.
+   */
+  'scroll-bar-enable'?: boolean;
+  /**
+   * Distance from the top/left edge that triggers bindscrolltoupper.
+   */
+  'upper-threshold'?: number;
+  /**
+   * Distance from the bottom/right edge that triggers bindscrolltolower.
+   */
+  'lower-threshold'?: number;
+  /**
+   * Initial scroll offset in px.
+   */
+  'initial-scroll-offset'?: number;
+  /**
+   * Scroll to item at this index on mount.
+   */
+  'initial-scroll-to-index'?: number;
+  /**
+   * Whether nested scrolling is enabled.
+   */
+  'enable-nested-scroll'?: boolean;
+  /**
+   * Use the new overflow clipping implementation (Android, Lynx 4.2+, experimental). @default true
+   */
+  'experimental-android-enable-new-overflow'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxScrollView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxScrollView, "scroll-view", never, {
+    "scroll-orientation": {
+      "alias": "scroll-orientation";
+      "required": false;
+    };
+    "enable-scroll": {
+      "alias": "enable-scroll";
+      "required": false;
+    };
+    "bounces": {
+      "alias": "bounces";
+      "required": false;
+    };
+    "scroll-bar-enable": {
+      "alias": "scroll-bar-enable";
+      "required": false;
+    };
+    "upper-threshold": {
+      "alias": "upper-threshold";
+      "required": false;
+    };
+    "lower-threshold": {
+      "alias": "lower-threshold";
+      "required": false;
+    };
+    "initial-scroll-offset": {
+      "alias": "initial-scroll-offset";
+      "required": false;
+    };
+    "initial-scroll-to-index": {
+      "alias": "initial-scroll-to-index";
+      "required": false;
+    };
+    "enable-nested-scroll": {
+      "alias": "enable-nested-scroll";
+      "required": false;
+    };
+    "experimental-android-enable-new-overflow": {
+      "alias": "experimental-android-enable-new-overflow";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Renders SVG content from a URL or an inline XML string.
+ */
+export declare class LynxSvg extends LynxElementBase {
+  /**
+   * URL pointing to an SVG resource.
+   */
+  src?: string;
+  /**
+   * Inline SVG XML string.
+   */
+  content?: string;
+  /**
+   * Color used for `currentColor` in the SVG. Doesn't override explicit `fill`/`stroke`.
+   */
+  'current-color'?: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxSvg, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxSvg, "svg", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+    };
+    "content": {
+      "alias": "content";
+      "required": false;
+    };
+    "current-color": {
+      "alias": "current-color";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Displays text content. Supports inline child `<text>` elements for mixed styling.
+ */
+export declare class LynxText extends LynxElementBase {
+  /**
+   * Maximum number of lines the text is laid out in. The text box ends after
+   * that many lines, but the ellipsis needs `text-overflow: ellipsis`
+   * (Tailwind's `text-ellipsis`). Without it, iOS cuts the text off at the
+   * last line, and Android draws the remaining lines past the box.
+   */
+  'text-maxline'?: number;
+  /**
+   * Vertical alignment for single-line text.
+   * @default 'normal'
+   */
+  'text-single-line-vertical-align'?: 'normal' | 'top' | 'center' | 'bottom';
+  /**
+   * Whether the user can select the text.
+   */
+  'text-selection'?: boolean;
+  /**
+   * Whether a custom context menu is shown on long-press.
+   */
+  'custom-context-menu'?: boolean;
+  /**
+   * Add extra font padding on Android.
+   */
+  'include-font-padding'?: boolean;
+  'tail-color-convert'?: boolean;
+  /**
+   * Synthesize bold when the font has no bold face (Android/iOS). @default false
+   */
+  'text-fake-bold'?: boolean;
+  /**
+   * Hand selection/copy gestures to your own handlers; requires `text-selection`. @default false
+   */
+  'custom-text-selection'?: boolean;
+  /**
+   * Render emoji with the Emoji2 compatibility library (Android; the app must include it). @default false
+   */
+  'android-emoji-compat'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxText, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxText, "text", never, {
+    "text-maxline": {
+      "alias": "text-maxline";
+      "required": false;
+    };
+    "text-single-line-vertical-align": {
+      "alias": "text-single-line-vertical-align";
+      "required": false;
+    };
+    "text-selection": {
+      "alias": "text-selection";
+      "required": false;
+    };
+    "custom-context-menu": {
+      "alias": "custom-context-menu";
+      "required": false;
+    };
+    "include-font-padding": {
+      "alias": "include-font-padding";
+      "required": false;
+    };
+    "tail-color-convert": {
+      "alias": "tail-color-convert";
+      "required": false;
+    };
+    "text-fake-bold": {
+      "alias": "text-fake-bold";
+      "required": false;
+    };
+    "custom-text-selection": {
+      "alias": "custom-text-selection";
+      "required": false;
+    };
+    "android-emoji-compat": {
+      "alias": "android-emoji-compat";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Custom content shown at the end of a `<text>` in place of the ellipsis when
+ * the text is truncated by `text-maxline`. Must be a direct child of `<text>`.
+ */
+export declare class LynxInlineTruncation extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxInlineTruncation, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxInlineTruncation, "inline-truncation", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Draggable region of a custom window title bar, like CSS `app-region: drag`
+ * (Clay Windows/macOS only).
+ */
+export declare class LynxTitleBarView extends LynxElementBase {
+  /**
+   * Whether dragging this region moves the window. @default false
+   */
+  moveable?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTitleBarView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxTitleBarView, "title-bar-view", never, {
+    "moveable": {
+      "alias": "moveable";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Native video player (experimental, Lynx 4.1+). Control playback with the
+ * `play` / `pause` / `stop` / `seek` UI methods via SelectorQuery.
+ */
+export declare class LynxVideo extends LynxElementBase {
+  /**
+   * Video URL. Only online network URLs are supported.
+   */
+  src?: string;
+  /**
+   * Whether playback loops. @default false
+   */
+  loop?: boolean;
+  /**
+   * Playback volume from 0 to 1. @default 1
+   */
+  volume?: number;
+  /**
+   * Whether audio is muted. @default false
+   */
+  muted?: boolean;
+  /**
+   * Playback rate from 0.1 to 2.0. @default 1
+   */
+  speed?: number;
+  /**
+   * How the video is scaled into the element box. @default 'contain'
+   */
+  'object-fit'?: 'contain' | 'cover' | 'fill';
+  /**
+   * How queued UI method calls are executed. @default 'queue'
+   */
+  mode?: 'queue' | 'direct' | 'latest';
+  /**
+   * Minimum interval between `bindtimeupdate` events, in seconds. @default 0.33
+   */
+  'timeupdate-interval'?: number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxVideo, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxVideo, "video", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+    };
+    "loop": {
+      "alias": "loop";
+      "required": false;
+    };
+    "volume": {
+      "alias": "volume";
+      "required": false;
+    };
+    "muted": {
+      "alias": "muted";
+      "required": false;
+    };
+    "speed": {
+      "alias": "speed";
+      "required": false;
+    };
+    "object-fit": {
+      "alias": "object-fit";
+      "required": false;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+    };
+    "timeupdate-interval": {
+      "alias": "timeupdate-interval";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * General-purpose container element, equivalent to HTML `<div>`. Its
+ * attributes (`flatten`, the pan-intercept ones, …) work on every element, so
+ * they live on {@link LynxElementBase}.
+ */
+export declare class LynxView extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxView, "view", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Horizontally swipeable paging container.
+ */
+export declare class LynxViewPager extends LynxElementBase {
+  /**
+   * Page index to display on first render. @default 0
+   */
+  'initial-select-index'?: number;
+  /**
+   * Whether horizontal scroll gesture is enabled. @default true
+   */
+  'enable-scroll'?: boolean;
+  /**
+   * Whether the pager bounces past edge (iOS/Harmony/Clay). @default true
+   */
+  bounces?: boolean;
+  /**
+   * Enable bounce effect at edges on Android. @default false
+   */
+  'android-always-overscroll'?: boolean;
+  /**
+   * Block gesture pass-through to parent on Android. @default false
+   */
+  'android-force-can-scroll'?: boolean;
+  /**
+   * Allow outer container swipe at edges (iOS). @default false
+   */
+  'ios-gesture-direction'?: boolean;
+  /**
+   * Left edge exclusion zone for swipe gesture (iOS, px). @default 0
+   */
+  'ios-gesture-offset'?: number;
+  /**
+   * UIGestureRecognizer class name for simultaneous recognition (iOS).
+   */
+  'ios-recognized-gesture-class'?: string;
+  /**
+   * UIView tag for simultaneous gesture recognition (iOS). @default 0
+   */
+  'ios-recognized-view-tag'?: number;
+  /**
+   * Enable lazy load mode with early exposure. @default false
+   */
+  'keep-item-view'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxViewPager, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxViewPager, "viewpager", never, {
+    "initial-select-index": {
+      "alias": "initial-select-index";
+      "required": false;
+    };
+    "enable-scroll": {
+      "alias": "enable-scroll";
+      "required": false;
+    };
+    "bounces": {
+      "alias": "bounces";
+      "required": false;
+    };
+    "android-always-overscroll": {
+      "alias": "android-always-overscroll";
+      "required": false;
+    };
+    "android-force-can-scroll": {
+      "alias": "android-force-can-scroll";
+      "required": false;
+    };
+    "ios-gesture-direction": {
+      "alias": "ios-gesture-direction";
+      "required": false;
+    };
+    "ios-gesture-offset": {
+      "alias": "ios-gesture-offset";
+      "required": false;
+    };
+    "ios-recognized-gesture-class": {
+      "alias": "ios-recognized-gesture-class";
+      "required": false;
+    };
+    "ios-recognized-view-tag": {
+      "alias": "ios-recognized-view-tag";
+      "required": false;
+    };
+    "keep-item-view": {
+      "alias": "keep-item-view";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Single page container inside a viewpager.
+ */
+export declare class LynxViewPagerItem extends LynxElementBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxViewPagerItem, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxViewPagerItem, "viewpager-item", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Native web view that loads a URL or an inline HTML string. Use `<frame>`
+ * instead to embed another Lynx bundle.
+ */
+export declare class LynxWebView extends LynxElementBase {
+  /**
+   * URL to load. Changing it reloads the page.
+   */
+  src?: string;
+  /**
+   * Inline HTML to load. Ignored when `src` is set.
+   */
+  html?: string;
+  /**
+   * Enable the bounce effect (iOS). @default false
+   */
+  bounces?: boolean;
+  /**
+   * Show the scroll bar (iOS). @default false
+   */
+  'scroll-bar-enable'?: boolean;
+  /**
+   * Params forwarded to a custom web view implementation (Android/iOS).
+   */
+  params?: Record<string, unknown>;
+  /**
+   * Which web view implementation (injected via LynxService) to use. @default 'default'
+   */
+  'webview-type'?: string;
+  /**
+   * Allow remote debugging (Chrome DevTools / Safari Web Inspector). @default false
+   */
+  'enable-debug'?: boolean;
+  /**
+   * JavaScript executed when the document is ready (Clay desktop).
+   */
+  initjs?: string;
+  /**
+   * Cookies preset before loading (Clay).
+   */
+  cookies?: {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite: string;
+  }[];
+  /**
+   * Render off-screen (Clay). @default false
+   */
+  'use-osr'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxWebView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxWebView, "webview", never, {
+    "src": {
+      "alias": "src";
+      "required": false;
+    };
+    "html": {
+      "alias": "html";
+      "required": false;
+    };
+    "bounces": {
+      "alias": "bounces";
+      "required": false;
+    };
+    "scroll-bar-enable": {
+      "alias": "scroll-bar-enable";
+      "required": false;
+    };
+    "params": {
+      "alias": "params";
+      "required": false;
+    };
+    "webview-type": {
+      "alias": "webview-type";
+      "required": false;
+    };
+    "enable-debug": {
+      "alias": "enable-debug";
+      "required": false;
+    };
+    "initjs": {
+      "alias": "initjs";
+      "required": false;
+    };
+    "cookies": {
+      "alias": "cookies";
+      "required": false;
+    };
+    "use-osr": {
+      "alias": "use-osr";
+      "required": false;
+    };
+  }, {}, 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 class LynxLogger {
+  #private;
+  log(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxLogger, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Extensible map of custom native modules declared by the host app.
+ *
+ * App developers augment this interface to get type-safe access
+ * via {@link LynxNativeModule.getNativeModule}. Describe each module's
+ * methods as the host implements them; `getNativeModule()` turns their
+ * return values into promises (see {@link NativeModuleProxy}):
+ *
+ * ```typescript
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
+ * declare module '@blotch/angular-lynx' {
+ *   interface NativeModuleMap {
+ *     NativeLocalStorageModule: {
+ *       setStorageItem(key: string, value: string): void;
+ *       getStorageItem(key: string, callback: (value: string) => void): void;
+ *       clearStorage(): void;
+ *     };
+ *   }
+ * }
+ * ```
+ */
+interface NativeModuleMap {}
+/**
+ * A native module as {@link LynxNativeModule.getNativeModule} returns it on
+ * the main thread, where Angular runs.
+ *
+ * Native modules exist only on the background thread, so each method call is
+ * relayed there: the method returns a promise of its result (copied as JSON),
+ * and function arguments are called back on the main thread. Only methods
+ * cross; other properties of the module aren't reachable.
+ */
+type NativeModuleProxy<T> = { [K in keyof T as T[K] extends ((...args: any[]) => unknown) ? K : never]: T[K] extends ((...args: infer A) => infer R) ? (...args: A) => Promise<Awaited<R>> : never; };
+/**
+ * Wraps the Lynx native module bridge and JS module registry as an Angular injectable.
+ *
+ * **Native modules** (`NativeModules` global) let JS code call native platform
+ * functions (iOS / Android / HarmonyOS). The host app registers modules on the
+ * native side; this service provides typed access from Angular.
+ *
+ * **JS modules** (`lynx.getJSModule` / `lynx.registerModule`) share JavaScript
+ * values within a single LynxView. This is the same API used internally by
+ * `LynxInitData` and `LynxGlobalData` (via `GlobalEventEmitter`).
+ *
+ * Lynx provides both only on the background thread, while Angular runs on the
+ * main thread. So on the main thread every method goes through the background
+ * call relay (background-call.ts): calls run on the background thread, their
+ * results and callbacks come back as JSON, and a module is a proxy whose
+ * methods return promises.
+ *
+ * @usageNotes
+ * ```typescript
+ * const modules = inject(LynxNativeModule);
+ *
+ * // Call a native method (Promise-based wrapper over bridge.call)
+ * const result = await modules.call<string>('getDeviceId', {});
+ *
+ * // Listen for native events
+ * modules.on('onDeepLink', (url) => console.log(url));
+ *
+ * // Access a typed custom native module
+ * const storage = modules.getNativeModule('NativeLocalStorageModule');
+ * storage?.setStorageItem('key', 'value');
+ *
+ * // JS module sharing within the LynxView
+ * modules.registerJSModule('mySharedState', { count: 0 });
+ * const state = modules.getJSModule<{ count: number }>('mySharedState');
+ * ```
+ */
+export declare class LynxNativeModule {
+  #private;
+  /**
+   * Calls a native method via `NativeModules.bridge.call()`.
+   *
+   * The native callback API is wrapped in a Promise for ergonomic
+   * use with `async`/`await`.
+   *
+   * Resolves `undefined` when there is no bridge (web preview, tests).
+   */
+  call<T = unknown>(name: string, params?: Record<string, unknown>): Promise<T | undefined>;
+  /**
+   * Subscribes to a native event via `NativeModules.bridge.on()`. From the
+   * main thread, the callback gets the event's arguments copied as JSON.
+   *
+   * No-op when there is no bridge.
+   */
+  on(name: string, callback: (...args: unknown[]) => void): void;
+  /**
+   * Retrieves a custom native module by name from the `NativeModules` global.
+   *
+   * Augment the {@link NativeModuleMap} interface for type-safe access:
+   *
+   * ```typescript
+   * export {};
+   *
+   * declare module '@blotch/angular-lynx' {
+   *   interface NativeModuleMap {
+   *     NativeLocalStorageModule: { ... };
+   *   }
+   * }
+   *
+   * const storage = modules.getNativeModule('NativeLocalStorageModule');
+   * ```
+   *
+   * On the main thread, which can't reach native modules, it returns a proxy:
+   * each method call runs on the background thread and returns a promise of
+   * its result, and a call to a module or method the host doesn't have
+   * rejects. The return type says so: a module in {@link NativeModuleMap}
+   * comes back as a {@link NativeModuleProxy} of it, and any other name as
+   * `unknown`.
+   *
+   * Returns `undefined` outside Lynx, or on the background thread when the
+   * module is not registered.
+   */
+  getNativeModule<K extends string>(name: K): K extends keyof NativeModuleMap ? NativeModuleProxy<NativeModuleMap[K]> | undefined : unknown;
+  /**
+   * Retrieves a JS module registered within this LynxView.
+   *
+   * This wraps `lynx.getJSModule()` — the same API used internally
+   * for `GlobalEventEmitter`. On the main thread it returns a proxy, as
+   * getNativeModule() does.
+   *
+   * Returns `undefined` when `lynx` is unavailable or, on the background
+   * thread, when the module is not registered.
+   */
+  getJSModule<T = unknown>(name: string): T | undefined;
+  /**
+   * Registers a JS module for sharing within this LynxView.
+   *
+   * Other code (including native callbacks) can retrieve it via
+   * `getJSModule()` or `lynx.getJSModule()`. From the main thread, the
+   * background thread registers a copy whose methods call this module's, with
+   * their arguments copied as JSON and their return values dropped.
+   *
+   * No-op when `lynx` is unavailable.
+   */
+  registerJSModule<T extends object>(name: string, module: T): void;
+  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;
+  tagName: string;
+  /**
+   * When true, this element is the root page element and must not be
+   * re-parented (appendChild/insertBefore) or removed from the tree.
+   * Angular calls appendChild/remove as part of normal component lifecycle,
+   * but the page element is the immutable root — moving or removing it
+   * would corrupt the native element tree.
+   */
+  isRootPageElement: boolean;
+  /**
+   * Virtual tree tracking — used when parent manages children outside the
+   * native element tree (e.g., list manages children via componentAtIndex
+   * callbacks rather than __AppendElement)
+   */
+  _virtualParent: LynxElement | null;
+  _virtualPrev: LynxElement | null;
+  _virtualNext: LynxElement | null;
+  constructor(element: ElementRef);
+  /**
+   * Drops this wrapper's current native id from the registry. Called when the
+   * native ref is swapped (recreate-on-remount) for the STALE id, and by the
+   * renderer's destroyNode when Angular tears the element down, so the registry
+   * doesn't retain wrappers for dead native refs.
+   */
+  deregisterNative(): void;
+  setProperty(name: string, value: any): void;
+  /**
+   * Seeds the cached text for a raw-text element so #recreateSubtree() can
+   * rebuild it via __CreateRawText. Called by LynxDocument right after
+   * construction — raw-text bakes its text in at creation, so it never flows
+   * through a cached setter.
+   */
+  setInitialText(text: string): void;
+  setAttribute(name: string, value: any): void;
+  /**
+   * On Android, gives a blur-view the CSS variables that approximate its iOS
+   * material (see android-blur-material). LynxDocument calls it when it
+   * creates one, and setAttribute whenever an attribute it depends on changes.
+   */
+  updateBlurMaterial(): void;
+  getAttribute(name: string): string;
+  removeAttribute(name: string): void;
+  setStyle(key: string, value: unknown): void;
+  removeStyle(key: string): void;
+  setInlineStyles(inlineStyle: string): void;
+  insertBefore(newChild: LynxElement, refChild: LynxElement | null): void;
+  appendChild(newChild: LynxElement): void;
+  addClass(name: string): void;
+  addScopeClass(name: string): void;
+  /**
+   * Lynx has no __RemoveClass PAPI — we must get current classes, filter,
+   * and set back. This is O(n) per class removal but class lists on Lynx
+   * elements are typically small (1-5 classes for scope/component styling).
+   */
+  removeClass(name: string): void;
+  /**
+   * Requests removal of this element. Two removal paths:
+   * 1. Virtual parent (list) → delegate to removeVirtualChild() SYNCHRONOUSLY,
+   *    which updates the JS linked list and schedules an update-list-info diff.
+   *    Does NOT call __RemoveElement — list item removal is managed exclusively
+   *    through update-list-info's removeAction (calling both would double-remove
+   *    and crash). This is never part of an Angular move, so it is not deferred.
+   * 2. Normal parent → QUEUED and committed at the end of the change-detection
+   *    cycle (see #pendingRemovals / commitPendingRemovals). If a re-insert
+   *    follows in the same cycle it is a move and gets canceled; otherwise
+   *    #doRemove() detaches from the native tree.
+   */
+  remove(): void;
+  /**
+   * Commits every queued genuine removal. Called by `LynxRendererFactory2.end()`
+   * once per change-detection cycle, BEFORE `__FlushElementTree()`, so the
+   * `__RemoveElement` calls are committed to the main thread in the same flush as
+   * the cycle's other mutations (see #pendingRemovals for why the timing
+   * matters). Any element that was re-inserted (a move) has already removed
+   * itself from the set via #cancelPendingRemoval, so only genuine destroys
+   * remain.
+   */
+  static commitPendingRemovals(): void;
+  /**
+   * Re-derives displayed whitespace for every text touched this cycle. Each dirty
+   * node is resolved to the OUTERMOST enclosing <text>: a nested <text> is inline
+   * — it shares one inline-formatting-context with the surrounding raw-text, like
+   * an HTML <span> — so the whole subtree is trimmed as a single run of text.
+   * Called by `processPendingTextNormalization()` from `end()` /
+   * `scheduleSettleFlush`, after removals and before the flush.
+   */
+  static commitPendingTextNormalization(): void;
+  /**
+   * Returns the parent element. For list children, the virtual parent (the JS
+   * LynxListElement) is returned instead of the native parent — this maintains
+   * the illusion that list children are parented by the list even though they
+   * may not be __AppendElement'd to the native list yet (lazy append in
+   * componentAtIndex).
+   */
+  parentNode(): LynxElement | null;
+  nextSibling(): LynxElement | null;
+  querySelector(selector: string): LynxElement | null;
+  querySelectorAll(selector: string): LynxElement[];
+  /**
+   * Invokes a native UI method on this element by name.
+   *
+   * This is needed because some Lynx native elements expose behavior only
+   * through UIMethod calls and have no corresponding @LynxProp handler. The
+   * most common case is input/textarea text updates: the native
+   * LynxUIBaseInput class has no @LynxProp for "value", so __SetAttribute
+   * is a no-op for changing the displayed text after user interaction. The
+   * setValue UIMethod is the only way to programmatically update the live
+   * text.
+   *
+   * The result callback is intentionally empty. Callers that need a result
+   * (e.g. getValue, boundingClientRect) should use MainThreadElement.invoke(),
+   * which returns a Promise. This method covers fire-and-forget cases like
+   * setValue where only the side-effect matters.
+   */
+  invoke(methodName: string, params?: Record<string, unknown>): void;
+  animate(keyframes: Record<string, string | number>[], options?: number | LynxAnimationOptions): LynxAnimation;
+  /**
+   * 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.
+   */
+  addEventListener(name: string, cb: (event: any) => any): () => void;
+}
+/**
+ * Commits all queued genuine element removals — a free-function wrapper over
+ * `LynxElement.commitPendingRemovals()` so `LynxRendererFactory2.end()` can
+ * drain them (via the lynx-element barrel) right before `__FlushElementTree()`,
+ * keeping removals in the same flush as the cycle's other mutations.
+ */
+declare const processPendingRemovals: () => void;
+/**
+ * Re-derives positional edge whitespace for every text touched this cycle — a
+ * free-function wrapper over `LynxElement.commitPendingTextNormalization()` so
+ * `LynxRendererFactory2.end()` can drain it (via the lynx-element barrel) right
+ * after removals and before `__FlushElementTree()`, keeping the corrected text in
+ * the same flush as the cycle's other mutations. See #pendingTextNormalization.
+ */
+declare const processPendingTextNormalization: () => void;
+/**
+ * Safety-net flush for native mutations made OUTSIDE a begin()/end() change-
+ * detection cycle. `LynxRendererFactory2.end()` calls `__FlushElementTree()`
+ * once per CD tick, which is what commits (lays out + paints) the cycle's
+ * element mutations. But a lazy-loaded route component is instantiated by
+ * `RouterOutlet` DURING navigation — outside any such cycle — so its freshly
+ * created elements land in the fiber tree yet are never flushed. On-device
+ * symptom: the route's static shell renders, but its `@if`/`@for`/interpolation
+ * content stays invisible until an unrelated CD (e.g. a tap) triggers the next
+ * end() flush. (Bootstrap sidesteps this via native's implicit post-renderPage
+ * flush.) This mirrors the `<list>` path's own guard for the exact same case —
+ * see `LynxListElement.#scheduleUpdate`.
+ *
+ * Called from `LynxDocument`'s element creators, which only run on the main
+ * thread (Angular doesn't run on the background thread), so no thread guard is
+ * needed here. It schedules ONE
+ * coalesced microtask (matching the list guard's `queueMicrotask`, not
+ * `setTimeout` — flushing from a macrotask crashes the native engine), and is a
+ * no-op while:
+ *  - inside a CD cycle — end() will flush;
+ *  - the first render is pending — native flushes after renderPage, and any
+ *    `<list>` defers its own first flush (see isFirstRenderPending()).
+ * The near-no-op cost when nothing is layout-dirty (the core's `need_layout_`
+ * gate) keeps the steady-state overhead negligible.
+ */
+declare const scheduleSettleFlush: () => void;
+/**
+ * Process all pending list updates. Called from LynxRendererFactory2.end()
+ * before __FlushElementTree() so list updates are flushed as part of the
+ * normal Angular CD cycle — never from setTimeout (which crashes native).
+ */
+declare const processPendingListUpdates: () => void;
+declare class LynxListElement extends LynxElement {
+  #private;
+  /**
+   * Store the list callbacks so _processUpdate() can re-register them via
+   * __UpdateListCallbacks on every update. React Lynx does this on every
+   * flush (see listUpdateInfo.ts) — the native engine (unlike the web
+   * polyfill) does not invoke componentAtIndex for a fresh update-list-info
+   * unless the callbacks are re-registered alongside it. Without this,
+   * update-list-info is accepted with no crash but componentAtIndex is
+   * silently never called and the list stays blank.
+   */
+  setCallbacks(componentAtIndex: (...args: any[]) => number | undefined, enqueueComponent: (...args: any[]) => void, componentAtIndexes: (...args: any[]) => void): void;
+  remove(): void;
+  appendChild(newChild: LynxElement): void;
+  insertBefore(newChild: LynxElement, refChild: LynxElement | null): void;
+  removeVirtualChild(child: LynxElement): void;
+  /**
+   * Returns ElementRefs of real UI children, excluding NoneElement comment
+   * markers — the invisible <view>s LynxDocument.createComment() creates as
+   * Angular's @for/@if insertion anchors, each tagged tagName === 'comment'.
+   *
+   * Filters on the wrapper's `tagName` (a plain JS string on the LynxElement
+   * object), NOT a WeakSet keyed by the native ElementRef. This is the fix for
+   * the crash-to-home-screen on every list add/remove. The previous
+   * implementation did `#nonElements.has(child.element)`, and hashing a
+   * native-backed element ref in a WeakSet/Map/Set on the main-thread Lepus
+   * context aborts the process — js_map_has → map_find_record → js_strict_eq2
+   * → __JS_FreeValueRT (a QuickJS refcount assertion). _processUpdate() calls
+   * this on every list update, so it detonated as soon as items changed.
+   * (The initial render happened to survive it — the abort is refcount-timing
+   * sensitive — which is why it looked fine until the first mutation.) Reading
+   * a string property off the JS wrapper touches no FFI object and no Map/Set,
+   * so it can never trip it. See create-list-element.ts's componentAtIndex doc
+   * for the general "never key a Set/Map on an element ref" constraint.
+   */
+  getUIChildren(): ElementRef[];
+  /**
+   * The UI children list as of the last _processUpdate() call, pre-filtered
+   * and cached — for componentAtIndex/componentAtIndexes (create-list-element.ts)
+   * to read via plain array indexing. See their call sites' doc comments:
+   * native invokes them synchronously, reentrantly, from deep inside its own
+   * list layout pass, and calling ANY WeakSet/Map method (even a single
+   * `.has()`) from within that reentrant call was observed to crash the
+   * Lepus QuickJS context with a refcounting assertion inside
+   * __JS_FreeValueRT, every time, regardless of how shallow the surrounding
+   * call stack is (confirmed via a genuinely fresh setTimeout-scheduled
+   * invocation that still crashed identically) — so getUIChildren() (which
+   * calls WeakSet.has() per child) must never run from that call path.
+   */
+  getCommittedUIChildren(): ElementRef[];
+  /**
+   * Appended-state is tracked as a plain property directly on the ElementRef
+   * rather than a WeakSet, for the same reason as getCommittedUIChildren():
+   * these are called from componentAtIndex, where WeakSet/Map methods crash.
+   * A plain property get/set compiles to ordinary field access, not a call
+   * into QuickJS's Map/Set native implementation.
+   */
+  isAppendedToNativeList(child: ElementRef): boolean;
+  markAppendedToNativeList(child: ElementRef): void;
+  /**
+   * Compute a diff against the last committed children and send update-list-info.
+   * Called from processPendingListUpdates() — NOT directly.
+   * __FlushElementTree() is called afterwards by the renderer factory.
+   *
+   * Positions in insertAction are indices in the NEW child array.
+   * Positions in removeAction are indices in the OLD (committed) child array.
+   * This matches the React Lynx ListUpdateInfoRecording format.
+   */
+  _processUpdate(): void;
+}
+/**
+ * Configuration for creating a portal overlay.
+ */
+type PortalConfig = {
+  /**
+   * The overlay's layer, from 1 (the top) to 4 (the lowest), as on
+   * `<overlay>`. Lynx's default is 1.
+   */
+  level?: 1 | 2 | 3 | 4;
+  /**
+   * Custom injector for the component's dependency injection context.
+   */
+  injector?: EnvironmentInjector;
+  /**
+   * Initial input values to set on the component after creation.
+   */
+  inputs?: Record<string, unknown>;
+};
+/**
+ * Handle for managing a portal instance created by {@link LynxPortal}.
+ *
+ * Call {@link destroy} to tear down the overlay and its content.
+ */
+export declare class PortalRef<T> {
+  #private;
+  /**
+   * @internal
+   */
+  constructor(overlay: BaseLynxElement, appRef: ApplicationRef, componentRef: ComponentRef<T> | null, viewRef: EmbeddedViewRef<unknown> | null);
+  /**
+   * The component instance. `null` for template portals.
+   */
+  get instance(): T | null;
+  /**
+   * Sets a component input. Only works for component portals.
+   */
+  setInput(name: string, value: unknown): void;
+  /**
+   * Tears down the portal: destroys the component/template view,
+   * detaches from change detection, and removes the native overlay element.
+   */
+  destroy(): void;
+}
+/**
+ * Programmatically renders Angular components or templates inside a native
+ * Lynx `<overlay>` element — the equivalent of Angular CDK's
+ * `Overlay` / `DomPortalOutlet`.
+ *
+ * For **declarative** overlays, use `<overlay>` directly in your template.
+ * This service is for **imperative** cases: modal dialogs, toast notifications,
+ * or any content that needs to be created from code rather than a template.
+ *
+ * @usageNotes
+ * ```typescript
+ * const portal = inject(LynxPortal);
+ *
+ * // Open a component in an overlay
+ * const ref = portal.open(ConfirmDialogComponent, {
+ *   level: 2,
+ *   inputs: { title: 'Delete item?' },
+ * });
+ *
+ * // Update inputs later
+ * ref.setInput('title', 'Are you sure?');
+ *
+ * // Tear down when done
+ * ref.destroy();
+ *
+ * // Open a template in an overlay
+ * const tplRef = portal.openTemplate(myTemplateRef, { level: 1 });
+ * tplRef.destroy();
+ * ```
+ */
+export declare class LynxPortal {
+  #private;
+  /**
+   * Creates a native `<overlay>` and renders the given component into it.
+   *
+   * The component participates in Angular change detection and is fully
+   * functional (inputs, outputs, dependency injection, lifecycle hooks).
+   */
+  open<T>(component: Type<T>, config?: PortalConfig): PortalRef<T>;
+  /**
+   *   * Creates a native `<overlay>` and renders the given template into it.
+   *   *
+   *   * Use this when you have a `TemplateRef` (from `@ViewChild` or a
+   *   * template variable) rather than a component class.
+   * v8 ignore start -- reaching this path requires a real Angular component render that produces a live TemplateRef; the mocked LYNX_DOCUMENT in the spec doesn't drive one, and viewChild.required doesn't resolve without an appRef flush. Coverage is provided by the on-device examples that use openTemplate.
+   */
+  openTemplate<C>(template: TemplateRef<C>, config?: PortalConfig & {
+    context?: C;
+  }): PortalRef<null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxPortal, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Type definition for main-thread function handles used by {@link mainThreadFn}.
+ */
+type MainThreadFnHandle<TArgs extends unknown[] = unknown[], TReturn = unknown> = {
+  readonly _wkltId: string;
+  readonly _workletType: 'main-thread';
+  readonly __isMainThreadFn: true;
+  readonly __args?: TArgs;
+  readonly __return?: TReturn;
+};
+export declare const mainThreadFn: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn) => MainThreadFnHandle<TArgs, TReturn>;
+/**
+ * Type definition for background function handles used by {@link backgroundFn}.
+ */
+type BackgroundFnHandle<TArgs extends unknown[] = unknown[], TReturn = unknown> = {
+  readonly _wkltId: string;
+  readonly _workletType: 'background';
+  readonly __isBackgroundFn: true;
+  readonly __args?: TArgs;
+  readonly __return?: TReturn;
+};
+/**
+ * Registers `fn` on the background thread and returns a handle that
+ * `runOnBackground()` calls it with from the main thread.
+ *
+ * @param fn - The function to run on the background thread.
+ * @param id - Set by the build for a module-level call, so the handle has the
+ *   same ID on both threads. Don't pass it yourself.
+ * @returns The handle.
+ */
+export declare const backgroundFn: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, id?: string) => BackgroundFnHandle<TArgs, TReturn>;
+export declare class MainThreadRef<T> {
+  #private;
+  readonly _wvid: number | string;
+  /**
+   * @param initValue - The ref's starting value.
+   * @param id - Set by the build for a ref created at module level, so the
+   *   ref has the same ID on both threads. Don't pass it yourself.
+   */
+  constructor(initValue: T, id?: string);
+  get current(): T;
+  set current(value: T);
+  /**
+   * Serialization hook for cross-thread transfer. JSON.stringify calls this
+   * when the ref is passed as a param to dispatchEvent (MTS/background RPC).
+   * The receiving thread resolves { _wvid } back to its own registered
+   * MainThreadRef instance.
+   */
+  toJSON(): {
+    _wvid: number | string;
+  };
+}
+/**
+ * Creates a {@link MainThreadRef}.
+ *
+ * @param initValue - The ref's starting value.
+ * @param id - Set by the build for a ref created at module level. Don't pass
+ *   it yourself.
+ * @returns The new ref.
+ */
+export declare const createMainThreadRef: <T>(initValue: T, id?: string) => MainThreadRef<T>;
+declare namespace MainThread {
+  /**
+   * An element's layout box, from `getBoundingClientRect()`, in pixels.
+   */
+  type BoundingClientRect = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+  };
+  /**
+   * Lynx's main-thread element, plus the `getBoundingClientRect()` that
+   * AngularLynx's MainThreadElement adds. The events below are Lynx's, built on
+   * this element type, so `event.currentTarget.getBoundingClientRect()` type
+   * checks without a cast.
+   */
+  type Element = Element$1 & {
+    getBoundingClientRect(options?: {
+      relativeTo?: string;
+    }): Promise<BoundingClientRect>;
+  };
+  type TouchEvent = BaseTouchEvent<Element>;
+  type MouseEvent = BaseMouseEvent<Element>;
+  type WheelEvent = BaseWheelEvent<Element>;
+  type KeyEvent = BaseKeyEvent<Element>;
+  type AnimationEvent = BaseAnimationEvent<Element>;
+  type TransitionEvent = BaseTransitionEvent<Element>;
+  type LayoutChangeEvent = LayoutChangeDetailEvent<Element>;
+  type UIAppearanceEvent = UIAppearanceDetailEvent<Element>;
+}
+/**
+ * Wraps a native ElementRef (elementRefptr) with the @lynx-js/types
+ * MainThread.Element API surface. Created by runWorklet's param transformation
+ * so that main-thread event handlers can call setStyleProperty(), setAttribute(),
+ * etc. on event.currentTarget.
+ */
+export declare class MainThreadElement {
+  #private;
+  constructor(element: ElementRef);
+  setAttribute(name: string, value: unknown): void;
+  getAttribute(name: string): unknown;
+  getAttributeNames(): string[];
+  setStyleProperty(name: string, value: string): void;
+  setStyleProperties(styles: Record<string, string>): void;
+  querySelector(selector: string): MainThreadElement | null;
+  querySelectorAll(selector: string): MainThreadElement[];
+  /**
+   * Invokes a native UI method on this element (e.g. scrollTo, autoPlay).
+   * __InvokeUIMethod is asynchronous — the result arrives in the callback.
+   * scheduleFlush() must be called AFTER __InvokeUIMethod so the method
+   * invocation is included in the next native render pass.
+   */
+  invoke(methodName: string, params?: Record<string, unknown>): Promise<unknown>;
+  animate(keyframes: Record<string, number | string>[], options?: number | LynxAnimationOptions): LynxAnimation;
+  /**
+   * Measures the element's layout box, by default from the top-left corner of
+   * the LynxView. `relativeTo` takes 'screen', or another element's `id`.
+   *
+   * Not part of the official @lynx-js/types Element interface, but useful for
+   * touch tracking. Unlike the DOM's, it's asynchronous: native Lynx gives a
+   * main-thread script the layout position only through the
+   * `boundingClientRect` UI method. The computed `left` and `top` styles are
+   * CSS offsets, often 0, not where the element is.
+   */
+  getBoundingClientRect(options?: {
+    relativeTo?: string;
+  }): Promise<MainThread.BoundingClientRect>;
+}
+/**
+ * Plain functions are also accepted: the worklet build plugin turns one with
+ * the 'main thread' directive into a MainThreadFnHandle at compile time, so
+ * TypeScript only sees the function, and the directive registers any other
+ * function itself.
+ */
+type MaybeHandle = MainThreadFnHandle | ((...args: any[]) => any) | undefined | null;
+/**
+ * Bridges Angular template bindings like `(mainThreadBindtap)="handler"` to
+ * Lynx's main-thread (Lepus) event dispatch.
+ *
+ * Why a dedicated directive and not the renderer's listen() path:
+ * - Normal `(bindtap)` handlers run on the main thread too (listen() registers
+ *   them as worklets), but each one goes through Angular's listener wrapper,
+ *   which marks the view for change detection on every dispatch: too much for
+ *   gesture-driven UI (scroll-tracking, drag, pinch) that mutates styles at
+ *   native frame rate. Their event's targets are also plain data.
+ * - The `mainThreadBind*` / `mainThreadCatch*` family registers the function
+ *   itself as a *worklet* with `_workletType: 'main-thread'`, so Lynx invokes
+ *   it directly, and runWorklet hands it MainThreadElement targets, whose
+ *   __AddInlineStyle / __SetAttribute calls are synchronous. Angular does no
+ *   work per event.
+ * - These inputs cannot be expressed as @Output() because Angular would route
+ *   them through its own event subscription system and the underlying
+ *   worklet handle would never be passed to __AddEvent.
+ *
+ * The worklet plugin (in rsbuild-plugin-angular-lynx) rewrites any function
+ * annotated with `'main thread'` directive into a `MainThreadFnHandle`
+ * carrying a stable `_wkltId`. That ID is what we hand to __AddEvent here.
+ */
+export declare class LynxMainThreadEvent implements OnChanges, OnDestroy {
+  #private;
+  mainThreadBindtap?: MaybeHandle;
+  mainThreadCatchtap?: MaybeHandle;
+  mainThreadBindtouchstart?: MaybeHandle;
+  mainThreadCatchtouchstart?: MaybeHandle;
+  mainThreadBindtouchmove?: MaybeHandle;
+  mainThreadCatchtouchmove?: MaybeHandle;
+  mainThreadBindtouchend?: MaybeHandle;
+  mainThreadCatchtouchend?: MaybeHandle;
+  mainThreadBindmousedown?: MaybeHandle;
+  mainThreadCatchmousedown?: MaybeHandle;
+  mainThreadBindmousemove?: MaybeHandle;
+  mainThreadCatchmousemove?: MaybeHandle;
+  mainThreadBindmouseup?: MaybeHandle;
+  mainThreadCatchmouseup?: MaybeHandle;
+  mainThreadBindlongpress?: MaybeHandle;
+  mainThreadCatchlongpress?: MaybeHandle;
+  mainThreadBindscroll?: MaybeHandle;
+  mainThreadCatchscroll?: MaybeHandle;
+  mainThreadBindanimationstart?: MaybeHandle;
+  mainThreadBindanimationend?: MaybeHandle;
+  mainThreadBindtransitionend?: MaybeHandle;
+  mainThreadBindlayoutchange?: MaybeHandle;
+  ngOnChanges(changes: SimpleChanges): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxMainThreadEvent, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxMainThreadEvent, "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindmousedown],[mainThreadCatchmousedown],[mainThreadBindmousemove],[mainThreadCatchmousemove],[mainThreadBindmouseup],[mainThreadCatchmouseup],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]", never, {
+    "mainThreadBindtap": {
+      "alias": "mainThreadBindtap";
+      "required": false;
+    };
+    "mainThreadCatchtap": {
+      "alias": "mainThreadCatchtap";
+      "required": false;
+    };
+    "mainThreadBindtouchstart": {
+      "alias": "mainThreadBindtouchstart";
+      "required": false;
+    };
+    "mainThreadCatchtouchstart": {
+      "alias": "mainThreadCatchtouchstart";
+      "required": false;
+    };
+    "mainThreadBindtouchmove": {
+      "alias": "mainThreadBindtouchmove";
+      "required": false;
+    };
+    "mainThreadCatchtouchmove": {
+      "alias": "mainThreadCatchtouchmove";
+      "required": false;
+    };
+    "mainThreadBindtouchend": {
+      "alias": "mainThreadBindtouchend";
+      "required": false;
+    };
+    "mainThreadCatchtouchend": {
+      "alias": "mainThreadCatchtouchend";
+      "required": false;
+    };
+    "mainThreadBindmousedown": {
+      "alias": "mainThreadBindmousedown";
+      "required": false;
+    };
+    "mainThreadCatchmousedown": {
+      "alias": "mainThreadCatchmousedown";
+      "required": false;
+    };
+    "mainThreadBindmousemove": {
+      "alias": "mainThreadBindmousemove";
+      "required": false;
+    };
+    "mainThreadCatchmousemove": {
+      "alias": "mainThreadCatchmousemove";
+      "required": false;
+    };
+    "mainThreadBindmouseup": {
+      "alias": "mainThreadBindmouseup";
+      "required": false;
+    };
+    "mainThreadCatchmouseup": {
+      "alias": "mainThreadCatchmouseup";
+      "required": false;
+    };
+    "mainThreadBindlongpress": {
+      "alias": "mainThreadBindlongpress";
+      "required": false;
+    };
+    "mainThreadCatchlongpress": {
+      "alias": "mainThreadCatchlongpress";
+      "required": false;
+    };
+    "mainThreadBindscroll": {
+      "alias": "mainThreadBindscroll";
+      "required": false;
+    };
+    "mainThreadCatchscroll": {
+      "alias": "mainThreadCatchscroll";
+      "required": false;
+    };
+    "mainThreadBindanimationstart": {
+      "alias": "mainThreadBindanimationstart";
+      "required": false;
+    };
+    "mainThreadBindanimationend": {
+      "alias": "mainThreadBindanimationend";
+      "required": false;
+    };
+    "mainThreadBindtransitionend": {
+      "alias": "mainThreadBindtransitionend";
+      "required": false;
+    };
+    "mainThreadBindlayoutchange": {
+      "alias": "mainThreadBindlayoutchange";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Injectable service for calling main-thread (Lepus) functions from Angular
+ * code, and getting their return values.
+ *
+ * Angular runs on the main thread only (see bootstrapApplication), so the
+ * call never crosses threads: it invokes the registered worklet in place,
+ * with the arguments as they are, and resolves with its result. Non-
+ * serializable values (element handles, MainThreadRefs) pass through intact.
+ *
+ * It used to send the call across threads when it ran on the background
+ * thread, for the copy of the app that booted there too. That copy is gone
+ * (issue #81), and with it the background-to-main call channel.
+ */
+export declare class LynxMainThread {
+  runOnMainThread<TArgs extends unknown[], TReturn>(handle: MainThreadFnHandle<TArgs, TReturn>, ...args: TArgs): Promise<TReturn>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxMainThread, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Resource priority hint for the native prefetch engine.
+ */
+type PrefetchPriority = 'high' | 'medium' | 'low';
+/**
+ * Cache destination for a prefetched resource.
+ * - `'disk'` — persists across app sessions (larger resources)
+ * - `'bitmap'` — decoded into memory for immediate display (images)
+ */
+type PrefetchCacheTarget = 'disk' | 'bitmap';
+/**
+ * Describes a single resource to prefetch.
+ */
+type PrefetchRequest = {
+  /**
+   * URL of the resource to prefetch.
+   */
+  uri: string;
+  /**
+   * Resource type — determines the native prefetch pipeline.
+   */
+  type: 'image' | 'video';
+  /**
+   * Optional priority hint (default determined by native engine).
+   */
+  priority?: PrefetchPriority;
+  /**
+   * Where to cache the prefetched resource.
+   */
+  cacheTarget?: PrefetchCacheTarget;
+  /**
+   * Custom cache key for manual cache management.
+   */
+  preloadKey?: string;
+  /**
+   * Expected resource size in bytes (helps native allocate buffers).
+   */
+  size?: number;
+};
+/**
+ * Per-resource result from a prefetch or cancel operation.
+ */
+type PrefetchResultDetail = {
+  code: number;
+  msg: string;
+  uri: string;
+  type: 'image' | 'video';
+};
+/**
+ * Wraps `lynx.requestResourcePrefetch()` and `lynx.cancelResourcePrefetch()`
+ * with a Promise-based API for preloading images and videos into the native
+ * cache before they're needed for display.
+ *
+ * Lynx has these APIs only on the background thread, while Angular runs on
+ * the main thread, so the calls go through the background call relay
+ * (background-call.ts).
+ *
+ * @usageNotes
+ * ```typescript
+ * const prefetch = inject(LynxResourcePrefetch);
+ *
+ * // Prefetch a single image
+ * const result = await prefetch.request([
+ *   { uri: 'https://cdn.example.com/hero.jpg', type: 'image' },
+ * ]);
+ *
+ * // Prefetch multiple resources with priority
+ * await prefetch.request([
+ *   { uri: 'https://cdn.example.com/hero.jpg', type: 'image', priority: 'high' },
+ *   { uri: 'https://cdn.example.com/promo.mp4', type: 'video', priority: 'low' },
+ * ]);
+ *
+ * // Cancel an in-flight prefetch
+ * await prefetch.cancel([
+ *   { uri: 'https://cdn.example.com/promo.mp4', type: 'video' },
+ * ]);
+ * ```
+ */
+export declare class LynxResourcePrefetch {
+  #private;
+  /**
+   * Request prefetching of one or more resources into the native cache.
+   * Resolves when the native engine acknowledges the request (not necessarily
+   * when the download completes).
+   */
+  request(resources: PrefetchRequest[]): Promise<ResourcePrefetchResult>;
+  /**
+   * Cancel in-flight prefetch requests for the specified resources.
+   * Useful when navigating away before prefetched content is needed.
+   */
+  cancel(resources: PrefetchRequest[]): Promise<ResourcePrefetchResult>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxResourcePrefetch, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * CSS `env()` value for the top safe area inset (notch / status bar).
+ */
+export declare const SAFE_AREA_INSET_TOP = "env(safe-area-inset-top)";
+/**
+ * CSS `env()` value for the bottom safe area inset (home indicator).
+ */
+export declare const SAFE_AREA_INSET_BOTTOM = "env(safe-area-inset-bottom)";
+/**
+ * CSS `env()` value for the left safe area inset.
+ */
+export declare const SAFE_AREA_INSET_LEFT = "env(safe-area-inset-left)";
+/**
+ * CSS `env()` value for the right safe area inset.
+ */
+export declare const SAFE_AREA_INSET_RIGHT = "env(safe-area-inset-right)";
+/**
+ * Provides device adaptation helpers for notch/safe-area-aware layouts.
+ *
+ * Safe area insets in Lynx are applied via CSS `env(safe-area-inset-*)`,
+ * identical to the web platform. This service exposes the `isNotchScreen`
+ * flag from the native host as a reactive signal for conditional logic.
+ *
+ * @usageNotes
+ *
+ * ### CSS approach (preferred)
+ * ```css
+ * .container {
+ *   padding-top: env(safe-area-inset-top);
+ *   padding-bottom: env(safe-area-inset-bottom);
+ * }
+ * ```
+ *
+ * ### Conditional logic in TypeScript
+ * ```typescript
+ * const safeArea = inject(LynxSafeArea);
+ *
+ * if (safeArea.isNotchScreen()) {
+ *   // Adjust layout for notch devices
+ * }
+ * ```
+ */
+export declare class LynxSafeArea {
+  #private;
+  /**
+   * Whether the device has a display notch or cutout. Reactive — updates when global props change.
+   */
+  readonly isNotchScreen: import("@angular/core").Signal<boolean>;
+  /**
+   * The current platform (`'iOS'`, `'Android'`, `'Harmony'`, etc.).
+   */
+  get platform(): import("@lynx-js/types").PlatformType;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxSafeArea, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Tracks an active session storage subscription so it can be cleaned up.
+ */
+type SessionStorageSubscription = {
+  readonly key: string;
+  readonly listenerId: number;
+};
+/**
+ * Wraps Lynx's session storage API for sharing data across multiple LynxViews.
+ *
+ * Session storage is a key-value store that persists for the lifetime of the
+ * host app session. Unlike browser localStorage, values are objects (not strings)
+ * and reads are asynchronous (callback-based in the native API, Promise-based here).
+ *
+ * The `setSessionStorageItem` / `getSessionStorageItem` / `subscribeSessionStorage` /
+ * `unsubscribeSessionStorage` methods are not declared in `@lynx-js/types`, so we
+ * access them via `any` — the APIs are stable and documented on lynxjs.org.
+ *
+ * The native surface differs by thread, and AngularLynx bootstraps the same
+ * component tree on both (see runtime.ts), so this service must detect which
+ * thread it's on rather than assume one shape everywhere:
+ * - Background thread: `getSessionStorageItem(key, callback)` is async, plus
+ *   `subscribeSessionStorage`/`unsubscribeSessionStorage` for pub/sub.
+ * - Main thread (Lepus engine, see `Utils::CreateLynx` in lynx core): only
+ *   `setSessionStorageItem`/`getSessionStorageItem` are registered — no
+ *   subscribe/unsubscribe at all — and `getSessionStorageItem` is
+ *   *synchronous*, taking just the key and returning the value directly.
+ *   Calling it with a callback (the background-thread shape) throws a native
+ *   "GetSessionStorageItem param size should be 1" fatal error. Subscriptions
+ *   made there go through the background thread (see background-call.ts).
+ *
+ * @usageNotes
+ * ```typescript
+ * const sessionStorage = inject(LynxSessionStorage);
+ *
+ * // Write
+ * sessionStorage.setItem('theme', { mode: 'dark' });
+ *
+ * // One-shot read
+ * const theme = await sessionStorage.getItem<{ mode: string }>('theme');
+ *
+ * // Reactive signal (auto-subscribes, auto-cleans up with injection context)
+ * const theme = sessionStorage.watch<{ mode: string }>('theme');
+ * // theme() updates whenever another LynxView calls setItem('theme', ...)
+ * ```
+ */
+export declare class LynxSessionStorage {
+  #private;
+  /**
+   * Stores a value in session storage, shared across all LynxViews.
+   * Existing subscribers for this key will be notified of the change.
+   *
+   * Two main-thread quirks are handled here, both discovered as on-device
+   * crashes/bugs in the session-storage example:
+   *
+   * 1. **Values must be objects.** The main thread's native
+   *    setSessionStorageItem rejects primitives with a fatal
+   *    "SetSessionStorageItem param 1 should be Object" error, so a bare
+   *    `setItem('counter', 1)` would crash on Increment. We wrap primitives
+   *    in `{ __data }` (getItem unwraps them symmetrically).
+   *
+   * 2. **No native pub/sub.** The main thread registers only get/set — there
+   *    is no subscribeSessionStorage — so {@link watch}'s subscription falls
+   *    back to the local listener map (see {@link subscribe}). A native write
+   *    alone therefore never reaches those listeners: the counter signal stays
+   *    on its seed value and the UI shows "not set" no matter how many times
+   *    the user taps Increment. We bridge the gap by firing the local
+   *    listeners ourselves right after the native write.
+   *
+   * The background thread deliberately does NOT call #notifyLocalListeners:
+   * there, watch() subscribes through native subscribeSessionStorage, and the
+   * native layer already fans the change out to every LynxView (including this
+   * one). Firing local listeners too would double-notify. There is no infinite
+   * loop in either case — #notifyLocalListeners only invokes stored callbacks,
+   * it never calls setItem back.
+   */
+  setItem<T = unknown>(key: string, value: T): void;
+  /**
+   * Reads a value from session storage. The native API is callback-based;
+   * this wraps it in a Promise for ergonomic use with `async`/`await`.
+   *
+   * On the main thread, wrapped primitives are unwrapped here to match
+   * the user's expectation that the value they stored is the value they get.
+   */
+  getItem<T = unknown>(key: string): Promise<T>;
+  /**
+   * Subscribes to changes for a session storage key. The callback fires
+   * whenever any LynxView calls `setItem` with the same key.
+   *
+   * Returns the subscription needed for {@link unsubscribe}.
+   */
+  subscribe<T = unknown>(key: string, callback: (value: T) => void): SessionStorageSubscription;
+  /**
+   * Cancels a session storage subscription created by {@link subscribe}.
+   */
+  unsubscribe(subscription: SessionStorageSubscription): void;
+  /**
+   * Creates a reactive signal that tracks a session storage key.
+   *
+   * Seeds the signal with the current value via `getItem`, then subscribes
+   * to future changes. The subscription is automatically cleaned up when the
+   * calling component/service is destroyed.
+   *
+   * Must be called from an injection context (constructor, field initializer,
+   * or `runInInjectionContext`) unless an explicit `injector` is provided.
+   */
+  watch<T = unknown>(key: string, options?: {
+    injector?: Injector;
+  }): ReturnType<typeof signal<T | undefined>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxSessionStorage, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Wraps the global `SystemInfo` object as an Angular injectable,
+ * providing device and platform information from the Lynx runtime.
+ *
+ * `SystemInfo` is populated once when the Lynx view initializes and
+ * is read-only for the lifetime of the app — the values never change.
+ *
+ * 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.
+ *
+ * @usageNotes
+ * ```typescript
+ * const systemInfo = inject(LynxSystemInfo);
+ *
+ * // Device dimensions in physical pixels
+ * const { pixelWidth, pixelHeight, pixelRatio } = systemInfo;
+ *
+ * // Logical screen dimensions (CSS pixels)
+ * const cssWidth = systemInfo.screenWidth;
+ * const cssHeight = systemInfo.screenHeight;
+ *
+ * // Platform detection
+ * if (systemInfo.platform === 'iOS') {
+ *   // iOS-specific logic
+ * }
+ * ```
+ */
+export declare class LynxSystemInfo {
+  #private;
+  constructor();
+  /**
+   * The platform of the current device (e.g. `'iOS'`, `'Android'`).
+   */
+  get platform(): PlatformType;
+  /**
+   * The Lynx engine version (e.g. `'3.2'`).
+   */
+  get engineVersion(): string;
+  /**
+   * The current operating system version.
+   */
+  get osVersion(): string;
+  /**
+   * Physical pixel width of the device screen.
+   */
+  get pixelWidth(): number;
+  /**
+   * Physical pixel height of the device screen.
+   */
+  get pixelHeight(): number;
+  /**
+   * Device pixel ratio (physical pixels per CSS pixel).
+   */
+  get pixelRatio(): number;
+  /**
+   * The JavaScript engine in use (`'v8'`, `'jsc'`, or `'quickjs'`). Only available on the background thread.
+   */
+  get runtimeType(): 'v8' | 'jsc' | 'quickjs';
+  /**
+   * Screen width in logical/CSS pixels (`pixelWidth / pixelRatio`).
+   */
+  get screenWidth(): number;
+  /**
+   * Screen height in logical/CSS pixels (`pixelHeight / pixelRatio`).
+   */
+  get screenHeight(): number;
+  /**
+   * The theme object, if provided by the host application.
+   */
+  get theme(): object | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxSystemInfo, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Wraps `lynx.getTextInfo()` for measuring text dimensions and
+ * performing line-breaking calculations.
+ *
+ * Only works with built-in platform fonts. Custom fonts loaded via
+ * `@font-face` or `LynxFont` will fall back to the default
+ * system font and produce inaccurate measurements.
+ *
+ * @usageNotes
+ * ```typescript
+ * const textMeasure = inject(LynxTextMeasure);
+ *
+ * const { width } = textMeasure.measure('Hello', { fontSize: '16px' });
+ *
+ * const { content } = textMeasure.measure('Long text...', {
+ *   fontSize: '14px',
+ *   maxWidth: '200px',
+ *   maxLine: 3,
+ * });
+ * ```
+ */
+export declare class LynxTextMeasure {
+  measure(text: string, options: TextInfo): TextMetrics;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTextMeasure, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Provides reactive access to the current Lynx theme ('Dark' or 'Light').
+ *
+ * The theme is driven by `lynx.__globalProps.theme`, which the native host
+ * sets based on the OS appearance setting. It updates reactively when the
+ * host calls `updateGlobalProps`.
+ *
+ * @usageNotes
+ * ```typescript
+ * const theme = inject(LynxTheme);
+ *
+ * // Reactive in templates
+ * template: `<text [style.color]="theme.isDarkMode() ? '#fff' : '#000'">Hello</text>`
+ *
+ * // Or use CSS variables (preferred for styling — see docs/guide/dark-mode.mdx)
+ * ```
+ */
+export declare class LynxTheme {
+  #private;
+  /**
+   * The current theme: `'Dark'` or `'Light'`. Reactive — updates when global props change.
+   */
+  readonly theme: import("@angular/core").Signal<"Dark" | "Light">;
+  /**
+   * Whether the current theme is dark mode. Reactive.
+   */
+  readonly isDarkMode: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTheme, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Animates the enter/leave of projected content using CSS `@keyframes`.
+ *
+ * Two classes are toggled on the host element:
+ *
+ * | Phase | Class applied   | Plays                                  |
+ * |-------|-----------------|----------------------------------------|
+ * | Enter | `{name}-enter`  | on mount, until `duration` elapses     |
+ * | Leave | `{name}-leave`  | then the element is unmounted          |
+ *
+ * **Why keyframes, not a two-phase CSS `transition`.** The obvious Vue-style
+ * approach (mount in a `-enter-from` state, then swap to `-enter-to` one frame
+ * later so a `transition` interpolates) needs a real paint gap between the two
+ * states. Lynx's background thread — where Angular runs — has no reliable frame
+ * boundary: `requestAnimationFrame` is microtask-mapped/absent, and class
+ * mutations made from an rAF/`setTimeout` callback don't go through change
+ * detection so they never reliably flush to the main thread (the element tree is
+ * committed once per CD cycle in `LynxRendererFactory2.end()`). A `@keyframes`
+ * animation sidesteps all of it: a SINGLE class, applied inside the effect (a CD
+ * pass) so it flushes in the same commit that mounts the element, and the native
+ * engine plays the keyframes from 0%. This mirrors the proven single-class
+ * pattern in `examples/animations`.
+ *
+ * Completion is timer-based (`duration`) because the background thread has no
+ * `animationend` bridge — `duration` must match your CSS animation length.
+ *
+ * @usageNotes
+ * ```html
+ * <lynx-transition [show]="isVisible()" name="fade" [duration]="300">
+ *   <view class="panel"><text>Hello</text></view>
+ * </lynx-transition>
+ * ```
+ *
+ * ```css
+ * @keyframes fade-enter { from { opacity: 0; } to { opacity: 1; } }
+ * @keyframes fade-leave { from { opacity: 1; } to { opacity: 0; } }
+ * .fade-enter { animation: fade-enter 300ms ease both; }
+ * .fade-leave { animation: fade-leave 300ms ease both; }
+ * ```
+ */
+export declare class LynxTransition {
+  #private;
+  readonly show: import("@angular/core").InputSignal<boolean>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly duration: import("@angular/core").InputSignal<number>;
+  readonly afterEnter: import("@angular/core").OutputEmitterRef<void>;
+  readonly afterLeave: import("@angular/core").OutputEmitterRef<void>;
+  readonly shouldRender: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTransition, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LynxTransition, "lynx-transition", never, {
+    "show": {
+      "alias": "show";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "duration": {
+      "alias": "duration";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "afterEnter": "afterEnter";
+    "afterLeave": "afterLeave";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Animates enter/leave of list items using CSS `@keyframes`.
+ *
+ * Unlike `LynxTransition` (single element), this manages a collection. Items are
+ * rendered from a user-provided `<ng-template>`, and the component diffs the list
+ * on each change to animate additions and removals.
+ *
+ * Each item's root element gets a single class toggled: `{name}-enter` on
+ * insertion, `{name}-leave` before removal. See `LynxTransition` for why a
+ * single `@keyframes` class is used instead of a two-phase CSS `transition` (the
+ * two-phase approach can't get a reliable paint gap on Lynx's background thread).
+ *
+ * @usageNotes
+ * ```html
+ * <lynx-transition-group [each]="items()" [trackBy]="idFn" name="list" [duration]="300">
+ *   <ng-template let-item>
+ *     <view>
+ *       <text>{{ item.name }}</text>
+ *     </view>
+ *   </ng-template>
+ * </lynx-transition-group>
+ * ```
+ *
+ * ```css
+ * @keyframes list-enter { from { opacity: 0; transform: translateX(30px); } to { opacity: 1; transform: translateX(0); } }
+ * @keyframes list-leave { from { opacity: 1; transform: translateX(0); } to { opacity: 0; transform: translateX(-30px); } }
+ * .list-enter { animation: list-enter 300ms ease both; }
+ * .list-leave { animation: list-leave 300ms ease both; }
+ * ```
+ */
+export declare class LynxTransitionGroup<T> {
+  #private;
+  readonly each: import("@angular/core").InputSignal<T[]>;
+  readonly trackBy: import("@angular/core").InputSignal<(item: T) => unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly duration: import("@angular/core").InputSignal<number>;
+  readonly afterEnter: import("@angular/core").OutputEmitterRef<T>;
+  readonly afterLeave: import("@angular/core").OutputEmitterRef<T>;
+  readonly itemTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  protected readonly vcr: import("@angular/core").Signal<ViewContainerRef>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxTransitionGroup<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LynxTransitionGroup<any>, "lynx-transition-group", never, {
+    "each": {
+      "alias": "each";
+      "required": false;
+      "isSignal": true;
+    };
+    "trackBy": {
+      "alias": "trackBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "duration": {
+      "alias": "duration";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "afterEnter": "afterEnter";
+    "afterLeave": "afterLeave";
+  }, ["itemTemplate"], never, true, never>;
+}
+/**
+ * Central DI configuration for the Lynx renderer. Must be included in every
+ * Lynx Angular app's providers (typically via app.config.ts). Sets up:
+ * 1. The document (LynxDocument, or LynxHydrateDocument for SSR)
+ * 2. DOCUMENT stub (Angular requires this token but Lynx has no DOM Document)
+ * 3. APP_BASE_HREF (prevents BrowserPlatformLocation from crashing)
+ * 4. Renderer factory (creates LynxRenderer / EmulatedLynxRenderer)
+ * 5. Error handler (routes to _ReportError + __lynxLastError)
+ */
+export declare const provideRenderer: () => EnvironmentProviders;
+/**
+ * Keeps the app on the screen it was showing when a hot update re-bootstraps
+ * it. Called with the old app's injector before it's destroyed, it saves the
+ * old strategy's history, and the next strategy created starts from it. The
+ * router's initial navigation then goes to the current URL instead of `/`,
+ * and Back still has the screens before it.
+ *
+ * Does nothing for an app without the router, or with another strategy.
+ *
+ * @param injector - The injector of the app that's about to be destroyed.
+ */
+declare const carryOverLocation: (injector: Injector | undefined) => void;
+/**
+ * In-memory LocationStrategy for Lynx — equivalent to React Router's MemoryRouter.
+ *
+ * Lynx is a native mobile runtime with no browser URL or History API.
+ * Angular's default PathLocationStrategy chains through PlatformLocation →
+ * window.history/window.location, which breaks Lynx's background thread
+ * even with mocked globals.
+ *
+ * This strategy keeps all routing state in memory: a history stack,
+ * current index, and popstate listeners — no browser APIs touched.
+ *
+ * Registered via `provideRouter()` in `lynx-router.ts`.
+ */
+export declare class LynxLocationStrategy extends LocationStrategy {
+  #private;
+  constructor();
+  /**
+   * Whether there's an entry before the current one, so `back()` goes
+   * somewhere. The Android back button follows it (see lynx-back-button.ts):
+   * while it's false, back leaves the app, as on any root screen.
+   */
+  readonly canGoBack: import("@angular/core").Signal<boolean>;
+  path(): string;
+  prepareExternalUrl(internal: string): string;
+  getBaseHref(): string;
+  getState(): unknown;
+  pushState(state: unknown, _title: string, url: string, queryParams: string): void;
+  replaceState(state: unknown, _title: string, url: string, queryParams: string): void;
+  back(): void;
+  forward(): void;
+  historyGo(relativePosition?: number): void;
+  onPopState(fn: LocationChangeListener): VoidFunction;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxLocationStrategy, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * PlatformLocation implementation for Lynx.
+ *
+ * Angular's default BrowserPlatformLocation uses `new URL()`, which doesn't
+ * exist in the Lynx JS runtime. This class avoids `URL` entirely by manually
+ * parsing pathname, search, and hash from the URL string.
+ *
+ * Registered via `provideRouter()` in `lynx-router.ts`.
+ *
+ * The `@Injectable()` decorator is required so Angular generates a `ɵfac`
+ * factory for this class. Without it, `getUndecoratedInjectableFactory()`
+ * walks the prototype chain, finds PlatformLocation's factory
+ * (`() => inject(BrowserPlatformLocation)`), and silently creates the wrong
+ * class — which crashes in Lynx because `window.location` doesn't exist.
+ */
+export declare class LynxPlatformLocation extends PlatformLocation {
+  #private;
+  getBaseHrefFromDOM(): string;
+  get href(): string;
+  get protocol(): string;
+  get hostname(): string;
+  get port(): string;
+  get pathname(): string;
+  get search(): string;
+  get hash(): string;
+  onPopState(fn: LocationChangeListener): VoidFunction;
+  onHashChange(_fn: LocationChangeListener): VoidFunction;
+  replaceState(state: unknown, title: string, url: string): void;
+  pushState(state: unknown, title: string, url: string): void;
+  forward(): void;
+  back(): void;
+  historyGo(relativePosition?: number): void;
+  getState(): unknown;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxPlatformLocation, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Route reuse strategy that keeps component views alive across navigations.
+ *
+ * Opt-in: `provideRouter()` doesn't install it, so leaving a route destroys
+ * its components, as Angular does on the web. Provide it yourself to keep
+ * every visited route's component, and its state, alive:
+ *
+ * ```typescript
+ * providers: [
+ *   provideRouter(routes),
+ *   { provide: RouteReuseStrategy, useClass: LynxRouteReuseStrategy },
+ * ]
+ * ```
+ *
+ * Nothing is ever evicted, and `ngOnDestroy()` doesn't run when you leave a
+ * route.
+ *
+ * ## Why it exists
+ *
+ * `provideRouter()` used to install it. A crash investigation in May 2026
+ * blamed a ~256-slot native element pool that `__RemoveElement` never freed,
+ * and detaching views was meant to reuse their elements. Neither holds on
+ * Lynx 4.1 (measured October 2026 on the iOS Simulator and an Android
+ * emulator, issue #68): 400 navigations between two 300-element routes
+ * created 121,527 native elements without a crash, with this strategy and
+ * with Angular's default alike. A re-attached view's native elements were
+ * destroyed when it was detached, so `LynxElement` rebuilds them from cache
+ * (`#recreateSubtree`), and a revisit creates as many elements as a fresh
+ * route.
+ */
+export declare class LynxRouteReuseStrategy implements RouteReuseStrategy {
+  #private;
+  shouldDetach(_route: ActivatedRouteSnapshot): boolean;
+  store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle | null): void;
+  shouldAttach(route: ActivatedRouteSnapshot): boolean;
+  retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
+  shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxRouteReuseStrategy, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Provides Angular Router configured for the Lynx runtime.
+ *
+ * Uses `LynxLocationStrategy` (in-memory routing) instead of Angular's default
+ * `PathLocationStrategy` which relies on browser History/Location APIs. This is
+ * the Angular equivalent of React Router's `MemoryRouter` — Lynx is a native
+ * mobile runtime with no browser URL or History API.
+ */
+export declare const provideRouter: (routes: Routes, ...features: RouterFeatures[]) => EnvironmentProviders;
+/**
+ * On-device crash diagnostics.
+ *
+ * There is no console on the Lynx device, so we capture the last unhandled
+ * error/rejection into a global (`__lynxLastError`) that Angular components can
+ * surface via a `<text>` element. LynxErrorHandler covers Angular-managed
+ * errors; the global `onerror`/`onunhandledrejection` handlers registered here
+ * catch crashes that escape Angular entirely — native glue code, promise
+ * rejections outside zones, etc.
+ *
+ * Split out of runtime.ts so `reportToNative` (and the handlers) can be
+ * unit-tested on their own, and so the diagnostic seed runs before any other
+ * runtime side effect.
+ */
+/**
+ * Forward an error to the native Lynx error reporting API when it exists.
+ * errorCode 1101 = ErrCode::LYNX_ERROR_CODE_LEPUS (matches React Lynx's
+ * convention). No-op off-device where `_ReportError` is absent.
+ */
+declare const reportToNative: (err: Error) => void;
+type GlobalExposureBatch = {
+  type: 'exposure' | 'disexposure';
+  events: GlobalExposureEvent;
+};
+/**
+ * Every batch of global exposure events, on whichever thread this module runs.
+ * LynxGlobalExposure subscribes.
+ */
+declare const globalExposureBatches: Subject<GlobalExposureBatch>;
+/**
+ * The background thread's half of the main thread's `fetch` (see fetch.ts).
+ * Lynx has `fetch` on the background thread only, and Angular runs on the
+ * main thread, so the main thread's `fetch` sends each request here, where
+ * background-call.ts's relay runs it, and this sends the response back.
+ *
+ * Everything crosses as JSON. A body is text when it can be, and base64
+ * otherwise, since JSON can't carry bytes.
+ */
+/** A request or response body as it crosses threads. */
+type RelayedBody = {
+  text: string;
+} | {
+  base64: string;
+} | null;
+/** A request as the main thread sends it. */
+type RelayedRequest = {
+  url: string;
+  method: string;
+  /** Unique names, since the main thread's Headers joins repeated ones. */
+  headers: [string, string][];
+  body: RelayedBody;
+  /** The rest of `RequestInit`, for hosts that use it (Lynx for Web's worker). */
+  options: {
+    cache?: string;
+    credentials?: string;
+    integrity?: string;
+    keepalive?: boolean;
+    mode?: string;
+    priority?: string;
+    redirect?: string;
+    referrer?: string;
+    referrerPolicy?: string;
+  };
+};
+/** A response as the background thread sends it back. */
+type RelayedResponse = {
+  status: number;
+  statusText: string;
+  url: string;
+  redirected: boolean;
+  headers: [string, string][];
+  body: RelayedBody;
+};
+/**
+ * Runs a request for the main thread and resolves with the response, body
+ * included. It rejects with a TypeError when the request fails, as `fetch`
+ * does.
+ *
+ * @param id - The main thread's ID for the request, to abort it by.
+ * @param request - The request.
+ * @returns The response.
+ */
+declare const fetchForMainThread: (id: number, request: RelayedRequest) => Promise<RelayedResponse>;
+/**
+ * Aborts a request the main thread sent, when its signal aborts. The main
+ * thread has already rejected its own promise; this stops the work here.
+ *
+ * @param id - The main thread's ID for the request.
+ */
+declare const abortFetchForMainThread: (id: number) => void;
+/**
+ * `__MAIN_THREAD__` is a build-time define. Unit tests don't define it, and run
+ * as the background thread unless they stub it.
+ *
+ * @returns Whether this code runs on the main thread.
+ */
+declare const isMainThread: () => boolean;
+/**
+ * Prepares a relayed call's arguments: on the main thread, each function in
+ * them, or in a plain object or array in them, becomes a marker that the
+ * background thread calls back. Elsewhere the call runs in place, so the
+ * arguments are left alone.
+ *
+ * @param value - The arguments, or one of them.
+ * @returns The value to send.
+ */
+declare const relayFunctions: (value: unknown) => unknown;
+/**
+ * Prepares a JS module for registering from the main thread: its methods,
+ * including ones on its prototype such as a class's, become markers bound to
+ * it, and its other fields are copied.
+ *
+ * @param module - The module to register.
+ * @returns The value to send.
+ */
+declare const relayModuleObject: (module: object) => unknown;
+/** Which registry a relayed module comes from. */
+type ModuleKind = 'native' | 'js';
+declare const handlers: {
+  accessibilityAnnounce: (content: string) => Promise<void>;
+  addFont: (fontFamily: string, src: string) => Promise<void>;
+  setObserverFrameRate: (options?: ObserverFrameRateOptions) => void;
+  stopExposure: (options?: {
+    sendEvent: boolean;
+  }) => void;
+  resumeExposure: () => void;
+  /**
+   * Subscribes on the background thread and sends each change to the main
+   * thread, where subscribeSessionStorageFromMainThread() delivers it.
+   */
+  subscribeSessionStorage: (key: string, relayId: number) => void;
+  unsubscribeSessionStorage: (relayId: number) => void;
+  requestResourcePrefetch: (data: unknown) => Promise<unknown>;
+  cancelResourcePrefetch: (data: unknown) => Promise<unknown>;
+  /**
+   * Calls the host's bridge method and resolves with the first value it
+   * passes back. Without a bridge, such as in the web preview, it resolves
+   * `undefined`, as LynxNativeModule.call() always has.
+   */
+  nativeBridgeCall: (name: string, params: unknown) => Promise<unknown>;
+  nativeBridgeOn: (name: string, callback: unknown) => void;
+  /**
+   * Calls a method of a native module or a JS module. The main thread's
+   * module proxies (relayedModule() below) send their calls here.
+   */
+  callModule: (kind: ModuleKind, name: string, method: string, args: unknown[]) => unknown;
+  registerJSModule: (name: string, module: unknown) => void;
+  /** The main thread's `fetch` (network/fetch.ts) sends its requests here. */
+  fetch: (id: number, request: RelayedRequest) => Promise<RelayedResponse>;
+  abortFetch: (id: number) => void;
+};
+type Handlers = typeof handlers;
+type HandlerName = keyof Handlers;
+/**
+ * Runs a background-only Lynx API, directly on the background thread or relayed
+ * from the main thread.
+ */
+declare const callOnBackground: <N extends HandlerName>(name: N, ...args: Parameters<Handlers[N]>) => Promise<Awaited<ReturnType<Handlers[N]>>>;
+/**
+ * Main thread: a stand-in for a native module or JS module, which only the
+ * background thread can reach. Each method call runs there and returns a
+ * promise of its result, and function arguments are called back here. Reading
+ * `then` gives `undefined`, so the proxy isn't mistaken for a promise.
+ *
+ * @param kind - `'native'` for `NativeModules`, `'js'` for `lynx.getJSModule`.
+ * @param name - The module's name.
+ * @returns The proxy.
+ */
+declare const relayedModule: (kind: ModuleKind, name: string) => object;
+/**
+ * Main thread only. Subscribes to a session storage key through the background
+ * thread, the only thread that can, and returns the ID to unsubscribe with.
+ */
+declare const subscribeSessionStorageFromMainThread: (key: string, listener: (value: unknown) => void) => number;
+declare const unsubscribeSessionStorageFromMainThread: (relayId: number) => void;
+/**
+ * Starts the background thread. The build calls it from the background
+ * thread's entry, a module it generates in place of the app's `main.ts`
+ * (background-entry.ts in the build plugin): Angular runs on the main thread
+ * only, so the background thread loads just this runtime and the modules that
+ * define a background function or a `MainThreadRef`.
+ *
+ * Loading the runtime installs the background half of each bridge (the imports
+ * above). This installs `lynx.loadLazyBundle`, for an `import()` in a
+ * background function. Importing it is also what keeps the runtime in the
+ * background bundle: the package is marked `"sideEffects": false`, so a bare
+ * `import '@blotch/angular-lynx'` would be dropped.
+ */
+export declare const ɵstartBackgroundThread: () => void;
+/**
+ * Bootstrap Angular application on the Lynx runtime. Waits for the main thread to
+ * signal it's ready before initializing the framework, then registers global
+ * callbacks for page updates and worklet invocations.
+ *
+ * Angular runs on the main thread only. The background thread starts from an
+ * entry the build generates instead of `main.ts` (see
+ * {@link ɵstartBackgroundThread}), so it doesn't reach this function, unless a
+ * module it loads also bootstraps, such as a `main.ts` that defines a
+ * `backgroundFn()` itself. Then it gets no app: the returned promise never
+ * settles on that thread. Booting a second copy there ran every constructor,
+ * `ngOnInit` and `effect()` twice, and its views went nowhere (issue #81).
+ */
+export declare const bootstrapApplication: (rootComponent: Type<unknown>, options?: ApplicationConfig) => Promise<ApplicationRef>;
+declare global {
+  /**
+   * Determines if code should be placed in the background thread, used as a compile-time define macro
+   */
+  var __BACKGROUND__: boolean;
+  /**
+   * Determines if code should be placed in the main thread, used as a compile-time define macro
+   */
+  var __MAIN_THREAD__: boolean;
+  /**
+   * Whether this bundle targets the web runtime (`@lynx-js/web-core`) rather
+   * than native Lynx. Compile-time define injected by the rsbuild plugin
+   * (`environment.name === 'web'`). Used to branch on web-only behavior that
+   * must be dead-code-eliminated from native bundles — e.g. web-core has no
+   * implicit post-`renderPage` flush, so the runtime forces the first
+   * `__FlushElementTree` itself (see `bootstrapApplication` in runtime.ts).
+   */
+  var __WEB__: boolean;
+  /**
+   * Determines if running in dev mode
+   */
+  var __DEV__: boolean;
+  /**
+   * Determines if running in profile mode
+   */
+  var __PROFILE__: boolean;
+  /**
+   * Whether SSR (Instant First-Frame Rendering) is enabled. When true, the
+   * runtime registers `ssrEncode` and `ssrHydrate` global callbacks that
+   * the Lynx engine calls to snapshot and restore the element tree.
+   */
+  var __ENABLE_SSR__: boolean;
+  /**
+   * Full URL of the dev log server (e.g. http://192.168.1.91:3001/__dev_logs).
+   * Injected by the rsbuild plugin's DefinePlugin in dev builds only.
+   */
+  var __DEV_LOG_URL__: string;
+  /**
+   * The source locale from angular.json i18n config (e.g. 'en-US', 'fr').
+   * Injected by the rsbuild plugin's DefinePlugin. Used by LynxLocale
+   * as a fallback when lynx.__globalProps.appLocale is not set.
+   */
+  var __LYNX_SOURCE_LOCALE__: string;
+  interface Window {
+    registerWorklet: (type: string, id: string, fn: Function) => void;
+    __workletRefMap: Record<number | string, {
+      current: unknown;
+    }>;
+    __lynxRunMainThreadWorklet: (wkltId: string, args: unknown[]) => unknown;
+  }
+  var registerWorklet: (type: string, id: string, fn: Function) => void;
+  var __workletRefMap: Record<number | string, {
+    current: unknown;
+  }>;
+  var __lynxRunMainThreadWorklet: (wkltId: string, args: unknown[]) => unknown;
+  function runOnBackground(handle: {
+    _wkltId: string;
+  }, ...args: unknown[]): Promise<unknown>;
+}
+declare global {
+  interface HTMLElementEventMap {
+    bindtap: TouchEvent;
+    catchtap: TouchEvent;
+    'capture-bindtap': TouchEvent;
+    'capture-catchtap': TouchEvent;
+    'global-bindtap': TouchEvent;
+    bindtouchstart: TouchEvent;
+    bindtouchend: TouchEvent;
+    bindtouchmove: TouchEvent;
+    bindtouchcancel: TouchEvent;
+    bindlongpress: TouchEvent;
+    catchtouchstart: TouchEvent;
+    catchtouchend: TouchEvent;
+    catchtouchmove: TouchEvent;
+    catchtouchcancel: TouchEvent;
+    catchlongpress: TouchEvent;
+    bindmousedown: MouseEvent;
+    bindmouseup: MouseEvent;
+    bindmousemove: MouseEvent;
+    bindmouseenter: MouseEvent;
+    bindmouseleave: MouseEvent;
+    catchmousedown: MouseEvent;
+    catchmouseup: MouseEvent;
+    catchmousemove: MouseEvent;
+    catchmouseenter: MouseEvent;
+    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 };