import { WEVU_PAGE_SCROLL_EVENT_CONTRACT_KEY, WEVU_ROUTE_EVENT_CONTRACT_KEY } from "@weapp-core/constants";
//#region src/host/globals.d.ts
export interface HeadlessAppDefinition extends Record<string, any> {}
export interface HeadlessPageDefinition extends Record<string, any> {}
export interface HeadlessComponentDefinition extends Record<string, any> {}
export interface HeadlessBehaviorDefinition extends Record<string, any> {
  __isHeadlessBehavior__?: boolean;
}
export interface HeadlessHostLoadContext {
  kind: 'app' | 'page' | 'component';
  componentDefinitions?: HeadlessComponentDefinition[];
  route?: string;
}
export interface HeadlessHostRegistries {
  appDefinition: HeadlessAppDefinition | null;
  components: Map<string, HeadlessComponentDefinition>;
  currentLoadContext: HeadlessHostLoadContext | null;
  pages: Map<string, HeadlessPageDefinition>;
}
export declare function normalizeComponentPageDefinition(definition: HeadlessComponentDefinition): HeadlessPageDefinition;
export declare function createHostRegistries(): HeadlessHostRegistries;
export declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
export declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition, explicitRoute?: string): HeadlessPageDefinition;
export declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
export declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
//#endregion
//#region src/project/pageConfig.d.ts
interface HeadlessNavigationBarSnapshot {
  animation: {
    duration?: number;
    timingFunction?: string;
  } | null;
  backgroundColor: string;
  frontColor: string;
  loading: boolean;
  title: string;
}
type HeadlessBackgroundTextStyle = 'dark' | 'light';
interface HeadlessBackgroundSnapshot {
  backgroundColor: string;
  backgroundColorBottom: string;
  backgroundColorTop: string;
  textStyle: HeadlessBackgroundTextStyle;
}
//#endregion
//#region src/runtime/componentInstance/types.d.ts
interface HeadlessComponentInstance extends Record<string, any> {
  __definition__?: HeadlessComponentDefinition;
  __lastInteractionEvent__?: Record<string, any>;
  __propertySnapshots__?: Record<string, any>;
  __ready__?: boolean;
  createIntersectionObserver?: (options?: Record<string, any>) => any;
  createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
  createSelectorQuery?: () => HeadlessWxSelectorQuery;
  getRelationNodes: (relationKey: string) => HeadlessComponentInstance[];
  data: Record<string, any>;
  properties: Record<string, any>;
  selectAllComponents?: (selector: string) => any[];
  selectComponent?: (selector: string) => any;
  selectOwnerComponent?: () => any;
  setData: (patch: Record<string, any>, callback?: () => void) => void;
  triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
}
interface CreateComponentInstanceOptions {
  definition: HeadlessComponentDefinition;
  properties?: Record<string, any>;
  requestRender?: (callback?: () => void) => void;
  triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
}
//#endregion
//#region src/runtime/componentInstance/observers.d.ts
export declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
//#endregion
//#region src/runtime/componentInstance/properties.d.ts
export declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
export declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
//#endregion
//#region src/runtime/componentInstance/shared.d.ts
export declare function cloneValue<T>(value: T): T;
export declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
//#endregion
//#region src/runtime/componentInstance/index.d.ts
export declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
export declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
export declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
//#endregion
//#region src/runtime/pageInstance.d.ts
export interface HeadlessPageInstance extends Record<string, any> {
  __background__?: HeadlessBackgroundSnapshot;
  __backgroundTextStyle__?: HeadlessBackgroundTextStyle;
  __lastChangedKeys__?: string[];
  __navigationBar__?: HeadlessNavigationBarSnapshot;
  __navigationBarTitle__?: string;
  __route__: string;
  __scrollTop__?: number;
  data: Record<string, any>;
  properties: Record<string, any>;
  options: Record<string, string>;
  route: string;
  createIntersectionObserver?: (options?: Record<string, any>) => any;
  createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
  getTabBar?: () => HeadlessComponentInstance | null;
  selectAllComponents?: (selector: string) => any[];
  selectComponent?: (selector: string) => any;
  setData: (patch: Record<string, any>, callback?: () => void) => void;
}
export declare function getPageInstanceId(page: HeadlessPageInstance): number;
export declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
  background?: HeadlessBackgroundSnapshot;
  backgroundTextStyle?: HeadlessBackgroundTextStyle;
  navigationBar?: HeadlessNavigationBarSnapshot;
  requestRender?: (callback?: () => void) => void;
}): HeadlessPageInstance;
//#endregion
//#region src/host/wx/core.d.ts
export interface HeadlessWxCallbackOption<TResult = void> {
  complete?: (result?: TResult) => void;
  fail?: (error: Error) => void;
  success?: (result: TResult) => void;
}
export interface HeadlessWxLoadFontFaceResult {
  errMsg: string;
}
export interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
  descriptors?: Record<string, string>;
  family: string;
  global?: boolean;
  scopes?: string[];
  source: string;
}
export interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
  url: string;
}
export interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
  delta?: number;
}
export interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
  duration?: number;
  scrollTop?: number;
  selector?: string;
}
export interface HeadlessWxVideoContext {
  exitFullScreen: () => void;
  pause: () => void;
  play: () => void;
  requestFullScreen: () => void;
  seek: (position: number) => void;
  stop: () => void;
}
export interface HeadlessWxAnimationStepOption {
  delay?: number;
  duration?: number;
  timingFunction?: 'ease' | 'ease-in' | 'ease-in-out' | 'ease-out' | 'linear' | 'step-end' | 'step-start';
  transformOrigin?: string;
}
export interface HeadlessWxAnimationAction {
  args: unknown[];
  type: string;
}
export interface HeadlessWxAnimationExportResult {
  actions: Array<{
    animates: HeadlessWxAnimationAction[];
    option: Required<HeadlessWxAnimationStepOption>;
  }>;
}
export interface HeadlessWxAnimation {
  backgroundColor: (value: string) => HeadlessWxAnimation;
  bottom: (value: number | string) => HeadlessWxAnimation;
  export: () => HeadlessWxAnimationExportResult;
  height: (value: number | string) => HeadlessWxAnimation;
  left: (value: number | string) => HeadlessWxAnimation;
  opacity: (value: number) => HeadlessWxAnimation;
  right: (value: number | string) => HeadlessWxAnimation;
  rotate: (angle: number) => HeadlessWxAnimation;
  scale: (sx: number, sy?: number) => HeadlessWxAnimation;
  step: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
  top: (value: number | string) => HeadlessWxAnimation;
  translate: (tx?: number | string, ty?: number | string) => HeadlessWxAnimation;
  translate3d: (tx?: number | string, ty?: number | string, tz?: number | string) => HeadlessWxAnimation;
  translateX: (translation: number) => HeadlessWxAnimation;
  translateY: (translation: number) => HeadlessWxAnimation;
  translateZ: (translation: number) => HeadlessWxAnimation;
  width: (value: number | string) => HeadlessWxAnimation;
}
export interface HeadlessWxCanvasDrawCall {
  args: unknown[];
  type: string;
}
export interface HeadlessWxCanvasSnapshot {
  canvasId: string;
  drawCalls: HeadlessWxCanvasDrawCall[];
  fillStyle: string;
  fontSize: number;
  globalAlpha: number;
  lineCap: string;
  lineDash: number[];
  lineDashOffset: number;
  lineJoin: string;
  miterLimit: number;
  lineWidth: number;
  reserve: boolean;
  shadowBlur: number;
  shadowColor: string;
  shadowOffsetX: number;
  shadowOffsetY: number;
  strokeStyle: string;
  textAlign: string;
  textBaseline: string;
}
export interface HeadlessWxCanvasContext {
  __getSnapshot: () => HeadlessWxCanvasSnapshot;
  arc: (x: number, y: number, r: number, sAngle: number, eAngle: number, counterclockwise?: boolean) => void;
  arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
  bezierCurveTo: (cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number) => void;
  beginPath: () => void;
  clearRect: (x: number, y: number, width: number, height: number) => void;
  clip: (fillRule?: string) => void;
  closePath: () => void;
  draw: (reserve?: boolean, callback?: () => void) => void;
  drawImage: (image: string, ...args: number[]) => void;
  fill: (fillRule?: string) => void;
  fillRect: (x: number, y: number, width: number, height: number) => void;
  fillText: (text: string, x: number, y: number, maxWidth?: number) => void;
  lineTo: (x: number, y: number) => void;
  measureText: (text: string) => {
    width: number;
  };
  moveTo: (x: number, y: number) => void;
  quadraticCurveTo: (cpx: number, cpy: number, x: number, y: number) => void;
  rect: (x: number, y: number, width: number, height: number) => void;
  restore: () => void;
  rotate: (rotate: number) => void;
  save: () => void;
  scale: (scaleWidth: number, scaleHeight: number) => void;
  setFillStyle: (value: string) => void;
  setFontSize: (fontSize: number) => void;
  setGlobalAlpha: (value: number) => void;
  setLineCap: (value: string) => void;
  setLineDash: (pattern: number[], offset?: number) => void;
  setLineJoin: (value: string) => void;
  setMiterLimit: (value: number) => void;
  setLineWidth: (value: number) => void;
  setShadow: (offsetX: number, offsetY: number, blur: number, color: string) => void;
  setStrokeStyle: (value: string) => void;
  setTextAlign: (value: string) => void;
  setTextBaseline: (value: string) => void;
  stroke: () => void;
  strokeRect: (x: number, y: number, width: number, height: number) => void;
  strokeText: (text: string, x: number, y: number, maxWidth?: number) => void;
  translate: (x: number, y: number) => void;
}
export interface HeadlessWxIntersectionObserverMargins {
  bottom?: number;
  left?: number;
  right?: number;
  top?: number;
}
export interface HeadlessWxIntersectionObserverObserveAllResult {
  boundingClientRect: HeadlessWxSelectorQueryBoundingClientRectResult;
  id: string;
  intersectionRatio: number;
  intersectionRect: HeadlessWxSelectorQueryBoundingClientRectResult;
  relativeRect: HeadlessWxSelectorQueryBoundingClientRectResult;
}
export interface HeadlessWxIntersectionObserver {
  disconnect: () => void;
  observe: (selector: string, callback: (result: HeadlessWxIntersectionObserverObserveAllResult) => void) => void;
  relativeTo: (selector: string, margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
  relativeToViewport: (margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
}
export interface HeadlessWxCreateIntersectionObserverOption {
  thresholds?: number[];
}
export interface HeadlessWxObserveDescriptor {
  height?: number;
  maxHeight?: number;
  maxWidth?: number;
  minHeight?: number;
  minWidth?: number;
  orientation?: string;
  width?: number;
}
export interface HeadlessWxMediaQueryObserverObserveCallbackResult {
  matches: boolean;
}
export interface HeadlessWxMediaQueryObserver {
  disconnect: () => void;
  observe: (descriptor: HeadlessWxObserveDescriptor, callback: (result: HeadlessWxMediaQueryObserverObserveCallbackResult) => void) => void;
}
export interface HeadlessWxSelectorQueryBoundingClientRectResult {
  bottom: number;
  height: number;
  left: number;
  right: number;
  top: number;
  width: number;
}
export interface HeadlessWxSelectorQueryScrollOffsetResult {
  scrollLeft: number;
  scrollTop: number;
}
export interface HeadlessWxSelectorQueryFieldsOption {
  computedStyle?: string[];
  context?: boolean;
  dataset?: boolean;
  id?: boolean;
  mark?: boolean;
  node?: boolean;
  properties?: string[];
  rect?: boolean;
  scrollOffset?: boolean;
  size?: boolean;
}
export interface HeadlessWxSelectorQueryRequest {
  fields: HeadlessWxSelectorQueryFieldsOption;
  selector?: string;
  single: boolean;
  target: 'selector' | 'viewport';
}
export interface HeadlessWxSelectorQueryNode {
  boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
  fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
  node: (callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
  scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
}
export interface HeadlessWxSelectorQuery {
  exec: (callback?: (result: unknown[]) => void) => unknown[];
  in: (component: Record<string, any>) => HeadlessWxSelectorQuery;
  select: (selector: string) => HeadlessWxSelectorQueryNode;
  selectAll: (selector: string) => HeadlessWxSelectorQueryNode;
  selectViewport: () => HeadlessWxSelectorQueryNode;
}
export interface HeadlessWxStorageResult {
  errMsg: string;
}
export interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
  data: unknown;
}
export interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
  currentSize: number;
  keys: string[];
  limitSize: number;
}
export type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
export interface HeadlessWxGetNetworkTypeResult {
  errMsg: string;
  networkType: HeadlessWxNetworkType;
}
export interface HeadlessWxGetLocationResult {
  accuracy: number;
  altitude: number;
  errMsg: string;
  horizontalAccuracy: number;
  latitude: number;
  longitude: number;
  speed: number;
  verticalAccuracy: number;
}
export interface HeadlessWxNetworkStatusChangeResult {
  isConnected: boolean;
  networkType: HeadlessWxNetworkType;
}
export type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
export interface HeadlessWxSystemInfoResult {
  SDKVersion: string;
  brand: string;
  language: string;
  model: string;
  pixelRatio: number;
  platform: string;
  safeArea: HeadlessWxSafeArea;
  safeAreaInsets: HeadlessWxSafeAreaInsets;
  screenHeight: number;
  screenWidth: number;
  system: string;
  version: string;
  windowHeight: number;
  windowWidth: number;
}
export interface HeadlessWxSafeArea {
  bottom: number;
  height: number;
  left: number;
  right: number;
  top: number;
  width: number;
}
export interface HeadlessWxSafeAreaInsets {
  bottom: number;
  left: number;
  right: number;
  top: number;
}
export interface HeadlessWxAppBaseInfoResult {
  SDKVersion: string;
  enableDebug: boolean;
  host: {
    env: string;
  };
  language: string;
  platform: string;
  version: string;
}
export interface HeadlessWxDeviceInfoResult {
  abi: string;
  benchmarkLevel: number;
  brand: string;
  cpuType: string;
  deviceAbi: string;
  memorySize: number;
  model: string;
  platform: string;
  system: string;
}
export interface HeadlessWxWindowInfoResult {
  pixelRatio: number;
  safeArea: HeadlessWxSafeArea;
  safeAreaInsets: HeadlessWxSafeAreaInsets;
  screenHeight: number;
  screenWidth: number;
  statusBarHeight: number;
  windowHeight: number;
  windowWidth: number;
}
export interface HeadlessWxLaunchOptions {
  path: string;
  query: Record<string, string>;
  referrerInfo: {
    appId?: string;
    extraData?: Record<string, never>;
  };
  scene: number;
}
export interface HeadlessWxAppHideOptions {
  reason: 0 | 1 | 2 | 3;
}
export type HeadlessWxAppHideCallback = (options: HeadlessWxAppHideOptions) => void;
export type HeadlessWxAppShowCallback = (options: HeadlessWxLaunchOptions) => void;
export interface HeadlessWxMenuButtonBoundingClientRectResult {
  bottom: number;
  height: number;
  left: number;
  right: number;
  top: number;
  width: number;
}
export interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
  data: unknown;
  key: string;
}
export interface HeadlessWxSetClipboardDataResult {
  errMsg: string;
}
export interface HeadlessWxSetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxSetClipboardDataResult> {
  data: string;
}
export interface HeadlessWxGetClipboardDataResult {
  data: string;
  errMsg: string;
}
export interface HeadlessWxGetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxGetClipboardDataResult> {}
export interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
  key: string;
}
export interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
export interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
export interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
  altitude?: boolean;
  highAccuracyExpireTime?: number;
  isHighAccuracy?: boolean;
  type?: 'gcj02' | 'wgs84';
}
export interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
export interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
export interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
//#endregion
//#region src/host/wx/eventBus.d.ts
export type HeadlessUniEventHandler = (...args: any[]) => void;
export interface HeadlessUniEventBus {
  $emit: (eventName: string, ...args: any[]) => void;
  $off: (eventName?: string, handler?: HeadlessUniEventHandler) => void;
  $on: (eventName: string, handler: HeadlessUniEventHandler) => void;
  $once: (eventName: string, handler: HeadlessUniEventHandler) => void;
}
export declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
//#endregion
//#region src/host/wx/fileSystem.d.ts
export interface HeadlessWxFileSystemResult {
  errMsg: string;
}
export interface HeadlessWxReadFileSuccessResult {
  data: string;
  errMsg: string;
}
export interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
  encoding?: string;
  filePath: string;
}
export interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  data: string;
  encoding?: string;
  filePath: string;
}
export interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  path: string;
}
export interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  data: string;
  encoding?: string;
  filePath: string;
}
export interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  filePath: string;
}
export interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  destPath: string;
  srcPath: string;
}
export interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  newPath: string;
  oldPath: string;
}
export interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  dirPath: string;
  recursive?: boolean;
}
export interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
  dirPath: string;
  recursive?: boolean;
}
export interface HeadlessWxReadDirSuccessResult {
  errMsg: string;
  files: string[];
}
export interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
  dirPath: string;
}
export interface HeadlessWxStats {
  isDirectory: () => boolean;
  isFile: () => boolean;
  size: number;
}
export interface HeadlessWxStatSuccessResult {
  errMsg: string;
  stats: HeadlessWxStats;
}
export interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
  path: string;
}
export interface HeadlessWxFileSystemManager {
  access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
  accessSync: (path: string) => void;
  appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
  appendFileSync: (filePath: string, data: string, encoding?: string) => void;
  copyFile: (option: HeadlessWxCopyFileOption) => HeadlessWxFileSystemResult | undefined;
  copyFileSync: (srcPath: string, destPath: string) => void;
  mkdir: (option: HeadlessWxMkdirOption) => HeadlessWxFileSystemResult | undefined;
  mkdirSync: (dirPath: string, recursive?: boolean) => void;
  readFile: (option: HeadlessWxReadFileOption) => HeadlessWxReadFileSuccessResult | undefined;
  readFileSync: (filePath: string, encoding?: string) => string;
  readdir: (option: HeadlessWxReadDirOption) => HeadlessWxReadDirSuccessResult | undefined;
  readdirSync: (dirPath: string) => string[];
  rmdir: (option: HeadlessWxRmdirOption) => HeadlessWxFileSystemResult | undefined;
  rmdirSync: (dirPath: string, recursive?: boolean) => void;
  rename: (option: HeadlessWxRenameOption) => HeadlessWxFileSystemResult | undefined;
  renameSync: (oldPath: string, newPath: string) => void;
  stat: (option: HeadlessWxStatOption) => HeadlessWxStatSuccessResult | undefined;
  statSync: (path: string) => HeadlessWxStats;
  unlink: (option: HeadlessWxUnlinkOption) => HeadlessWxFileSystemResult | undefined;
  unlinkSync: (filePath: string) => void;
  writeFile: (option: HeadlessWxWriteFileOption) => HeadlessWxFileSystemResult | undefined;
  writeFileSync: (filePath: string, data: string, encoding?: string) => void;
}
//#endregion
//#region src/host/wx/logManager.d.ts
interface HeadlessWxGetLogManagerOption {
  /** 控制宿主自动生命周期及 API 日志，不过滤显式日志方法。 */
  level?: number;
}
interface HeadlessWxLogManager {
  debug: (...args: unknown[]) => void;
  info: (...args: unknown[]) => void;
  log: (...args: unknown[]) => void;
  warn: (...args: unknown[]) => void;
}
//#endregion
//#region src/host/wx/media.d.ts
export interface HeadlessWxGetImageInfoResult {
  errMsg: string;
  height: number;
  orientation: 'up';
  path: string;
  type: string;
  width: number;
}
export interface HeadlessWxGetImageInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetImageInfoResult> {
  src: string;
}
export interface HeadlessWxGetFileInfoResult {
  digest: string;
  errMsg: string;
  size: number;
}
export interface HeadlessWxGetFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetFileInfoResult> {
  digestAlgorithm?: 'md5' | 'sha1';
  filePath: string;
}
export interface HeadlessWxOpenDocumentResult {
  errMsg: string;
}
export interface HeadlessWxOpenDocumentOption extends HeadlessWxCallbackOption<HeadlessWxOpenDocumentResult> {
  filePath: string;
  fileType?: string;
  showMenu?: boolean;
}
export interface HeadlessWxGetVideoInfoResult {
  bitrate: number;
  duration: number;
  errMsg: string;
  fps: number;
  height: number;
  orientation: 'up';
  size: number;
  type: string;
  width: number;
}
export interface HeadlessWxGetVideoInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetVideoInfoResult> {
  src: string;
}
export interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
  key: string;
}
export interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
export interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {}
export interface HeadlessWxStartPullDownRefreshOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {}
export interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  textStyle: string;
}
export interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  backgroundColor?: string;
  backgroundColorBottom?: string;
  backgroundColorTop?: string;
}
export interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  title: string;
}
export interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  animation?: {
    duration?: number;
    timingFunction?: string;
  };
  backgroundColor?: string;
  frontColor?: string;
}
export interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {}
export interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {}
export interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  isUpdatableMessage?: boolean;
  menus?: string[];
  withShareTicket?: boolean;
}
export interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {}
export interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  index: number;
}
export interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
  text: string;
}
export interface HeadlessWxShowActionSheetResult {
  errMsg: string;
  tapIndex: number;
}
export interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
  itemList: string[];
}
export interface HeadlessWxShowModalResult {
  cancel: boolean;
  confirm: boolean;
  errMsg: string;
}
export interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
  cancelColor?: string;
  cancelText?: string;
  confirmColor?: string;
  confirmText?: string;
  content: string;
  showCancel?: boolean;
  title?: string;
}
export interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  duration?: number;
  icon?: string;
  mask?: boolean;
  title: string;
}
export interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  mask?: boolean;
  title: string;
}
export interface HeadlessWxRequestSuccessResult {
  cookies: string[];
  data: unknown;
  errMsg: string;
  header: Record<string, string>;
  statusCode: number;
}
export interface HeadlessWxRequestOption extends Omit<HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult>, 'complete'> {
  complete?: (result?: HeadlessWxRequestSuccessResult | Error) => void;
  enableChunked?: boolean;
  responseType?: 'text' | 'arraybuffer';
  data?: unknown;
  header?: Record<string, string>;
  method?: string;
  url: string;
}
export interface HeadlessWxRequestTask {
  abort: () => void;
}
export interface HeadlessWxRequestHeadersResult {
  cookies: string[];
  header: Record<string, string>;
  statusCode: number;
}
export interface HeadlessWxRequestChunkResult {
  data: ArrayBuffer;
}
export interface HeadlessWxNetworkRequestTask extends HeadlessWxRequestTask {
  /** 自定义传输可仅实现 abort，使用监听前应检测能力。 */
  onHeadersReceived?: (callback: (result: HeadlessWxRequestHeadersResult) => void) => void;
  offHeadersReceived?: (callback?: (result: HeadlessWxRequestHeadersResult) => void) => void;
  onChunkReceived?: (callback: (result: HeadlessWxRequestChunkResult) => void) => void;
  offChunkReceived?: (callback?: (result: HeadlessWxRequestChunkResult) => void) => void;
}
export interface HeadlessWxDownloadFileSuccessResult {
  errMsg: string;
  statusCode: number;
  tempFilePath: string;
}
export interface HeadlessWxDownloadFileOption extends HeadlessWxCallbackOption<HeadlessWxDownloadFileSuccessResult> {
  filePath?: string;
  header?: Record<string, string>;
  url: string;
}
export interface HeadlessWxUploadFileSuccessResult {
  data: string;
  errMsg: string;
  statusCode: number;
}
export interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWxUploadFileSuccessResult> {
  fileName?: string;
  filePath: string;
  formData?: Record<string, unknown>;
  header?: Record<string, string>;
  name: string;
  url: string;
}
export interface HeadlessWxSaveFileSuccessResult {
  errMsg: string;
  savedFilePath: string;
}
export interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSaveFileSuccessResult> {
  filePath?: string;
  tempFilePath: string;
}
export interface HeadlessWxCanvasToTempFilePathSuccessResult {
  errMsg: string;
  tempFilePath: string;
}
export interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<HeadlessWxCanvasToTempFilePathSuccessResult> {
  canvasId: string;
  component?: Record<string, any>;
  destHeight?: number;
  destWidth?: number;
  fileType?: string;
  height?: number;
  quality?: number;
  width?: number;
  x?: number;
  y?: number;
}
export interface HeadlessWxSaveImageToPhotosAlbumResult {
  errMsg: string;
}
export interface HeadlessWxSaveImageToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveImageToPhotosAlbumResult> {
  filePath: string;
}
export interface HeadlessWxSaveVideoToPhotosAlbumResult {
  errMsg: string;
}
export interface HeadlessWxSaveVideoToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveVideoToPhotosAlbumResult> {
  filePath: string;
}
export interface HeadlessWxPreviewImageResult {
  errMsg: string;
}
export interface HeadlessWxPreviewImageOption extends HeadlessWxCallbackOption<HeadlessWxPreviewImageResult> {
  current?: string;
  urls: string[];
}
export interface HeadlessWxChooseImageTempFile {
  path: string;
  size: number;
}
export interface HeadlessWxChooseImageResult {
  errMsg: string;
  tempFilePaths: string[];
  tempFiles: HeadlessWxChooseImageTempFile[];
}
export interface HeadlessWxChooseImageOption extends HeadlessWxCallbackOption<HeadlessWxChooseImageResult> {
  count?: number;
  sizeType?: string[];
  sourceType?: string[];
}
export interface HeadlessWxChooseMessageFileTempFile {
  name: string;
  path: string;
  size: number;
  time: number;
  type: string;
}
export interface HeadlessWxChooseMessageFileResult {
  errMsg: string;
  tempFiles: HeadlessWxChooseMessageFileTempFile[];
}
export interface HeadlessWxChooseMessageFileOption extends HeadlessWxCallbackOption<HeadlessWxChooseMessageFileResult> {
  count?: number;
  extension?: string[];
  type?: 'all' | 'file' | 'image' | 'video';
}
export interface HeadlessWxCompressImageResult {
  errMsg: string;
  tempFilePath: string;
}
export interface HeadlessWxCompressImageOption extends HeadlessWxCallbackOption<HeadlessWxCompressImageResult> {
  compressedHeight?: number;
  compressedWidth?: number;
  quality?: number;
  src: string;
}
export interface HeadlessWxChooseVideoResult {
  duration: number;
  errMsg: string;
  height: number;
  size: number;
  tempFilePath: string;
  width: number;
}
export interface HeadlessWxChooseVideoOption extends HeadlessWxCallbackOption<HeadlessWxChooseVideoResult> {
  camera?: string[];
  compressed?: boolean;
  maxDuration?: number;
  sourceType?: string[];
}
export interface HeadlessWxChooseMediaTempFile {
  duration?: number;
  fileType: 'image' | 'video';
  height: number;
  size: number;
  tempFilePath: string;
  thumbTempFilePath?: string;
  width: number;
}
export interface HeadlessWxChooseMediaResult {
  errMsg: string;
  tempFiles: HeadlessWxChooseMediaTempFile[];
  type: 'image' | 'mix' | 'video';
}
export interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessWxChooseMediaResult> {
  camera?: string[];
  count?: number;
  maxDuration?: number;
  mediaType?: Array<'image' | 'video'>;
  sizeType?: string[];
  sourceType?: string[];
}
export interface HeadlessWxSavedFileInfo {
  createTime: number;
  filePath: string;
  size: number;
}
export interface HeadlessWxGetSavedFileListSuccessResult {
  errMsg: string;
  fileList: HeadlessWxSavedFileInfo[];
}
export interface HeadlessWxGetSavedFileListOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileListSuccessResult> {}
export interface HeadlessWxGetSavedFileInfoSuccessResult {
  createTime: number;
  errMsg: string;
  size: number;
}
export interface HeadlessWxGetSavedFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileInfoSuccessResult> {
  filePath: string;
}
export interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
  errMsg: string;
}> {
  filePath: string;
}
export interface HeadlessWxDriverCapabilities {
  clearStorageSync: () => void;
  createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
  createCanvasContext: (canvasId: string, scope?: Record<string, any>) => HeadlessWxCanvasContext;
  createIntersectionObserver: (scope: Record<string, any> | undefined, options?: HeadlessWxCreateIntersectionObserverOption) => HeadlessWxIntersectionObserver;
  createVideoContext: (videoId: string, scope?: Record<string, any>) => HeadlessWxVideoContext;
  executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
  getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
  getDeviceInfo: () => HeadlessWxDeviceInfoResult;
  getClipboardData: () => HeadlessWxGetClipboardDataResult;
  getEnterOptionsSync: () => HeadlessWxLaunchOptions;
  getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
  getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
  getNetworkType: () => HeadlessWxGetNetworkTypeResult;
  getStorageInfoSync: () => HeadlessWxStorageInfoResult;
  getStorageSync: (key: string) => unknown;
  getSystemInfoSync: () => HeadlessWxSystemInfoResult;
  getWindowInfoSync: () => HeadlessWxWindowInfoResult;
  hideLoading: () => {
    errMsg: string;
  };
  hideToast: () => {
    errMsg: string;
  };
  hideNavigationBarLoading: () => {
    errMsg: string;
  };
  hideShareMenu: () => {
    errMsg: string;
  };
  hideTabBar: () => {
    errMsg: string;
  };
  hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
    errMsg: string;
  };
  navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
  navigateTo: (option: HeadlessWxNavigateOption) => unknown;
  nextTick: (callback?: () => void) => void;
  offAppHide: (callback?: HeadlessWxAppHideCallback) => void;
  offAppShow: (callback?: HeadlessWxAppShowCallback) => void;
  offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
  onAppHide: (callback: HeadlessWxAppHideCallback) => void;
  onAppShow: (callback: HeadlessWxAppShowCallback) => void;
  onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
  pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
  reLaunch: (option: HeadlessWxNavigateOption) => unknown;
  redirectTo: (option: HeadlessWxNavigateOption) => unknown;
  removeStorageSync: (key: string) => void;
  setStorageSync: (key: string, value: unknown) => void;
  setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
    errMsg: string;
  };
  setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
    errMsg: string;
  };
  setClipboardData: (option: HeadlessWxSetClipboardDataOption) => HeadlessWxSetClipboardDataResult;
  setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
    errMsg: string;
  };
  setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
    errMsg: string;
  };
  showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
  showLoading: (option: HeadlessWxShowLoadingOption) => {
    errMsg: string;
  };
  showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
  showNavigationBarLoading: () => {
    errMsg: string;
  };
  showShareMenu: (option: HeadlessWxShareMenuOption) => {
    errMsg: string;
  };
  showTabBar: () => {
    errMsg: string;
  };
  showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
    errMsg: string;
  };
  showToast: (option: HeadlessWxShowToastOption) => {
    errMsg: string;
  };
  startPullDownRefresh: () => {
    errMsg: string;
  };
  stopPullDownRefresh: () => void;
  switchTab: (option: HeadlessWxNavigateOption) => unknown;
  removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
    errMsg: string;
  };
  setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
    errMsg: string;
  };
  updateShareMenu: (option: HeadlessWxShareMenuOption) => {
    errMsg: string;
  };
}
//#endregion
//#region src/host/wx/workers.d.ts
export interface HeadlessWorker {
  onMessage: (listener: (message: any) => void) => void;
  offMessage: (listener?: (message: any) => void) => void;
  postMessage: (message: unknown) => void;
  onError: (listener: (error: {
    message: string;
  }) => void) => void;
  offError: (listener?: (error: {
    message: string;
  }) => void) => void;
  terminate: () => void;
}
export interface HeadlessWorkerApis {
  createWorker: (scriptPath: string) => HeadlessWorker;
  preDownloadSubpackage: (options: HeadlessWxCallbackOption<{
    errMsg: string;
  }> & {
    packageType: 'workers';
  }) => void;
}
//#endregion
//#region src/host/wx/api.d.ts
/** 宿主已接受的一次路由操作；同一次操作的所有阶段共用事件标识。 */
export interface HeadlessWxRouteEvent {
  path: string;
  query: Record<string, string>;
  openType: 'appLaunch' | 'navigateTo' | 'redirectTo' | 'navigateBack' | 'switchTab' | 'reLaunch';
  renderer: 'webview' | 'skyline' | 'xr-frame';
  webviewId: number;
  routeEventId: string;
  timeStamp: number;
}
/** 页面销毁前的原生实例，仍可同步读取页面数据。 */
export interface HeadlessWxBeforePageUnloadEvent extends HeadlessWxRouteEvent {
  page: HeadlessPageInstance;
}
export interface HeadlessWxRouteListeners {
  onBeforeAppRoute: (listener: (event: HeadlessWxRouteEvent) => void) => void;
  offBeforeAppRoute: (listener?: (event: HeadlessWxRouteEvent) => void) => void;
  onBeforePageUnload: (listener: (event: HeadlessWxBeforePageUnloadEvent) => void) => void;
  offBeforePageUnload: (listener?: (event: HeadlessWxBeforePageUnloadEvent) => void) => void;
  onAppRoute: (listener: (event: HeadlessWxRouteEvent) => void) => void;
  offAppRoute: (listener?: (event: HeadlessWxRouteEvent) => void) => void;
  onAppRouteDone: (listener: (event: HeadlessWxRouteEvent) => void) => void;
  offAppRouteDone: (listener?: (event: HeadlessWxRouteEvent) => void) => void;
}
export interface HeadlessWxDriver extends HeadlessWxDriverCapabilities, HeadlessWxRouteListeners {
  chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
  chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
  chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
  chooseVideo: (option: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult;
  compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult;
  getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult;
  getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult;
  getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult;
  getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult;
  getFileSystemManager: () => HeadlessWxFileSystemManager;
  getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
  getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
  downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
  openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult;
  previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult;
  removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
    errMsg: string;
  };
  request: (option: HeadlessWxRequestOption) => HeadlessWxNetworkRequestTask;
  saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
  saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult;
  saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult;
  canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
  uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
}
export interface HeadlessWx extends HeadlessUniEventBus, HeadlessWxRouteListeners, HeadlessWorkerApis {
  [WEVU_ROUTE_EVENT_CONTRACT_KEY]: 1;
  [WEVU_PAGE_SCROLL_EVENT_CONTRACT_KEY]: 1;
  canIUse: (schema: string) => boolean;
  chooseImage: (option?: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult | undefined;
  chooseMessageFile: (option?: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult | undefined;
  chooseMedia: (option?: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult | undefined;
  chooseVideo: (option?: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult | undefined;
  compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult | undefined;
  clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
  clearStorageSync: () => void;
  canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult | undefined;
  createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
  createCanvasContext: (canvasId: string, component?: Record<string, any>) => HeadlessWxCanvasContext;
  createIntersectionObserver: (component?: Record<string, any>, options?: HeadlessWxCreateIntersectionObserverOption) => HeadlessWxIntersectionObserver;
  createVideoContext: (videoId: string, component?: Record<string, any>) => HeadlessWxVideoContext;
  createSelectorQuery: () => HeadlessWxSelectorQuery;
  getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult | undefined;
  getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult | undefined;
  getLocale: () => string;
  getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult | undefined;
  getFileSystemManager: () => HeadlessWxFileSystemManager;
  getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult | undefined;
  getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult | undefined;
  getEnterOptionsSync: () => HeadlessWxLaunchOptions;
  getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
  getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
  getDeviceInfo: () => HeadlessWxDeviceInfoResult;
  getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
  getLogManager: (option?: HeadlessWxGetLogManagerOption) => HeadlessWxLogManager;
  getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
  getClipboardData: (option?: HeadlessWxGetClipboardDataOption) => HeadlessWxGetClipboardDataResult | undefined;
  getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult | undefined;
  getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
  getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
  getStorageInfoSync: () => HeadlessWxStorageInfoResult;
  getStorage: (option: HeadlessWxGetStorageOption) => HeadlessWxGetStorageResult | undefined;
  getStorageSync: (key: string) => unknown;
  getSystemInfo: (option?: HeadlessWxGetSystemInfoOption) => HeadlessWxSystemInfoResult | undefined;
  getSystemInfoSync: () => HeadlessWxSystemInfoResult;
  getWindowInfo: (option?: HeadlessWxGetWindowInfoOption) => HeadlessWxWindowInfoResult | undefined;
  getWindowInfoSync: () => HeadlessWxWindowInfoResult;
  loadFontFace: (option: HeadlessWxLoadFontFaceOption) => HeadlessWxLoadFontFaceResult | undefined;
  hideLoading: (option?: HeadlessWxHideLoadingOption) => {
    errMsg: string;
  } | undefined;
  hideToast: () => {
    errMsg: string;
  };
  downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
  navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
  navigateTo: (option: HeadlessWxNavigateOption) => unknown;
  nextTick: (callback?: () => void) => void;
  offAppHide: (callback?: HeadlessWxAppHideCallback) => void;
  offAppShow: (callback?: HeadlessWxAppShowCallback) => void;
  offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
  onAppHide: (callback: HeadlessWxAppHideCallback) => void;
  onAppShow: (callback: HeadlessWxAppShowCallback) => void;
  onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
  openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult | undefined;
  pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
  previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult | undefined;
  reLaunch: (option: HeadlessWxNavigateOption) => unknown;
  redirectTo: (option: HeadlessWxNavigateOption) => unknown;
  removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
    errMsg: string;
  } | undefined;
  saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult | undefined;
  saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult | undefined;
  removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
  removeStorageSync: (key: string) => void;
  rpx2px: (value: number) => number;
  request: (option: HeadlessWxRequestOption) => HeadlessWxNetworkRequestTask;
  saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult | undefined;
  setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
    errMsg: string;
  } | undefined;
  setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
    errMsg: string;
  } | undefined;
  setClipboardData: (option: HeadlessWxSetClipboardDataOption) => HeadlessWxSetClipboardDataResult | undefined;
  setStorage: (option: HeadlessWxSetStorageOption) => HeadlessWxStorageResult | undefined;
  setStorageSync: (key: string, value: unknown) => void;
  setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
    errMsg: string;
  } | undefined;
  setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
    errMsg: string;
  } | undefined;
  hideShareMenu: (option?: HeadlessWxCallbackOption<{
    errMsg: string;
  }>) => {
    errMsg: string;
  } | undefined;
  hideNavigationBarLoading: (option?: HeadlessWxHideNavigationBarLoadingOption) => {
    errMsg: string;
  } | undefined;
  hideTabBar: (option?: HeadlessWxTabBarOption) => {
    errMsg: string;
  } | undefined;
  hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
    errMsg: string;
  } | undefined;
  showShareMenu: (option?: HeadlessWxShareMenuOption) => {
    errMsg: string;
  } | undefined;
  showNavigationBarLoading: (option?: HeadlessWxShowNavigationBarLoadingOption) => {
    errMsg: string;
  } | undefined;
  showTabBar: (option?: HeadlessWxTabBarOption) => {
    errMsg: string;
  } | undefined;
  showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
    errMsg: string;
  } | undefined;
  showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult | undefined;
  showLoading: (option: HeadlessWxShowLoadingOption) => {
    errMsg: string;
  } | undefined;
  showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult | undefined;
  showToast: (option: HeadlessWxShowToastOption) => {
    errMsg: string;
  } | undefined;
  startPullDownRefresh: (option?: HeadlessWxStartPullDownRefreshOption) => {
    errMsg: string;
  } | undefined;
  stopPullDownRefresh: () => void;
  switchTab: (option: HeadlessWxNavigateOption) => unknown;
  uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
  removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
    errMsg: string;
  } | undefined;
  setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
    errMsg: string;
  } | undefined;
  updateShareMenu: (option?: HeadlessWxShareMenuOption) => {
    errMsg: string;
  } | undefined;
  upx2px: (value: number) => number;
}
//#endregion
//#region src/host/wx/index.d.ts
export declare function createHeadlessWx(driver: HeadlessWxDriver, runtimeConsole?: Pick<Console, 'debug' | 'info' | 'log' | 'warn'>, workers?: HeadlessWorkerApis): HeadlessWx;
//#endregion
//#region src/kernel/artifactSource.d.ts
export interface ArtifactSource {
  has: (filePath: string) => boolean;
  readText: (filePath: string) => string | undefined;
}
export declare function createFileSystemArtifactSource(): ArtifactSource;
export declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
export declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
//#endregion
//#region src/kernel/diagnostics.d.ts
export type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
export interface RuntimeDiagnosticEntry {
  args: unknown[];
  level: RuntimeDiagnosticLevel;
  timestamp: number;
}
export interface RuntimeConsoleEntry {
  args: unknown[];
  level: 'debug' | 'error' | 'info' | 'log' | 'warn';
}
export declare class RuntimeDiagnostics {
  private readonly entries;
  clear(): void;
  getEntries(): {
    args: unknown[];
    level: RuntimeDiagnosticLevel;
    timestamp: number;
  }[];
  record(level: RuntimeDiagnosticLevel, args: unknown[]): void;
  createConsole(baseConsole?: Console, onConsole?: (entry: RuntimeConsoleEntry) => void): Console;
}
//#endregion
//#region src/kernel/platform.d.ts
export interface PlatformAdapter {
  readonly name: string;
}
export declare function wechat(): PlatformAdapter;
//#endregion
//#region src/kernel/scheduler.d.ts
type TimeoutHandle = ReturnType<typeof setTimeout>;
type IntervalHandle = ReturnType<typeof setInterval>;
export declare class RuntimeScheduler {
  private readonly intervals;
  private readonly timeouts;
  private closed;
  private canceledHandle?;
  private readonly onError;
  constructor(onError: (error: unknown) => void);
  clearInterval(handle: IntervalHandle): void;
  clearTimeout(handle: TimeoutHandle): void;
  close(): void;
  queueMicrotask(handler: () => void): void;
  setInterval(handler: (...args: any[]) => void, timeout?: number, ...args: any[]): NodeJS.Timeout;
  setTimeout(handler: (...args: any[]) => void, timeout?: number, ...args: any[]): NodeJS.Timeout;
  /** 已销毁 realm 的 Promise 回调不能复活任务，也不能向外泄漏异步拒绝。 */
  private getCanceledHandle;
}
//#endregion
//#region src/kernel/runtimeKernel.d.ts
export declare class RuntimeKernel {
  readonly diagnostics: RuntimeDiagnostics;
  readonly scheduler: RuntimeScheduler;
  private closed;
  assertActive(): void;
  close(): void;
  get isClosed(): boolean;
}
//#endregion
//#region src/project/plugins.d.ts
export declare const HEADLESS_PLUGIN_VIRTUAL_ROOT = "__plugins__";
export interface HeadlessPluginDescriptor {
  alias: string;
  config: Record<string, any>;
  provider: string;
  rootPath: string;
  virtualRoot: string;
}
export declare function createPluginVirtualRoot(alias: string): string;
export declare function resolvePluginRequest(plugins: HeadlessPluginDescriptor[], request: string, kind: 'page' | 'publicComponent'): {
  plugin: HeadlessPluginDescriptor;
  publicName: string;
  resourcePath: string;
} | undefined;
export declare function createPluginArtifactSource(fallback: ArtifactSource, miniprogramRootPath: string, plugins: HeadlessPluginDescriptor[]): ArtifactSource;
//#endregion
//#region src/project/resolveRoutes.d.ts
export interface HeadlessRouteRecord {
  kind: 'page';
  route: string;
  source: 'pages' | 'plugin' | 'subPackages';
  resourcePath?: string;
  subpackageRoot?: string;
}
export declare function resolveRoutesFromAppConfig(config: Record<string, any>, plugins?: HeadlessPluginDescriptor[]): HeadlessRouteRecord[];
//#endregion
//#region src/project/createProjectDescriptor.d.ts
export interface HeadlessProjectConfigFile {
  filePath: string;
  value: Record<string, any>;
}
export interface HeadlessProjectDescriptor {
  artifactSource: ArtifactSource;
  appConfig: Record<string, any>;
  appConfigPath: string;
  miniprogramRoot: string;
  miniprogramRootPath: string;
  plugins: HeadlessPluginDescriptor[];
  projectPath: string;
  projectConfigFiles: HeadlessProjectConfigFile[];
  routes: HeadlessRouteRecord[];
}
export interface CreateProjectDescriptorOptions {
  artifactSource?: ArtifactSource;
  appConfig: Record<string, any>;
  appConfigPath: string;
  miniprogramRoot: string;
  miniprogramRootPath: string;
  plugins?: HeadlessPluginDescriptor[];
  projectPath: string;
  projectConfigFiles?: HeadlessProjectConfigFile[];
}
export declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
//#endregion
//#region src/project/createArtifactProject.d.ts
export interface CreateArtifactProjectOptions {
  appConfigPath?: string;
  artifactSource?: ArtifactSource;
  miniprogramRootPath: string;
  projectPath?: string;
}
export declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
//#endregion
//#region src/project/hostConfig.d.ts
/**
 * @description 根据构建后的 app.json 创建模拟器提供给小程序脚本读取的宿主配置。
 * 微信开发者工具的 tabBar 页面路径通常带有 `.html` 后缀，保留该形态以覆盖路由归一化边界。
 */
