@blotch/angular-lynx 22.2.0 → 22.2.2

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

@@ -0,0 +1,4349 @@
+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, AnimationEvent, AnimationOptions, Element, KeyEvent, LayoutChangeEvent, MouseEvent, TouchEvent, TransitionEvent, UIAppearanceEvent, WheelEvent } from "@lynx-js/types/main-thread";
+import { AnyObject } from "@lynx-js/types/common";
+import { ControlValueAccessor } from "@angular/forms";
+import { PlatformType, ResourcePrefetchData, ResourcePrefetchResult, TextInfo, TextMetrics, TouchEvent as TouchEvent$1 } from "@lynx-js/types";
+import { LocationChangeListener, LocationStrategy, PlatformLocation } from "@angular/common";
+import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy, RouterFeatures, Routes } from "@angular/router";
+/**
+ * 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()`.
+   */
+  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()`.
+   */
+  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;
+};
+/**
+ * Shared interface for all animation implementations (real and no-op).
+ * Used by `BaseLynxElement.animate()` return type so both `LynxAnimation`
+ * (main thread) and `NoopLynxAnimation` (background thread) are valid.
+ * Required because LynxAnimation uses ES private fields (#element, #count)
+ * which brand the class — TypeScript's structural typing won't accept
+ * NoopLynxAnimation as assignable to LynxAnimation. This shared Pick type
+ * extracts only the public API both implementations satisfy.
+ */
+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.
+ */
+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;
+}
+/**
+ * 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.
+ *
+ * @usageNotes
+ * ```typescript
+ * const perf = inject(LynxPerformance);
+ *
+ * perf.profileStart('MyComponent::render', { itemCount: 42 });
+ * // ... do work ...
+ * perf.profileEnd();
+ *
+ * perf.profileMark('dataLoaded', { 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?: {
+    flowId?: number;
+    args?: Record<string, unknown>;
+  }): 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?: {
+    args?: Record<string, unknown>;
+  }): void;
+  /**
+   * Generate a unique flow ID for correlating multi-threaded traces.
+   */
+  profileFlowId(): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxPerformance, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Profiling counters collected by the renderer during a session.
+ * Only populated when the app is built with `__PROFILE__` enabled —
+ * in production, instrumentation is dead-code-eliminated and all values stay 0.
+ */
+type DevToolsStats = {
+  cdCycles: number;
+  elementCreated: number;
+  elementRemoved: number;
+  flushCount: number;
+  lastCdDurationMs: number;
+};
+/**
+ * High-level DevTools service exposing performance stats as Angular signals.
+ *
+ * Stats are only meaningful when the app is built with `__PROFILE__` enabled.
+ * 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;
+};
+/**
+ * Extend this interface to type the raw data passed from native before processing.
+ *
+ * @example
+ * 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
+ * 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
+ * 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 so that native data is transformed
+ * before LynxInitData receives the first onDataChanged event.
+ *
+ * @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;
+  'unique-id': 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 {
+  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;
+  setObserverFrameRate(options?: ObserverFrameRateOptions): 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.
+ *
+ * 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>>;
+/**
+ * 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`.
+ *
+ * @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
+   */
+  _config: Record<string, unknown>;
+  /**
+   * @internal
+   */
+  _waitFor: BaseGesture[];
+  /**
+   * @internal
+   */
+  _simultaneousWith: BaseGesture[];
+  /**
+   * @internal
+   */
+  _continueWith: BaseGesture[];
+  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;
+  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;
+};
+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.
+   */
+  direction(dir: FlingDirection): this;
+  /**
+   * The gesture only recognizes when exactly `count` fingers are involved.
+   * Defaults to 1 if not set.
+   */
+  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;
+  /**
+   * 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.
+   */
+  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.
+   */
+  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;
+}
+/**
+ * @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;
+  'accessibility-trait'?: 'none' | 'button' | 'image' | 'text';
+  /**
+   * Comma-separated list of child element names that are accessibility nodes.
+   */
+  '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;
+  /**
+   * Unique ID used for impression/exposure analytics.
+   */
+  'exposure-id'?: string;
+  /**
+   * Scene identifier grouping exposure events.
+   */
+  'exposure-scene'?: string;
+  /**
+   * Percentage of the element that must be visible (0–100) to trigger exposure.
+   */
+  'exposure-area'?: number;
+  /**
+   * Extends/shrinks the viewport detection zone (top edge, in px).
+   */
+  'exposure-screen-margin-top'?: number | string;
+  /**
+   * Extends/shrinks the viewport detection zone (bottom edge, in px).
+   */
+  'exposure-screen-margin-bottom'?: number | string;
+  /**
+   * Extends/shrinks the viewport detection zone (left edge, in px).
+   */
+  'exposure-screen-margin-left'?: number | string;
+  /**
+   * Extends/shrinks the viewport detection zone (right edge, in px).
+   */
+  'exposure-screen-margin-right'?: number | string;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (top, in px).
+   */
+  'exposure-ui-margin-top'?: number | string;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (bottom, in px).
+   */
+  'exposure-ui-margin-bottom'?: number | string;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (left, in px).
+   */
+  'exposure-ui-margin-left'?: number | string;
+  /**
+   * Adjusts the element's own bounding rect for exposure detection (right, in px).
+   */
+  'exposure-ui-margin-right'?: number | string;
+  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-trait": {
+      "alias": "accessibility-trait";
+      "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;
+    };
+    "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;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Backdrop blur: blurs the content rendered behind the element, like CSS
+ * `backdrop-filter: blur()`. On iOS, `blur-effect="glass"` renders the
+ * Liquid Glass material.
+ */
+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).
+   */
+  '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. @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). @default 'transparent'
+   */
+  'glass-tint-color'?: string;
+  /**
+   * Glass variant (iOS). @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.
+ */
+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';
+  /**
+   * Gap between items on the main axis (CSS length).
+   */
+  'list-main-axis-gap'?: string;
+  /**
+   * Gap between columns/rows on the cross axis (CSS length).
+   */
+  'list-cross-axis-gap'?: string;
+  /**
+   * 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;
+    };
+    "list-main-axis-gap": {
+      "alias": "list-main-axis-gap";
+      "required": false;
+    };
+    "list-cross-axis-gap": {
+      "alias": "list-cross-axis-gap";
+      "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;
+  /**
+   * Deferred rendering. Pass `true` to defer, or an object to control
+   * whether the item unmounts when recycled.
+   */
+  defer?: boolean | {
+    unmountRecycled?: boolean;
+  };
+  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;
+    };
+    "defer": {
+      "alias": "defer";
+      "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;
+  /**
+   * Z-order layer (higher = above other overlays).
+   * 1 = default, 2 = status bar level, 3 = keyboard level, 4 = top.
+   */
+  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 before truncation with ellipsis.
+   */
+  '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>`.
+ */
+export declare class LynxView extends LynxElementBase {
+  /**
+   * Flatten the view into its parent's layer (Android only).
+   * Improves performance for non-interactive views.
+   */
+  flatten?: boolean;
+  /**
+   * Direction of pan-gesture interception.
+   * 0 = horizontal, 1 = vertical, 2 = none.
+   */
+  'pan-intercept-direction'?: 0 | 1 | 2;
+  'pan-intercept-scope'?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+  'consume-slide-event'?: [number, number][];
+  'enable-touch-pseudo-propagation'?: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxView, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxView, "view", never, {
+    "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;
+    };
+  }, {}, 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 import("@blotch/angular-lynx").LynxInputValueAccessor, typeof import("@blotch/angular-lynx").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;
+  constructor();
+  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}:
+ *
+ * ```typescript
+ * declare module '@blotch/angular-lynx' {
+ *   interface NativeModuleMap {
+ *     NativeLocalStorageModule: {
+ *       setStorageItem(key: string, value: string): void;
+ *       getStorageItem(key: string, callback: (value: string) => void): void;
+ *       clearStorage(): void;
+ *     };
+ *   }
+ * }
+ * ```
+ */
+type NativeModuleMap = {};
+/**
+ * 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`).
+ *
+ * @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`.
+   *
+   * Returns `undefined` when `NativeModules` is unavailable (web preview, tests).
+   */
+  call<T = unknown>(name: string, params?: Record<string, unknown>): Promise<T | undefined>;
+  /**
+   * Subscribes to a native event via `NativeModules.bridge.on()`.
+   *
+   * No-op when `NativeModules` is unavailable.
+   */
+  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
+   * declare module '@blotch/angular-lynx' {
+   *   interface NativeModuleMap {
+   *     NativeLocalStorageModule: { ... };
+   *   }
+   * }
+   *
+   * const storage = modules.getNativeModule('NativeLocalStorageModule');
+   * ```
+   *
+   * Returns `undefined` when `NativeModules` is unavailable or the module
+   * is not registered.
+   */
+  getNativeModule<K extends string>(name: K): K extends keyof NativeModuleMap ? NativeModuleMap[K] : unknown;
+  /**
+   * Retrieves a JS module registered within this LynxView.
+   *
+   * This wraps `lynx.getJSModule()` — the same API used internally
+   * for `GlobalEventEmitter`.
+   *
+   * Returns `undefined` when `lynx` is unavailable or 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()`.
+   *
+   * 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>;
+}
+/**
+ * A no-op animation returned when `animate()` is called on the background
+ * thread where `__ElementAnimate` is unavailable. Provides the same API
+ * surface as `LynxAnimation` so callers can call `.cancel()`, `.pause()`,
+ * `.play()` without crashing — the calls simply do nothing.
+ *
+ * Fixes: "Uncaught Error: animate() is only available on the main thread"
+ * in the Go web preview (and any background-thread context).
+ *
+ * Why needed: In the Lynx dual-thread model, Angular runs on the background
+ * thread where __ElementAnimate doesn't exist. Previously, calling
+ * element.animate() from a component (e.g. the animations example's "Tap to
+ * pulse" button) would throw, crashing the Go web preview on the docs site.
+ *
+ * Approach: Return a silent no-op instead of throwing. This matches how
+ * @lynx-js/web-core itself handles __ElementAnimate on the server — it's
+ * defined as `() => {}` (a no-op). We mirror that graceful degradation here.
+ * Alternatives considered:
+ *   - Cross-thread bridge via lynx.getCoreContext().dispatchEvent() — correct
+ *     long-term but complex; LynxBackgroundElement doesn't hold a native ref.
+ *   - Removing animate() from the example — wrong because it's the primary
+ *     demonstration of the JS animate API.
+ */
+declare class NoopLynxAnimation implements Pick<Animation, 'id' | 'cancel' | 'pause' | 'play'> {
+  #private;
+  readonly id: string;
+  constructor();
+  play(): void;
+  pause(): void;
+  cancel(): void;
+}
+type LynxEventType = 'bindEvent' | 'catchEvent' | 'capture-bindEvent' | 'capture-catchEvent' | 'global-bindEvent';
+declare const EVENT_PREFIXES: [string, LynxEventType][];
+type BaseLynxElement = Pick<Element, '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;
+  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).
+   *
+   * Marked optional because it only exists on the main thread: LynxElement
+   * implements it via __InvokeUIMethod, while LynxBackgroundElement (used in
+   * tests and the background-thread context) does not — UIMethod calls have no
+   * meaning outside the native render thread. Callers should use invoke?.() so
+   * they become no-ops in test/background environments rather than crashing.
+   */
+  invoke?(methodName: string, params?: Record<string, unknown>): void;
+};
+/**
+ * Virtual element for the background thread where no native PAPI functions exist.
+ * Maintains an in-memory linked-list tree (parent/child/sibling pointers) that
+ * mirrors what LynxDocument builds on the main thread. Used by:
+ * - Angular's change detection (reads parentNode/nextSibling for view insertion)
+ * - querySelector/querySelectorAll (for testing and background-thread lookups)
+ * - LynxBackgroundDocument (creates these instead of native elements)
+ *
+ * Props, styles, classes, and events are stored in Maps/Sets but never sent to
+ * native — they exist so component code can read back what it set without
+ * crashing, and so the testing library can inspect element state.
+ */
+declare class LynxBackgroundElement implements BaseLynxElement {
+  #private;
+  isRootPageElement: boolean;
+  tagName: string;
+  setProperty(name: string, value: any): void;
+  setAttribute(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: LynxBackgroundElement, refChild: LynxBackgroundElement | null): void;
+  appendChild(newChild: LynxBackgroundElement): void;
+  addClass(name: string): void;
+  removeClass(name: string): void;
+  remove(): void;
+  parentNode(): BaseLynxElement | null;
+  nextSibling(): BaseLynxElement | null;
+  querySelector(selector: string): BaseLynxElement | null;
+  querySelectorAll(selector: string): BaseLynxElement[];
+  /**
+   * Previously threw: `throw new Error('animate() is only available on the
+   * main thread')`. This crashed the Go web preview on the docs site because
+   * the animations example's (bindtap) handler calls el.nativeElement.animate()
+   * which lands here on the background thread. Returning a no-op is safe —
+   * the animation won't visually play, but the caller's code (including
+   * .cancel() / .pause() / .play() chains) continues without error.
+   */
+  animate(_keyframes: Record<string, string | number>[], _options?: number | LynxAnimationOptions): NoopLynxAnimation;
+  addEventListener(name: string, cb: (event: any) => any): () => 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;
+  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;
+  /**
+   * 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 ever run on the
+ * main thread (the background thread uses LynxBackgroundDocument, which does not
+ * touch the native tree), 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 = {
+  /**
+   * Overlay z-level (1–4). Higher levels render above lower ones.
+   */
+  level?: number;
+  /**
+   * 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>;
+/**
+ * Reset counter on HMR — called from runtime.ts before modules re-evaluate.
+ */
+declare const __resetWorkletCounter: () => void;
+/**
+ * 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;
+};
+export declare const backgroundFn: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn) => BackgroundFnHandle<TArgs, TReturn>;
+/**
+ * Reset counter on HMR.
+ */
+declare const __resetBgWorkletCounter: () => void;
+export declare class MainThreadRef<T> {
+  #private;
+  readonly _wvid: number;
+  constructor(initValue: T);
+  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's transformParams() resolves { _wvid } back to the
+   * registered MainThreadRef instance.
+   */
+  toJSON(): {
+    _wvid: number;
+  };
+}
+export declare const createMainThreadRef: <T>(initValue: T) => MainThreadRef<T>;
+/**
+ * Reset counter on HMR.
+ */
+declare const __resetRefCounter: () => void;
+/**
+ * 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;
+  /**
+   * Not part of the official @lynx-js/types Element interface, but useful for
+   * touch-tracking calculations. Uses __GetComputedStyleByKey when available.
+   */
+  getBoundingClientRect(): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+  };
+}
+/**
+ * Plain functions are also accepted because the worklet build plugin transforms
+ * them into MainThreadFnHandle objects at compile time.
+ */
+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)` events are delivered to the background JS thread and
+ *   incur a thread hop on every dispatch — fine for one-shot taps, but too
+ *   slow for gesture-driven UI (scroll-tracking, drag, pinch) where the
+ *   handler needs to mutate styles at native frame rate.
+ * - The `mainThreadBind*` / `mainThreadCatch*` family registers the handler
+ *   as a *worklet* with `_workletType: 'main-thread'`, so Lynx invokes it
+ *   directly on the Lepus thread where __AddInlineStyle / __SetAttribute are
+ *   synchronous. There is no thread hop and no background JS involvement.
+ * - 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;
+  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],[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;
+    };
+    "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 the
+ * background thread it uses Lynx's cross-thread RPC via JSContext events:
+ *
+ *   background calls runOnMainThread(handle, ...args)
+ *   → dispatches 'Lynx.Worklet.runWorkletCtx' with { worklet, params, resolveId }
+ *   → main thread's listener (in runtime.ts) invokes the registered worklet fn
+ *   → dispatches 'Lynx.Worklet.FunctionCallRet' with { resolveId, returnValue }
+ *   → background thread's listener resolves the Promise
+ *
+ * This enables background-thread Angular code (services, effects) to trigger
+ * main-thread imperative operations (animate, measure, invoke UI methods)
+ * with proper async/await ergonomics.
+ *
+ * It is also safe to call from code already running on the main thread. The
+ * renderer registers Angular `(bind*)`/`(catch*)` event handlers as main-thread
+ * worklets, so a handler like `(bindtap)="flash()"` executes on the Lepus thread
+ * — and any runOnMainThread() call it makes originates there too. Rather than
+ * fail (there is no other thread to be "called from"), we detect that case and
+ * invoke the target worklet in-place, so the same call site works regardless of
+ * which thread reaches it.
+ */
+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>;
+}
+declare namespace MainThread {
+  type Element = Element;
+  type TouchEvent = TouchEvent;
+  type MouseEvent = MouseEvent;
+  type WheelEvent = WheelEvent;
+  type KeyEvent = KeyEvent;
+  type AnimationEvent = AnimationEvent;
+  type TransitionEvent = TransitionEvent;
+  type LayoutChangeEvent = LayoutChangeEvent;
+  type UIAppearanceEvent = UIAppearanceEvent;
+}
+/**
+ * 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.
+ *
+ * Only available on the background thread — these APIs are not exposed on
+ * the main thread.
+ *
+ * @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.
+ *
+ * @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.
+ *
+ * @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. Thread-aware document (LynxDocument vs LynxBackgroundDocument)
+ * 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;
+/**
+ * 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;
+  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.
+ *
+ * ## Why this is required on Lynx
+ *
+ * Lynx's native element APIs (`__CreateView`, `__CreateText`, etc.) allocate
+ * elements in a fixed-size native pool. `__RemoveElement` detaches an element
+ * from the tree but does NOT free its pool slot — there is no `__ReleaseElement`
+ * API in Lynx's public surface. Angular's default `RouteReuseStrategy` destroys
+ * components on every navigation, creating fresh native elements each time. Those
+ * freed elements accumulate in the pool until it overflows (~256 slots on device),
+ * causing a hard native crash on the 9th navigation in a back-and-forth pattern.
+ *
+ * ## What this strategy does
+ *
+ * Instead of destroying a component when navigating away, Angular calls
+ * `ViewContainerRef.detach()`. The component's DOM elements are removed from the
+ * native tree (the slots are occupied but unused). When navigating back,
+ * `ViewContainerRef.insert()` re-adds those same native elements to the tree —
+ * reusing their existing pool slots with no new allocations. The pool stays bounded
+ * by (initial elements) + (max elements for any single route), regardless of how
+ * many times the user navigates.
+ */
+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;
+/**
+ * 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.
+ */
+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, {
+      current: unknown;
+    }>;
+    __lynxMtsPendingResolvers: Record<number, {
+      resolve: (v: unknown) => void;
+      reject: (e: unknown) => void;
+    }>;
+    __lynxMtsNextResolveId: () => number;
+    __lynxRunMainThreadWorklet: (wkltId: string, args: unknown[]) => unknown;
+  }
+  var registerWorklet: (type: string, id: string, fn: Function) => void;
+  var __workletRefMap: Record<number, {
+    current: unknown;
+  }>;
+  var __lynxMtsPendingResolvers: Record<number, {
+    resolve: (v: unknown) => void;
+    reject: (e: unknown) => void;
+  }>;
+  var __lynxMtsNextResolveId: () => number;
+  var __lynxRunMainThreadWorklet: (wkltId: string, args: unknown[]) => unknown;
+  function runOnBackground(handle: {
+    _wkltId: string;
+  }, ...args: unknown[]): Promise<unknown>;
+}
+declare global {
+  interface HTMLElementEventMap {
+    bindtap: TouchEvent$1;
+    catchtap: TouchEvent$1;
+    'capture-bindtap': TouchEvent$1;
+    'capture-catchtap': TouchEvent$1;
+    'global-bindtap': TouchEvent$1;
+    bindtouchstart: TouchEvent$1;
+    bindtouchend: TouchEvent$1;
+    bindtouchmove: TouchEvent$1;
+    bindtouchcancel: TouchEvent$1;
+    bindlongpress: TouchEvent$1;
+    catchtouchstart: TouchEvent$1;
+    catchtouchend: TouchEvent$1;
+    catchtouchmove: TouchEvent$1;
+    catchtouchcancel: TouchEvent$1;
+    catchlongpress: TouchEvent$1;
+  }
+}
+export type { BackgroundFnHandle, BaseLynxAnimation, DataProcessorDefinition, DevToolsStats, ExposureEventDetail, FlingGestureEvent, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, InitData, InitDataRaw, LongPressGestureEvent, LynxAnimationOptions, LynxFontEntry, LynxFontFaceConfig, LynxFontStatus, MainThread, MainThreadFnHandle, NativeModuleMap, ObserverFrameRateOptions, PanGestureEvent, PinchGestureEvent, PortalConfig, PrefetchCacheTarget, PrefetchPriority, PrefetchRequest, PrefetchResultDetail, RotationGestureEvent, SessionStorageSubscription, TapGestureEvent };