export declare function createMiniProgramHostConfig(appConfig: Record<string, any>, override?: unknown): Record<string, any>;
//#endregion
//#region src/project/loadProject.d.ts
export declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
//#endregion
//#region src/browser/virtualFiles.d.ts
export interface BrowserDirectoryFileLike {
  name: string;
  text: () => Promise<string>;
  webkitRelativePath?: string;
}
export type BrowserVirtualFiles = Map<string, string>;
export declare function normalizeBrowserFilePath(filePath: string): string;
export declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
export declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
export declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
export declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
//#endregion
//#region src/browser/moduleLoader.d.ts
export interface BrowserModuleLoader {
  close: () => void;
  executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
  executeAppModule: (filePath: string) => HeadlessAppDefinition;
  executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
  wx: HeadlessWx;
}
export declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
  globals?: Record<string, unknown>;
  kernel: RuntimeKernel;
  miniprogramRootPath: string;
  plugins: HeadlessPluginDescriptor[];
}): BrowserModuleLoader;
//#endregion
//#region src/browser/project.d.ts
export interface CreateBrowserProjectOptions {
  appConfigPath?: string;
  miniprogramRoot?: string;
  miniprogramRootPath?: string;
  plugins?: HeadlessPluginDescriptor[];
  projectPath?: string;
}
export declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
//#endregion
//#region src/view/nodeHandle.d.ts
interface DomNodeLike$5 {
  attribs?: Record<string, string>;
  children?: DomNodeLike$5[];
  data?: string;
  dataset?: Record<string, unknown>;
  name?: string;
  parent?: DomNodeLike$5 | null;
  type?: string;
}
export interface HeadlessTestingNodeEventInit {
  currentTarget?: {
    dataset?: Record<string, unknown>;
    id?: string;
  };
  dataset?: Record<string, unknown>;
  detail?: unknown;
  id?: string;
  mark?: Record<string, unknown>;
  target?: {
    dataset?: Record<string, unknown>;
    id?: string;
  };
}
export interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit {
  detail?: {
    value?: string;
    [key: string]: unknown;
  };
}
interface HeadlessTestingNodeInteractionHandlers {
  assertActive?: () => void;
  callMethod: (scopeId: string | null, methodName: string, event: Record<string, any>) => unknown;
  dispatchNativeEvent?: (node: DomNodeLike$5, eventName: string, event: HeadlessTestingNodeEventInit, onHandlerResult?: (result: unknown) => void) => boolean;
  createScopeHandle: (scopeId: string | null) => {
    scopeId: string;
    snapshot: () => Promise<unknown>;
  } | null;
  createPageHandle: () => {
    data: (path?: string) => Promise<unknown>;
  };
  ownerScopeId: (scopeId: string | null) => string | null;
  projectionOnly?: boolean;
}
export declare class HeadlessTestingNodeHandle {
  private readonly node;
  private readonly interactions?;
  constructor(node: DomNodeLike$5, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
  private assertActive;
  private query;
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
  getElementsByXpath(expression: string): Promise<HeadlessTestingNodeHandle[]>;
  attr(name: string): Promise<string | undefined>;
  dataset(): Promise<Record<string, unknown>>;
  scope(): Promise<{
    scopeId: string;
    snapshot: () => Promise<unknown>;
  } | null>;
  componentScope(): Promise<{
    scopeId: string;
    snapshot: () => Promise<unknown>;
  } | null>;
  pageScope(): Promise<{
    scopeId: string;
    snapshot: () => Promise<unknown>;
  } | null>;
  page(): Promise<{
    data: (path?: string) => Promise<unknown>;
  }>;
  ownerComponentScope(): Promise<{
    scopeId: string;
    snapshot: () => Promise<unknown>;
  } | null>;
  text(): Promise<string>;
  tagName(): Promise<string | undefined>;
  trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
  tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
  input(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
  change(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
  blur(value?: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
  wxml(): Promise<string>;
}
//#endregion
//#region src/view/eventBinding.d.ts
export interface MiniProgramEventBinding {
  method: string;
  stopAfter: boolean;
}
export declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
export declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
/** 冒泡时保留原始 target，currentTarget 则属于当前执行绑定的节点。 */
export declare function createMiniProgramEventPayload(node: {
  attribs?: Record<string, string>;
  dataset?: Record<string, unknown>;
}, eventName: string, event: HeadlessTestingNodeEventInit, origin?: {
  attribs?: Record<string, string>;
  dataset?: Record<string, unknown>;
}): {
  bubbles: boolean;
  capturePhase: boolean;
  composed: boolean;
  currentTarget: {
    dataset: Record<string, unknown>;
    id: string;
  };
  detail: unknown;
  mark: Record<string, unknown> | undefined;
  target: {
    dataset: Record<string, unknown>;
    id: string;
  };
  timeStamp: number;
  type: string;
};
//#endregion
//#region src/view/wxs.d.ts
type WxsModuleBindings = Record<string, unknown>;
//#endregion
//#region src/view/templateRuntime.d.ts
interface TemplateNodeLike {
  attribs?: Record<string, string>;
  children?: TemplateNodeLike[];
  data?: string;
  name?: string;
  type?: string;
}
interface TemplateRenderState<T extends TemplateNodeLike> {
  definitions: Map<string, T>;
  definitionScopes?: Map<T, Map<string, T>>;
  definitionWxsScopes?: Map<T, WxsModuleBindings>;
  wxsModules?: WxsModuleBindings;
  stack: string[];
}
//#endregion
//#region src/browser/styles/index.d.ts
export interface BrowserPageStyles {
  /** 按实际遍历顺序去重的项目相对样式依赖。 */
  dependencies: string[];
  /** 已展开本地导入的页面 CSS；不包含嵌套组件样式隔离转换。 */
  cssText: string;
  /** Component 页面的 page-* 隔离选项可关闭隐式 app.wxss。 */
  appWxssEnabled: boolean;
}
/** 读取当前文件内容并展开页面样式依赖，保持 app 在前、页面声明在后的层叠顺序。 */
export declare function resolveBrowserPageStyles(files: BrowserVirtualFiles, route: string, options?: {
  miniprogramRootPath?: string;
  styleIsolation?: string;
}): BrowserPageStyles;
//#endregion
//#region src/browser/render/types.d.ts
interface DomNodeLike$4 {
  attribs?: Record<string, string>;
  children?: DomNodeLike$4[];
  data?: string;
  dataset?: Record<string, unknown>;
  name?: string;
  parent?: DomNodeLike$4 | null;
  type?: string;
}
interface BrowserRenderScope {
  wxs?: WxsModuleBindings;
  alias?: string;
  classList?: string[];
  data: Record<string, any>;
  dataset?: Record<string, unknown>;
  eventBindings?: Map<string, MiniProgramEventBinding>;
  captureEventBindings?: Map<string, MiniProgramEventBinding>;
  getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
  getScopeId: () => string;
  genericComponents?: Map<string, string>;
  hostId?: string;
  hostNode?: DomNodeLike$4;
  listenerScopeId?: string;
  id?: string;
  ownerScopeId?: string;
  slots?: Map<string, BrowserSlotContent[]>;
}
interface BrowserSlotContent {
  instancePath: string;
  node: DomNodeLike$4;
  ownerFilePath: string;
  ownerJsonPath: string;
  scope: BrowserRenderScope;
  templateRenderState: TemplateRenderState<DomNodeLike$4>;
}
interface BrowserRenderedPageTree {
  root: DomNodeLike$4;
  styles: BrowserPageStyles;
  wxml: string;
}
interface BrowserRendererContext {
  changedPageKeys: string[];
  componentCache: Map<string, HeadlessComponentInstance>;
  componentScopes: Map<string, BrowserRenderScope>;
  files: BrowserVirtualFiles;
  moduleLoader: BrowserModuleLoader;
  project: HeadlessProjectDescriptor;
  session: {
    createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
    createMediaQueryObserver: (scope: any) => any;
    requestRender: (callback?: () => void) => void;
    selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
    selectComponentWithin: (scopeId: string, selector: string) => any;
    selectOwnerComponent: (scopeId: string) => any;
  };
}
//#endregion
//#region src/browser/render/index.d.ts
export declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
//#endregion
//#region src/runtime/appInstance.d.ts
export interface HeadlessAppInstance extends Record<string, any> {
  globalData: Record<string, any>;
}
export declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
//#endregion
//#region src/runtime/moduleLoader.d.ts
interface HeadlessModuleLoader {
  close: () => void;
  evaluate: <T>(source: string, args: any[]) => T;
  executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
  executeAppModule: (filePath: string) => HeadlessAppDefinition;
  executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
  wx: HeadlessWx;
}
//#endregion
//#region src/runtime/render/types.d.ts
interface DomNodeLike$3 {
  attribs?: Record<string, string>;
  children?: DomNodeLike$3[];
  data?: string;
  dataset?: Record<string, unknown>;
  name?: string;
  parent?: DomNodeLike$3 | null;
  type?: string;
}
interface RuntimeRenderScope {
  wxs?: WxsModuleBindings;
  alias?: string;
  classList?: string[];
  data: Record<string, any>;
  dataset?: Record<string, unknown>;
  eventBindings?: Map<string, MiniProgramEventBinding>;
  captureEventBindings?: Map<string, MiniProgramEventBinding>;
  getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
  getScopeId: () => string;
  genericComponents?: Map<string, string>;
  hostId?: string;
  hostNode?: DomNodeLike$3;
  listenerScopeId?: string;
  id?: string;
  ownerScopeId?: string;
  slots?: Map<string, RuntimeSlotContent[]>;
}
interface RuntimeSlotContent {
  instancePath: string;
  node: DomNodeLike$3;
  ownerFilePath: string;
  ownerJsonPath: string;
  scope: RuntimeRenderScope;
  templateRenderState: TemplateRenderState<DomNodeLike$3>;
}
interface RuntimeRenderedPageTree {
  root: DomNodeLike$3;
  wxml: string;
}
interface RuntimeRendererContext {
  artifactSource: ArtifactSource;
  changedPageKeys: string[];
  componentCache: Map<string, HeadlessComponentInstance>;
  componentScopes: Map<string, RuntimeRenderScope>;
  moduleLoader: HeadlessModuleLoader;
  project: HeadlessProjectDescriptor;
  session: {
    createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
    createMediaQueryObserver: (scope: any) => any;
    requestRender: (callback?: () => void) => void;
    selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
    selectComponentWithin: (scopeId: string, selector: string) => any;
    selectOwnerComponent: (scopeId: string) => any;
  };
}
//#endregion
//#region src/runtime/render/index.d.ts
export declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
//#endregion
//#region src/view/nativeNode.d.ts
interface HeadlessNativeNode {
  attribs?: Record<string, string>;
  children?: HeadlessNativeNode[];
  name?: string;
  dataset?: Record<string, unknown>;
  data?: string;
  type?: string;
  parent?: HeadlessNativeNode | null;
}
//#endregion
//#region src/runtime/wxState.d.ts
export interface HeadlessWxLoadingSnapshot {
  mask: boolean;
  title: string;
}
export interface HeadlessWxToastSnapshot {
  duration: number;
  icon: string;
  mask: boolean;
  title: string;
}
export interface HeadlessWxPreviewImageSnapshot {
  current: string;
  urls: string[];
  visible: boolean;
}
export interface HeadlessWxOpenDocumentSnapshot {
  filePath: string;
  fileType: string;
  showMenu: boolean;
  visible: boolean;
}
export interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
export interface HeadlessWxShareMenuSnapshot {
  isUpdatableMessage: boolean;
  menus: string[];
  visible: boolean;
  withShareTicket: boolean;
}
export interface HeadlessWxClipboardSnapshot {
  data: string;
}
export interface HeadlessWxActionSheetMockDefinition {
  cancel?: boolean;
  tapIndex?: number;
}
export interface HeadlessWxActionSheetLogEntry {
  itemList: string[];
  result?: HeadlessWxShowActionSheetResult;
}
export interface HeadlessWxModalMockDefinition {
  cancel?: boolean;
  confirm?: boolean;
}
export interface HeadlessWxModalLogEntry {
  cancelColor: string;
  cancelText: string;
  confirmColor: string;
  confirmText: string;
  content: string;
  result: HeadlessWxShowModalResult;
  showCancel: boolean;
  title: string;
}
export interface HeadlessWxRequestMockDefinition {
  /** enableChunked 请求的显式分块，每个 delay 相对于前一个阶段。 */
  chunks?: Array<{
    data: ArrayBuffer;
    delay?: number;
  }>;
  /** 分块发送完成后触发的模拟错误。 */
  error?: string;
  delay?: number;
  header?: Record<string, string>;
  method?: string;
  response: unknown | ((option: HeadlessWxRequestOption) => unknown);
  statusCode?: number;
  url: RegExp | string;
}
export interface HeadlessWxRequestLogEntry {
  data: unknown;
  header: Record<string, string>;
  matched: boolean;
  method: string;
  response?: HeadlessWxRequestSuccessResult;
  url: string;
}
export interface HeadlessWxDownloadFileMockDefinition {
  delay?: number;
  fileContent: string | ((option: HeadlessWxDownloadFileOption) => string);
  header?: Record<string, string>;
  statusCode?: number;
  url: RegExp | string;
}
export interface HeadlessWxDownloadFileLogEntry {
  header: Record<string, string>;
  matched: boolean;
  response?: HeadlessWxDownloadFileSuccessResult;
  tempFilePath?: string;
  url: string;
}
export interface HeadlessWxUploadFileMockDefinition {
  delay?: number;
  header?: Record<string, string>;
  method?: string;
  response: string | Partial<HeadlessWxUploadFileSuccessResult> | ((option: HeadlessWxUploadFileOption & {
    fileContent: string;
  }) => string | Partial<HeadlessWxUploadFileSuccessResult>);
  statusCode?: number;
  url: RegExp | string;
}
export interface HeadlessWxUploadFileLogEntry {
  fileContent: string;
  fileName?: string;
  filePath: string;
  formData: Record<string, unknown>;
  header: Record<string, string>;
  matched: boolean;
  name: string;
  response?: HeadlessWxUploadFileSuccessResult;
  url: string;
}
export interface HeadlessWxStateOptions {
  strictMocks?: boolean;
  readPackageFile?: (filePath: string) => string | undefined;
}
export declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
  close(): void;
  clearStorageSync(): void;
  downloadFile(option: HeadlessWxDownloadFileOption): HeadlessWxRequestTask;
  getActionSheetLogs(): {
    itemList: string[];
    result: {
      errMsg: string;
      tapIndex: number;
    } | undefined;
  }[];
  getDownloadFileLogs(): {
    header: {
      [x: string]: string;
    };
    response: {
      errMsg: string;
      statusCode: number;
      tempFilePath: string;
    } | undefined;
    matched: boolean;
    tempFilePath?: string;
    url: string;
  }[];
  getFileSnapshot(): {
    [k: string]: string;
  };
  getDirectorySnapshot(): string[];
  getFileSystemManager(): HeadlessWxFileSystemManager;
  getSavedFileInfo(option: HeadlessWxGetSavedFileInfoOption): HeadlessWxGetSavedFileInfoSuccessResult;
  getFileInfo(option: HeadlessWxGetFileInfoOption): HeadlessWxGetFileInfoResult;
  getSavedFileList(): HeadlessWxGetSavedFileListSuccessResult;
  getFileText(filePath: string): string | null;
  createTempFile(fileContent: string, preferredPath?: string): string;
  chooseImage(option: {
    count?: number;
    sizeType?: string[];
    sourceType?: string[];
  }): {
    errMsg: string;
    tempFilePaths: string[];
    tempFiles: {
      path: string;
      size: number;
    }[];
  };
  chooseMessageFile(option: HeadlessWxChooseMessageFileOption): HeadlessWxChooseMessageFileResult;
  chooseMedia(option: {
    count?: number;
    maxDuration?: number;
    mediaType?: Array<"image" | "video">;
    sizeType?: string[];
    sourceType?: string[];
  }): {
    errMsg: string;
    tempFiles: ({
      duration: number;
      fileType: "video";
      height: number;
      size: number;
      tempFilePath: string;
      thumbTempFilePath: string;
      width: number;
    } | {
      fileType: "image";
      height: number;
      size: number;
      tempFilePath: string;
      width: number;
      duration?: undefined;
      thumbTempFilePath?: undefined;
    })[];
    type: "image" | "video" | "mix";
  };
  chooseVideo(option: {
    compressed?: boolean;
    maxDuration?: number;
    sourceType?: string[];
  }): {
    duration: number;
    errMsg: string;
    height: number;
    size: number;
    tempFilePath: string;
    width: number;
  };
  compressImage(option: {
    compressedHeight?: number;
    compressedWidth?: number;
    quality?: number;
    src: string;
  }): {
    errMsg: string;
    tempFilePath: string;
  };
  getNetworkType(): HeadlessWxGetNetworkTypeResult;
  getImageInfo(option: HeadlessWxGetImageInfoOption): HeadlessWxGetImageInfoResult;
  getVideoInfo(option: {
    src: string;
  }): {
    bitrate: number;
    duration: number;
    errMsg: string;
    fps: number;
    height: number;
    orientation: "up";
    size: number;
    type: string;
    width: number;
  };
  getModalLogs(): {
    result: {
      cancel: boolean;
      confirm: boolean;
      errMsg: string;
    };
    cancelColor: string;
    cancelText: string;
    confirmColor: string;
    confirmText: string;
    content: string;
    showCancel: boolean;
    title: string;
  }[];
  getRequestLogs(): {
    data: unknown;
    header: {
      [x: string]: string;
    };
    response: {
      cookies: string[];
      data: unknown;
      header: {
        [x: string]: string;
      };
      errMsg: string;
      statusCode: number;
    } | undefined;
    matched: boolean;
    method: string;
    url: string;
  }[];
  getStorageInfoSync(): {
    currentSize: number;
    errMsg: string;
    keys: string[];
    limitSize: number;
  };
  getStorageSnapshot(): {
    [k: string]: unknown;
  };
  getClipboardData(): {
    data: string;
    errMsg: string;
  };
  getClipboardSnapshot(): {
    data: string;
  };
  getStorageSync(key: string): unknown;
  getShareMenu(): {
    isUpdatableMessage: boolean;
    menus: string[];
    visible: boolean;
    withShareTicket: boolean;
  };
  getLoading(): {
    mask: boolean;
    title: string;
  } | null;
  getPreviewImage(): {
    current: string;
    urls: string[];
    visible: boolean;
  } | null;
  getOpenedDocument(): {
    filePath: string;
    fileType: string;
    showMenu: boolean;
    visible: boolean;
  } | null;
  hideShareMenu(): {
    errMsg: string;
  };
  getToast(): {
    duration: number;
    icon: string;
    mask: boolean;
    title: string;
  } | null;
  getUploadFileLogs(): {
    formData: Record<string, unknown>;
    header: {
      [x: string]: string;
    };
    response: {
      data: string;
      errMsg: string;
      statusCode: number;
    } | undefined;
    fileContent: string;
    fileName?: string;
    filePath: string;
    matched: boolean;
    name: string;
    url: string;
  }[];
  hideLoading(): {
    errMsg: string;
  };
  hideToast(): {
    errMsg: string;
  };
  offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
  mockRequest(definition: HeadlessWxRequestMockDefinition): void;
  mockDownloadFile(definition: HeadlessWxDownloadFileMockDefinition): void;
  mockModal(definition?: HeadlessWxModalMockDefinition): void;
  mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
  mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
  onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
  openDocument(option: HeadlessWxOpenDocumentOption): {
    errMsg: string;
  };
  previewImage(option: {
    current?: string;
    urls: string[];
  }): {
    errMsg: string;
  };
  removeStorageSync(key: string): void;
  request(option: HeadlessWxRequestOption): HeadlessWxNetworkRequestTask;
  removeSavedFile(option: HeadlessWxRemoveSavedFileOption): {
    errMsg: string;
  };
  saveImageToPhotosAlbum(option: {
    filePath: string;
  }): {
    errMsg: string;
  };
  saveVideoToPhotosAlbum(option: {
    filePath: string;
  }): {
    errMsg: string;
  };
  saveFile(option: HeadlessWxSaveFileOption): HeadlessWxSaveFileSuccessResult;
  setStorageSync(key: string, value: unknown): void;
  setClipboardData(option: {
    data: string;
  }): {
    errMsg: string;
  };
  setFile(filePath: string, fileContent: string): void;
  setNetworkType(nextNetworkType: HeadlessWxNetworkType): {
    errMsg: string;
    networkType: HeadlessWxNetworkType;
  };
  showActionSheet(option: HeadlessWxShowActionSheetOption): HeadlessWxShowActionSheetResult;
  showShareMenu(option?: HeadlessWxShareMenuOption): {
    errMsg: string;
  };
  showLoading(option: HeadlessWxShowLoadingOption): {
    errMsg: string;
  };
  showModal(option: HeadlessWxShowModalOption): HeadlessWxShowModalResult;
  showToast(option: HeadlessWxShowToastOption): {
    errMsg: string;
  };
  uploadFile(option: HeadlessWxUploadFileOption): HeadlessWxRequestTask;
  updateShareMenu(option?: HeadlessWxShareMenuOption): {
    errMsg: string;
  };
};
//#endregion
//#region src/runtime/session.d.ts
export interface HeadlessSessionOptions {
  globals?: Record<string, unknown>;
  project?: HeadlessProjectDescriptor;
  projectPath?: string;
  strictHostMocks?: boolean;
}
export declare class HeadlessSession {
  readonly project: HeadlessProjectDescriptor;
  private readonly kernel;
  private readonly startupNavigation;
  private appDefinition;
  private appInstance;
  private readonly appLifecycle;
  private readonly moduleLoader;
  private readonly routeEvents;
  private readonly eventListeners;
  private readonly registries;
  private currentPageInstance;
  private readonly pages;
  private readonly componentCache;
  private readonly componentScopes;
  private readonly selectorQueryScopeSnapshots;
  private renderRequestPending;
  private readonly renderRequestCallbacks;
  private readonly tabBarRoutes;
  private readonly tabPages;
  private readonly tabBarItems;
  private readonly tabBarState;
  private tabBarVisible;
  private readonly systemInfo;
  private readonly mediaQueryObservers;
  private readonly canvasContexts;
  private enterOptions;
  private launchOptions;
  private readonly wxState;
  private pullDownRefreshState;
  constructor(options: HeadlessSessionOptions);
  assertActive(): void;
  close(): void;
  getDiagnostics(): RuntimeDiagnosticEntry[];
  on(eventName: string, handler: (...args: any[]) => void): void;
  removeListener(eventName: string, handler: (...args: any[]) => void): void;
  private emit;
  get isClosed(): boolean;
  getApp(): HeadlessAppInstance | null;
  getCurrentPages(): HeadlessPageInstance[];
  getWx(): HeadlessWx;
  /** 在当前小程序实例的上下文执行测试函数，复用应用全局对象与调度器。 */
  evaluateRuntime<T = unknown>(source: string, args?: any[]): T;
  callWxMethod(methodName: string, ...args: any[]): any;
  getCurrentPageNavigationBarTitle(): string | null;
  getCurrentPageNavigationBar(): {
    animation: {
      duration?: number;
      timingFunction?: string;
    } | null;
    backgroundColor: string;
    frontColor: string;
    loading: boolean;
    title: string;
  } | null;
  getCurrentPageBackground(): {
    backgroundColor: string;
    backgroundColorBottom: string;
    backgroundColorTop: string;
    textStyle: HeadlessBackgroundTextStyle;
  } | null;
  getActionSheetLogs(): {
    itemList: string[];
    result: {
      errMsg: string;
      tapIndex: number;
    } | undefined;
  }[];
  getRequestLogs(): {
    data: unknown;
    header: {
      [x: string]: string;
    };
    response: {
      cookies: string[];
      data: unknown;
      header: {
        [x: string]: string;
      };
      errMsg: string;
      statusCode: number;
    } | undefined;
    matched: boolean;
    method: string;
    url: string;
  }[];
  getDownloadFileLogs(): {
    header: {
      [x: string]: string;
    };
    response: {
      errMsg: string;
      statusCode: number;
      tempFilePath: string;
    } | undefined;
    matched: boolean;
    tempFilePath?: string;
    url: string;
  }[];
  getUploadFileLogs(): {
    formData: Record<string, unknown>;
    header: {
      [x: string]: string;
    };
    response: {
      data: string;
      errMsg: string;
      statusCode: number;
    } | undefined;
    fileContent: string;
    fileName?: string;
    filePath: string;
    matched: boolean;
    name: string;
    url: string;
  }[];
  getFileSnapshot(): {
    [k: string]: string;
  };
  getDirectorySnapshot(): string[];
  getFileText(filePath: string): string | null;
  getSavedFileListSnapshot(): HeadlessWxSavedFileInfo[];
  renderCurrentPage(): RuntimeRenderedPageTree;
  dispatchNativeNodeEvent(node: HeadlessNativeNode, eventName: string, event: {
    detail?: unknown;
  }, onHandlerResult?: (result: unknown) => void): boolean;
  requestRender(callback?: () => void): void;
  getScopeSnapshot(scopeId: string): {
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, any>;
    scopeId: string;
    type: "component";
  } | {
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, string>;
    scopeId: string;
    type: "page";
  } | {
    data: any;
    methods: string[];
    properties: {};
    scopeId: string;
    type: "scope";
  } | null;
  getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
  callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
  /** 解析本次交互的实例，后续回调不随重渲染或导航切换所有者。 */
  private resolveScopeMethod;
  callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
  getStorageSnapshot(): {
    [k: string]: unknown;
  };
  getShareMenu(): {
    isUpdatableMessage: boolean;
    menus: string[];
    visible: boolean;
    withShareTicket: boolean;
  };
  selectComponent(selector: string): HeadlessComponentInstance | null;
  selectAllComponents(selector: string): (HeadlessComponentInstance | undefined)[];
  selectComponentWithin(scopeId: string, selector: string): HeadlessComponentInstance | null;
  selectAllComponentsWithin(scopeId: string, selector: string): (HeadlessComponentInstance | undefined)[];
  selectOwnerComponent(scopeId: string): HeadlessComponentInstance | null;
  getTabBar(): {
    visible: boolean;
  };
  getTabBarSnapshot(): {
    items: {
      badge: string | null;
      index: number;
      pagePath: string;
      redDot: boolean;
      text: string | undefined;
    }[];
    visible: boolean;
  };
  getStorageInfo(): {
    currentSize: number;
    errMsg: string;
    keys: string[];
    limitSize: number;
  };
  getClipboardData(): HeadlessWxClipboardSnapshot;
  getPreviewImage(): {
    current: string;
    urls: string[];
    visible: boolean;
  } | null;
  getOpenedDocument(): HeadlessWxOpenDocumentSnapshot | null;
  getPullDownRefreshState(): {
    active: boolean;
    stopCalls: number;
  };
  getSystemInfo(): {
    SDKVersion: string;
    brand: string;
    language: string;
    model: string;
    pixelRatio: number;
    platform: string;
    safeArea: HeadlessWxSafeArea;
    safeAreaInsets: HeadlessWxSafeAreaInsets;
    screenHeight: number;
    screenWidth: number;
    system: string;
    version: string;
    windowHeight: number;
    windowWidth: number;
  };
  getWindowInfo(): HeadlessWxWindowInfoResult;
  getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
  getDeviceInfo(): HeadlessWxDeviceInfoResult;
  getLaunchOptions(): HeadlessWxLaunchOptions;
  getEnterOptions(): HeadlessWxLaunchOptions;
  getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
  getLocation(): HeadlessWxGetLocationResult;
  getNetworkType(): HeadlessWxGetNetworkTypeResult;
  getLoading(): {
    mask: boolean;
    title: string;
  } | null;
  getModalLogs(): {
    result: {
      cancel: boolean;
      confirm: boolean;
      errMsg: string;
    };
    cancelColor: string;
    cancelText: string;
    confirmColor: string;
    confirmText: string;
    content: string;
    showCancel: boolean;
    title: string;
  }[];
  getToast(): {
    duration: number;
    icon: string;
    mask: boolean;
    title: string;
  } | null;
  mockModal(definition?: HeadlessWxModalMockDefinition): void;
  mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
  mockRequest(definition: HeadlessWxRequestMockDefinition): void;
  mockDownloadFile(definition: HeadlessWxDownloadFileMockDefinition): void;
  mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
  setFile(filePath: string, fileContent: string): void;
  setNetworkType(networkType: HeadlessWxNetworkType): {
    errMsg: string;
    networkType: HeadlessWxNetworkType;
  };
  setBackgroundTextStyle(textStyle: string): {
    errMsg: string;
  };
  setBackgroundColor(option: {
    backgroundColor?: string;
    backgroundColorBottom?: string;
    backgroundColorTop?: string;
  }): {
    errMsg: string;
  };
  setNavigationBarTitle(title: string): {
    errMsg: string;
  };
  setNavigationBarColor(option: {
    animation?: {
      duration?: number;
      timingFunction?: string;
    };
    backgroundColor?: string;
    frontColor?: string;
  }): {
    errMsg: string;
  };
  showNavigationBarLoading(): {
    errMsg: string;
  };
  hideNavigationBarLoading(): {
    errMsg: string;
  };
  hideTabBar(): {
    errMsg: string;
  };
  hideTabBarRedDot(index: number): {
    errMsg: string;
  };
  showTabBar(): {
    errMsg: string;
  };
  showTabBarRedDot(index: number): {
    errMsg: string;
  };
  removeTabBarBadge(index: number): {
    errMsg: string;
  };
  setTabBarBadge(index: number, text: string): {
    errMsg: string;
  };
  bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
  private syncRuntimeAppState;
  private bootstrapNavigation;
  reLaunch(url: string): HeadlessPageInstance;
  navigateTo(url: string): HeadlessPageInstance;
  redirectTo(url: string): HeadlessPageInstance;
  navigateBack(delta?: number): HeadlessPageInstance | null;
  switchTab(url: string): HeadlessPageInstance | null;
  private prepareSwitchTab;
  private commitSwitchTab;
  pageScrollTo(option: {
    scrollTop?: number;
    duration?: number;
    selector?: string;
    success?: () => void;
    fail?: (error: Error) => void;
    complete?: () => void;
  }): void;
  triggerAppHide(options: HeadlessWxAppHideOptions): void;
  triggerAppShow(options?: HeadlessWxLaunchOptions): void;
  triggerPullDownRefresh(): HeadlessPageInstance;
  startPullDownRefresh(): {
    errMsg: string;
  };
  triggerReachBottom(): HeadlessPageInstance;
  triggerResize(options: Record<string, any>): HeadlessPageInstance;
  triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
  stopPullDownRefresh(): void;
  private executeSelectorQuery;
  private beginRoute;
  private createFreshPage;
  private runInitialPageLifecycles;
  private isTabBarRoute;
  private requireTabBarItem;
  private removePageInstance;
  private resolveNavigationTarget;
  private unloadAllPages;
  private unloadPage;
  private requireCurrentPage;
  private selectComponentsWithin;
  private detachPageComponents;
  private notifyMediaQueryObservers;
  private clearMediaQueryObservers;
  private runPageComponentLifetime;
  private getComponentScopeId;
  private createVideoContext;
  private createAnimation;
  private resolveCanvasScopeKey;
  private createCanvasContext;
  private canvasToTempFilePath;
  private createIntersectionObserver;
  private createMediaQueryObserver;
}
export declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
//#endregion
//#region src/browser/session.d.ts
export interface BrowserHeadlessSessionOptions {
  files: BrowserVirtualFiles;
  globals?: Record<string, unknown>;
  /** 返回的 Promise 表示宿主 DOM 已提交；普通返回值按同步渲染处理。 */
  onRender?: () => unknown;
  project?: HeadlessProjectDescriptor;
  strictHostMocks?: boolean;
}
export declare class BrowserHeadlessSession {
  readonly files: BrowserVirtualFiles;
  readonly project: HeadlessProjectDescriptor;
  private appDefinition;
  private appInstance;
  private readonly appLifecycle;
  private readonly moduleLoader;
  private readonly onRender?;
  private readonly registries;
  private currentPageInstance;
  private readonly pages;
  private readonly componentCache;
  private readonly componentScopes;
  private readonly selectorQueryScopeSnapshots;
  private renderRequestPending;
  private renderInProgress;
  private readonly renderRequestCallbacks;
  private readonly tabBarRoutes;
  private readonly tabPages;
  private readonly tabBarItems;
  private readonly tabBarState;
  private tabBarVisible;
  private readonly systemInfo;
  private readonly mediaQueryObservers;
  private readonly canvasContexts;
  private enterOptions;
  private launchOptions;
  private readonly kernel;
  private readonly startupNavigation;
  private readonly routeEvents;
  private readonly wxState;
  private pullDownRefreshState;
  constructor(options: BrowserHeadlessSessionOptions);
  assertActive(): void;
  close(): void;
  getDiagnostics(): RuntimeDiagnosticEntry[];
  get isClosed(): boolean;
  getApp(): HeadlessAppInstance | null;
  getCurrentPages(): HeadlessPageInstance[];
  getCurrentPageNavigationBarTitle(): string | null;
  getCurrentPageNavigationBar(): {
    animation: {
      duration?: number;
      timingFunction?: string;
    } | null;
    backgroundColor: string;
    frontColor: string;
    loading: boolean;
    title: string;
  } | null;
  getCurrentPageBackground(): {
    backgroundColor: string;
    backgroundColorBottom: string;
    backgroundColorTop: string;
    textStyle: HeadlessBackgroundTextStyle;
  } | null;
  getActionSheetLogs(): {
    itemList: string[];
    result: {
      errMsg: string;
      tapIndex: number;
    } | undefined;
  }[];
  getRequestLogs(): {
    data: unknown;
    header: {
      [x: string]: string;
    };
    response: {
      cookies: string[];
      data: unknown;
      header: {
        [x: string]: string;
      };
      errMsg: string;
      statusCode: number;
    } | undefined;
    matched: boolean;
    method: string;
    url: string;
  }[];
  getDownloadFileLogs(): {
    header: {
      [x: string]: string;
    };
    response: {
      errMsg: string;
      statusCode: number;
      tempFilePath: string;
    } | undefined;
    matched: boolean;
    tempFilePath?: string;
    url: string;
  }[];
  getUploadFileLogs(): {
    formData: Record<string, unknown>;
    header: {
      [x: string]: string;
    };
    response: {
      data: string;
      errMsg: string;
      statusCode: number;
    } | undefined;
    fileContent: string;
    fileName?: string;
    filePath: string;
    matched: boolean;
    name: string;
    url: string;
  }[];
  getFileSnapshot(): {
    [k: string]: string;
  };
  getDirectorySnapshot(): string[];
  getFileText(filePath: string): string | null;
  getSavedFileListSnapshot(): HeadlessWxSavedFileInfo[];
  getStorageSnapshot(): {
    [k: string]: unknown;
  };
  getShareMenu(): {
    isUpdatableMessage: boolean;
    menus: string[];
    visible: boolean;
    withShareTicket: boolean;
  };
  getTabBar(): {
    visible: boolean;
  };
  getTabBarSnapshot(): {
    items: {
      badge: string | null;
      index: number;
      pagePath: string;
      redDot: boolean;
      text: string | undefined;
    }[];
    visible: boolean;
  };
  getStorageInfo(): {
    currentSize: number;
    errMsg: string;
    keys: string[];
    limitSize: number;
  };
  getClipboardData(): HeadlessWxClipboardSnapshot;
  getPreviewImage(): {
    current: string;
    urls: string[];
    visible: boolean;
  } | null;
  getOpenedDocument(): HeadlessWxOpenDocumentSnapshot | null;
  getPullDownRefreshState(): {
    active: boolean;
    stopCalls: number;
  };
  getSystemInfo(): {
    SDKVersion: string;
    brand: string;
    language: string;
    model: string;
    pixelRatio: number;
    platform: string;
    safeArea: HeadlessWxSafeArea;
    safeAreaInsets: HeadlessWxSafeAreaInsets;
    screenHeight: number;
    screenWidth: number;
    system: string;
    version: string;
    windowHeight: number;
    windowWidth: number;
  };
  getWindowInfo(): HeadlessWxWindowInfoResult;
  getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
  getDeviceInfo(): HeadlessWxDeviceInfoResult;
  getLaunchOptions(): HeadlessWxLaunchOptions;
  getEnterOptions(): HeadlessWxLaunchOptions;
  getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
  getLocation(): HeadlessWxGetLocationResult;
  getNetworkType(): HeadlessWxGetNetworkTypeResult;
  getLoading(): {
    mask: boolean;
    title: string;
  } | null;
  getModalLogs(): {
    result: {
      cancel: boolean;
      confirm: boolean;
      errMsg: string;
    };
    cancelColor: string;
    cancelText: string;
    confirmColor: string;
    confirmText: string;
    content: string;
    showCancel: boolean;
    title: string;
  }[];
  getToast(): {
    duration: number;
    icon: string;
    mask: boolean;
    title: string;
  } | null;
  mockModal(definition?: HeadlessWxModalMockDefinition): void;
  mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
  mockRequest(definition: HeadlessWxRequestMockDefinition): void;
  mockDownloadFile(definition: HeadlessWxDownloadFileMockDefinition): void;
  mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
  setFile(filePath: string, fileContent: string): void;
  setNetworkType(networkType: HeadlessWxNetworkType): {
    errMsg: string;
    networkType: HeadlessWxNetworkType;
  };
  setBackgroundTextStyle(textStyle: string): {
    errMsg: string;
  };
  setBackgroundColor(option: {
    backgroundColor?: string;
    backgroundColorBottom?: string;
    backgroundColorTop?: string;
  }): {
    errMsg: string;
  };
  setNavigationBarTitle(title: string): {
    errMsg: string;
  };
  setNavigationBarColor(option: {
    animation?: {
      duration?: number;
      timingFunction?: string;
    };
    backgroundColor?: string;
    frontColor?: string;
  }): {
    errMsg: string;
  };
  showNavigationBarLoading(): {
    errMsg: string;
  };
  hideNavigationBarLoading(): {
    errMsg: string;
  };
  hideTabBar(): {
    errMsg: string;
  };
  hideTabBarRedDot(index: number): {
    errMsg: string;
  };
  showTabBar(): {
    errMsg: string;
  };
  showTabBarRedDot(index: number): {
    errMsg: string;
  };
  removeTabBarBadge(index: number): {
    errMsg: string;
  };
  setTabBarBadge(index: number, text: string): {
    errMsg: string;
  };
  getScopeSnapshot(scopeId: string): {
    data: any;
    methods: string[];
    properties: any;
    scopeId: string;
    type: "component";
  } | {
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, string>;
    scopeId: string;
    type: "page";
  } | {
    data: any;
    methods: string[];
    properties: {};
    scopeId: string;
    type: "scope";
  } | null;
  getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
  selectComponent(selector: string): any;
  selectAllComponents(selector: string): any[];
  selectComponentWithin(scopeId: string, selector: string): any;
  selectAllComponentsWithin(scopeId: string, selector: string): any[];
  selectOwnerComponent(scopeId: string): any;
  private selectComponentsWithin;
  renderCurrentPage(): BrowserRenderedPageTree;
  dispatchNativeNodeEvent(node: HeadlessNativeNode, eventName: string, event: {
    detail?: unknown;
  }, onHandlerResult?: (result: unknown) => void): boolean;
  requestRender(callback?: () => void): void;
  callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
  /** 解析本次交互的实例，后续回调不随重渲染或导航切换所有者。 */
  private resolveScopeMethod;
  callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
  callTapBinding(scopeId: string, methodName: string): any;
  callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
    currentTarget?: {
      dataset?: Record<string, unknown>;
      id?: string;
    };
    dataset?: Record<string, unknown>;
    id?: string;
    mark?: Record<string, unknown>;
    target?: {
      dataset?: Record<string, unknown>;
      id?: string;
    };
  }): any;
  bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
  private bootstrapNavigation;
  reLaunch(url: string): HeadlessPageInstance;
  navigateTo(url: string): HeadlessPageInstance;
  redirectTo(url: string): HeadlessPageInstance;
  navigateBack(delta?: number): HeadlessPageInstance | null;
  switchTab(url: string): HeadlessPageInstance | null;
  private prepareSwitchTab;
  private commitSwitchTab;
  pageScrollTo(option: {
    duration?: number;
    selector?: string;
    scrollTop?: number;
  }): void;
  triggerAppHide(options: HeadlessWxAppHideOptions): void;
  triggerAppShow(options?: HeadlessWxLaunchOptions): void;
  triggerPullDownRefresh(): HeadlessPageInstance;
  startPullDownRefresh(): {
    errMsg: string;
  };
  triggerReachBottom(): HeadlessPageInstance;
  triggerResize(options: Record<string, any>): HeadlessPageInstance;
  triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
  stopPullDownRefresh(): void;
  private executeSelectorQuery;
  private beginRoute;
  private createFreshPage;
  private runInitialPageLifecycles;
  private isTabBarRoute;
  private removePageInstance;
  private resolveNavigationTarget;
  private requireTabBarItem;
  private unloadAllPages;
  private unloadPage;
  private requireCurrentPage;
  private detachPageComponents;
  private notifyMediaQueryObservers;
  private clearMediaQueryObservers;
  private runPageComponentLifetime;
  private getComponentScopeId;
  private createVideoContext;
  private createAnimation;
  private resolveCanvasScopeKey;
  private createCanvasContext;
  private canvasToTempFilePath;
  private createIntersectionObserver;
  private createMediaQueryObserver;
}
export declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
//#endregion
//#region src/testing/pageWait.d.ts
export interface HeadlessTestingWaitOptions {
  interval?: number;
  timeout?: number;
}
export type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
export interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
  state?: 'attached' | 'detached';
}
export interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
  data: (path?: string) => Promise<unknown>;
  findOne: (selector: string) => Promise<NodeHandle | null>;
  selectComponent: (selector: string) => Promise<ScopeHandle | null>;
  selectComponents: (selector: string) => Promise<ScopeHandle[]>;
  waitFor: (ms?: number) => Promise<void>;
  wxml: () => Promise<string>;
}
export declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
export declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
export declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
export declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
export declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
export declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
//#endregion
//#region src/view/render.d.ts
interface DomNodeLike$2 {
  attribs?: Record<string, string>;
  children?: DomNodeLike$2[];
  data?: string;
  dataset?: Record<string, unknown>;
  name?: string;
  parent?: DomNodeLike$2 | null;
  type?: string;
}
export interface RenderedPageTree {
  root: DomNodeLike$2;
  wxml: string;
}
export declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
//#endregion
//#region src/view/selectorQuery.d.ts
interface DomNodeLike$1 {
  attribs?: Record<string, string>;
  children?: DomNodeLike$1[];
  data?: string;
  dataset?: Record<string, unknown>;
  name?: string;
  parent?: DomNodeLike$1 | null;
  type?: string;
}
export interface HeadlessSelectorQueryResolverOptions {
  page: HeadlessPageInstance;
  resolveContext?: (node: DomNodeLike$1) => unknown;
  root: DomNodeLike$1;
  windowInfo: HeadlessWxWindowInfoResult;
}
export declare function resolveSelectorScrollTop(root: DomNodeLike$1, selector?: string | null): number | null;
export declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
export declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
//#endregion
//#region src/view/selectors.d.ts
interface DomNodeLike {
  attribs?: Record<string, string>;
  children?: DomNodeLike[];
  data?: string;
  name?: string;
  parent?: DomNodeLike | null;
  type?: string;
}
export declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
//#endregion
//#region src/testing/rendered.d.ts
export interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
  componentSelectors?: string[];
  fallback?: boolean;
  routeOnly?: boolean;
}
export interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
  componentSelectors?: string[];
  dataset?: Record<string, boolean | number | string>;
  predicate?: (wxml: string) => boolean;
  selector?: string;
  text?: string;
}
export interface HeadlessTestingRenderedNodeSnapshot {
  bottom?: number;
  dataset?: Record<string, unknown>;
  height?: number;
  id?: string;
  left?: number;
  right?: number;
  top?: number;
  width?: number;
}
export type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
export interface HeadlessTestingRenderedPageAccess {
  assertActive: () => void;
  findAll: (selector: string) => Promise<HeadlessTestingNodeHandle[]>;
  waitFor: (ms?: number) => Promise<void>;
  wxml: () => Promise<string>;
}
export declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
export declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
export declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
//#endregion
//#region src/testing/logicalSnapshot.d.ts
export interface HeadlessTestingLogicalNode {
  attrs: Record<string, string>;
  children: HeadlessTestingLogicalNode[];
  nodeId?: string;
  tag?: string;
  text: string;
  type: 'element' | 'text';
}
export interface HeadlessTestingPageSnapshot {
  data: Record<string, any>;
  path: string;
  query: Record<string, string>;
  root: HeadlessTestingLogicalNode;
  wxml: string;
}
export declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
//#endregion
//#region src/testing/pageHandle.d.ts
export interface HeadlessTestingPageCallMethodOptions {
  fallback?: boolean;
  routeOnly?: boolean;
  timeout?: number;
}
export declare class HeadlessTestingPageHandle {
  private readonly project;
  private readonly page;
  private readonly session?;
  constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
  /** 返回底层页面实例身份；重新获取 handle 不会改变该身份。 */
  get pageId(): number;
  get path(): string;
  get query(): {
    [x: string]: string;
  };
  private resolveDataByPath;
  assertActive(): void;
  private createScopeHandle;
  callMethod(methodName: string, ...args: any[]): Promise<any>;
  callMethodWithOptions(methodName: string, options?: HeadlessTestingPageCallMethodOptions, ...args: any[]): Promise<any>;
  data(path?: string): Promise<any>;
  setData(data: Record<string, unknown>): Promise<void>;
  selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
  selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
  waitFor(ms?: number): Promise<void>;
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
  getElementsByXpath(expression: string): Promise<HeadlessTestingNodeHandle[]>;
  renderedNodes(selector: string, options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
  renderedSelectorNodes(selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
  waitForRendered(options?: HeadlessTestingRenderedOptions): Promise<string>;
  waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
  waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
  waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
  waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
  waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
  waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<{}>;
  wxml(): Promise<string>;
  snapshot(): Promise<HeadlessTestingPageSnapshot>;
  private renderedAccess;
  private waitAccess;
}
//#endregion
//#region src/testing/sessionHandle/scope.d.ts
export declare class HeadlessTestingScopeHandle {
  readonly scopeId: string;
  private readonly project;
  private readonly session;
  constructor(scopeId: string, project: HeadlessProjectDescriptor, session: HeadlessSession);
  private createScopeHandle;
  callMethod(methodName: string, ...args: any[]): Promise<any>;
  snapshot(): Promise<{
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, any>;
    scopeId: string;
    type: "component";
  } | {
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, string>;
    scopeId: string;
    type: "page";
  } | {
    data: any;
    methods: string[];
    properties: {};
    scopeId: string;
    type: "scope";
  } | null>;
  page(): Promise<HeadlessTestingPageHandle | null>;
  pageScope(): Promise<HeadlessTestingScopeHandle>;
  ownerComponent(): Promise<HeadlessTestingScopeHandle | null>;
  waitForOwnerComponent(options?: {
    interval?: number;
    timeout?: number;
  }): Promise<HeadlessTestingScopeHandle>;
  selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
  selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
  waitForComponent(selector: string, options?: {
    interval?: number;
    timeout?: number;
  }): Promise<HeadlessTestingScopeHandle>;
  waitForComponents(selector: string, count?: number, options?: {
    interval?: number;
    timeout?: number;
  }): Promise<HeadlessTestingScopeHandle[]>;
}
//#endregion
//#region src/testing/sessionHandle/index.d.ts
interface HeadlessTestingProtocolOptions {
  timeout?: number;
}
type HeadlessTestingEvaluator<T = unknown> = ((...args: any[]) => T | PromiseLike<T>) | string;
interface HeadlessTestingToolInfo {
  version: 'mpcore-simulator';
}
export declare class HeadlessTestingSessionHandle {
  private readonly project;
  private readonly session;
  private readonly pendingNavigations;
  constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
  close(): Promise<void>;
  /** 无头会话独占本地 runtime；同步释放与 automator 的连接清理契约一致。 */
  disconnect(): void;
  toolInfo(): Promise<HeadlessTestingToolInfo>;
  on(eventName: string, handler: (...args: any[]) => void): this;
  removeListener(eventName: string, handler: (...args: any[]) => void): this;
  off(eventName: string, handler: (...args: any[]) => void): this;
  evaluate<T = unknown>(evaluator: HeadlessTestingEvaluator<T>, ...args: any[]): Promise<T>;
  evaluateWithOptions<T = unknown>(evaluator: HeadlessTestingEvaluator<T>, options?: HeadlessTestingProtocolOptions, ...args: any[]): Promise<T>;
  currentPage(): Promise<HeadlessTestingPageHandle | null>;
  getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
  callWxMethod<T = unknown>(methodName: string, ...args: any[]): Promise<T>;
  callWxMethodWithOptions<T = unknown>(methodName: string, options?: HeadlessTestingProtocolOptions, ...args: any[]): Promise<T>;
  /** 返回与 DevTools automator 兼容的运行时系统信息。 */
  systemInfo<T = unknown>(): Promise<T>;
  scopeSnapshot(scopeId: string): Promise<{
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, any>;
    scopeId: string;
    type: "component";
  } | {
    data: Record<string, any>;
    methods: string[];
    properties: Record<string, string>;
    scopeId: string;
    type: "page";
  } | {
    data: any;
    methods: string[];
    properties: {};
    scopeId: string;
    type: "scope";
  } | null>;
  selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
  selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
  waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
  waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
  reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
  navigateTo(route: string): Promise<HeadlessTestingPageHandle>;
  redirectTo(route: string): Promise<HeadlessTestingPageHandle>;
  navigateBack(delta?: number): Promise<HeadlessTestingPageHandle | null>;
  switchTab(route: string): Promise<HeadlessTestingPageHandle>;
  waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
  pageScrollTo(scrollTop: number): Promise<void>;
  triggerAppHide(options: HeadlessWxAppHideOptions): Promise<void>;
  triggerAppShow(options?: HeadlessWxLaunchOptions): Promise<void>;
  triggerPullDownRefresh(): Promise<void>;
  triggerReachBottom(): Promise<void>;
  triggerResize(options: Record<string, any>): Promise<void>;
  triggerRouteDone(options?: Record<string, any>): Promise<void>;
  private invokeNavigation;
  private requireCurrentPage;
  private evaluateInRuntime;
}
//#endregion
//#region src/testing/launch.d.ts
export interface HeadlessTestingLaunchOptions {
  projectPath: string;
  configureSession?: (session: HeadlessSession) => void | Promise<void>;
  onSessionCreated?: (session: HeadlessTestingSessionHandle) => void | Promise<void>;
}
export declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
//#endregion
export type { BrowserRenderedPageTree, BrowserRendererContext, CreateComponentInstanceOptions, HeadlessComponentInstance, HeadlessTestingToolInfo, HeadlessWxGetLogManagerOption, HeadlessWxLogManager, RuntimeRenderedPageTree, RuntimeRendererContext };