import type {} from '../jsx'

/** 当前 @rue-js/runtime 包版本，由构建流程注入。 */
export declare const version: string;
/** Rue DOMAdapter 使用的最小节点形态。 */
export interface DomNodeLike {
	/** 当前节点的下一个兄弟节点。 */
	nextSibling?: DomNodeLike | null;
	/** 当前节点的第一个子节点。 */
	firstChild?: DomNodeLike | null;
}
/** Rue DOMAdapter 使用的最小元素形态。 */
export interface DomElementLike extends DomNodeLike {
	/** 元素 HTML 内容；非浏览器宿主可以按需实现。 */
	innerHTML?: any;
}
/** 默认渲染桥的目标位置。 */
export type RenderTarget = {
	/** 清空并填充整个容器。 */
	kind: "container";
	/** 目标容器节点。 */
	container: DomElementLike;
} | {
	/** 只替换 start/end 两个锚点之间的内容。 */
	kind: "between";
	/** start/end 所在父节点。 */
	parent: DomElementLike;
	/** 区间起始锚点，渲染时会保留。 */
	start: DomNodeLike;
	/** 区间结束锚点，新的节点会插入到它之前。 */
	end: DomNodeLike;
} | {
	/** 在单个尾锚点之前渲染，可重复更新。 */
	kind: "anchor";
	/** anchor 所在父节点。 */
	parent: DomElementLike;
	/** 尾锚点，新的节点会插入到它之前。 */
	anchor: DomNodeLike;
} | {
	/** 在临时锚点前执行静态渲染，完成后会移除锚点。 */
	kind: "static";
	/** anchor 所在父节点。 */
	parent: DomElementLike;
	/** 一次性静态渲染锚点。 */
	anchor: DomNodeLike;
};
/** 可直接挂载到 RenderTarget 的块实例。 */
export interface BlockInstance {
	/** 固定协议标记，用于区分普通函数和块实例。 */
	readonly kind: "block";
	/** 将块内容挂载到指定目标。 */
	mount(target: RenderTarget): void;
	/** 与块绑定的清理回调集合，会在替换或卸载时执行。 */
	cleanupBucket?: Array<() => void>;
	/** 可选卸载钩子，通常用于释放事件监听或外部资源。 */
	unmount?(): void;
}
/** 延迟创建 BlockInstance 的工厂函数。 */
export interface BlockFactory {
	/** 创建新的块实例；每次挂载都应返回独立实例。 */
	(): BlockInstance;
	/** 固定协议标记，用于 normalizeRenderable 识别。 */
	readonly kind: "block-factory";
}
/** 规范化后的默认渲染值，只保留运行时能安全处理的形态。 */
export type NormalizedRenderable = DomNodeLike | BlockFactory | BlockInstance | ReadonlyArray<NormalizedRenderable>;
/** normalizeRenderable 的判别式返回值。 */
export type NormalizeRenderableResult = {
	/** 输入已经成功转换为可渲染值。 */
	kind: "renderable";
	/** 可直接交给 renderable bridge 挂载的值。 */
	value: NormalizedRenderable;
} | {
	/** 输入是默认运行时不再接受的对象形态。 */
	kind: "unsupported-object";
	/** 原始输入值，供调用方决定是否抛错或走兼容路径。 */
	value: unknown;
};
/** 组件、块和手写 render 可返回的默认渲染值集合。 */
export type Renderable = string | number | boolean | null | undefined | DomNodeLike | BlockFactory | BlockInstance | ReadonlyArray<Renderable>;
/** onErrorCaptured 注册的处理器；返回 false 表示错误已被消费。 */
export type ErrorCapturedHook = (error: any, instance?: any, info?: string) => boolean | void;
/** 注册组件树错误捕获回调，返回取消注册函数。 */
export declare const onErrorCaptured: (fn: ErrorCapturedHook) => (() => void) | undefined;
/** JSX/组件 props 的通用结构，允许任意属性和 children。 */
export interface ComponentProps {
	/** 组件或元素属性。 */
	[key: string]: any;
	/** JSX 子节点。 */
	children?: ChildInput;
}
/** Wasm/runtime-vapor 返回的可挂载句柄集合。 */
export type RueMountHandle = {
	/** 传统 mount handle 标识。 */
	__rue_mount_id: unknown;
} | {
	/** portable component 的组件类型或类型标识。 */
	__rue_component_type: unknown;
	/** portable component 的 props 快照。 */
	props?: unknown;
} | {
	/** vapor setup 函数句柄。 */
	__rue_vapor_setup: unknown;
};
/** 默认 runtime 可接受的顶层渲染输入。 */
export type RenderableInput = Renderable | RueMountHandle | ReadonlyArray<RenderableInput>;
/** 组件和 JSX 工厂可返回的渲染输出。 */
export type RenderableOutput = Renderable | RueMountHandle | ReadonlyArray<RenderableOutput>;
/** Vapor setup 返回的 DOM 节点。 */
export type VaporSetupResult = DomNodeLike;
export type Child = RenderableOutput;
export type ChildInput = Child | ReadonlyArray<ChildInput>;
/** 给组件 props 自动附加 children 字段。 */
export type PropsWithChildren<P = {}> = P & {
	children?: ChildInput;
};
/** Rue 函数组件类型。 */
export type FC<P = {}> = (props: PropsWithChildren<P>) => RenderableOutput;
/** 组件实例类型，当前等价于函数组件。 */
export type ComponentInstance<P = {}> = FC<P>;
/** Rue runtime 实例类型；底层由 Wasm 工厂返回，暂以 any 兼容。 */
export type Rue = any;
/** 创建元素（JSX 工厂同源）
 * @param type 标签字符串或组件实例
 * @param props 属性对象
 * @param children 子元素集合
 */
export declare const createElement: <P = {}>(type: string | ComponentInstance<P>, props: ComponentProps | null, ...children: ChildInput[]) => RenderableOutput;
/** 渲染到容器；支持默认 renderable 和 Wasm mount handle 两条路径。 */
export declare const render: (value: RenderableInput, container: DomElementLike) => any;
/** 在区间 [start,end] 之间渲染，并保留区间两端锚点。 */
export declare const renderBetween: (value: RenderableInput, parent: DomElementLike, start: DomNodeLike, end: DomNodeLike) => any;
/** 在单个尾锚点前渲染，可重复更新同一锚点前的内容，patch 阶段不向外层 effect 泄露依赖。 */
export declare const renderAnchor: (value: RenderableInput, parent: DomElementLike, anchor: DomNodeLike) => any;
/** 在单个临时锚点前执行一次性静态渲染，完成后可移除锚点。 */
export declare const renderStatic: (value: RenderableInput, parent: DomElementLike, anchor: DomNodeLike) => any;
/** 挂载组件应用到容器或选择器。 */
export declare const mount: (App: ComponentInstance, container: string | DomElementLike) => any;
/** 安装 Rue 插件。 */
export declare const use: (plugin: any, ...options: any[]) => any;
/** 根据 props 生成组件事件发射器，并兼容 Custom Element emit bridge。 */
export declare const useEmit: (props: ComponentProps) => (eventName: string, ...args: unknown[]) => void;
/** 创建 Vapor 块挂载句柄，setup 会在 runtime-vapor 作用域内执行。 */
export declare const vapor: (setup: (parentContext?: DomElementLike | null) => VaporSetupResult) => RenderableOutput;
/** 生命周期：创建前 */
export declare const onBeforeCreate: (fn: () => void) => any;
/** 生命周期：已创建 */
export declare const onCreated: (fn: () => void) => any;
/** 生命周期：挂载前 */
export declare const onBeforeMount: (fn: () => void) => any;
/** 生命周期：已挂载 */
export declare const onMounted: (fn: () => void) => any;
/** 生命周期：缓存实例已激活 */
export declare const onActivated: (fn: () => void) => any;
/** 生命周期：更新前 */
export declare const onBeforeUpdate: (fn: () => void) => any;
/** 生命周期：已更新 */
export declare const onUpdated: (fn: () => void) => any;
/** 调试钩子：渲染依赖触发组件更新时调用。 */
export declare const onRenderTriggered: (fn: (event: any) => void) => any;
/** 生命周期：卸载前 */
export declare const onBeforeUnmount: (fn: () => void) => any;
/** 生命周期：已卸载 */
export declare const onUnmounted: (fn: () => void) => any;
/** 生命周期：缓存实例已停用 */
export declare const onDeactivated: (fn: () => void) => any;
/** 生命周期：服务端渲染预取 */
export declare const onServerPrefetch: (fn: () => Promise<any> | any) => any;
/** 执行当前上下文的服务端预取钩子。 */
export declare const runServerPrefetch: () => any;
/** 错误处理钩子 */
export declare const onError: (fn: (error: any, instance?: any) => void) => any;
/** 获取当前容器（挂载上下文） */
export declare const getCurrentContainer: () => any;
/** 直接创建独立 Rue 实例，并绑定当前 DOMAdapter bridge。 */
export declare function createRue(): any;
/** JSX/TSX 工厂函数：与 createElement 同源
 * @param type 标签字符串或组件函数
 * @param props 属性对象
 * @param children 子节点集合
 * @returns RenderableOutput
 */
export declare function h<P = {}>(type: string | ComponentInstance<P>, props: ComponentProps | null, ...children: ChildInput[]): RenderableOutput;
export declare function jsx<P = {}>(type: string | ComponentInstance<P>, props?: ComponentProps | null, key?: unknown): RenderableOutput;
export declare const jsxs: typeof jsx;
export declare function jsxDEV<P = {}>(type: string | ComponentInstance<P>, props?: ComponentProps | null, key?: unknown): RenderableOutput;
/** JSX Fragment 标记，最终由底层 runtime 识别为片段渲染。 */
export declare const Fragment = "fragment";
/** 将任意默认运行时输入转换为安全可挂载的 NormalizedRenderable。 */
export declare const normalizeRenderable: (value: unknown) => NormalizeRenderableResult;
/** 创建应用管理器
 * @param AppOrOptions 组件或 {setup, render} 配置
 * @param runtime 可选自定义 Rue 实例
 * @returns 含 use/component/mount/unmount 的应用控制对象
 */
export declare function useApp(AppOrOptions: ComponentInstance | {
	/** 应用级 setup，返回值会传给 render。 */
	setup?: () => any;
	/** 应用级 render，接收 setup 返回的上下文。 */
	render?: (ctx: any) => RenderableOutput;
}, runtime?: Rue): {
	/** 安装插件到应用，并返回 app 以支持链式调用。 */
	use(plugin: any, ...options: any[]): any;
	/** 注册运行时组件名，供 <component is="Foo" /> 解析使用。 */
	component(name: string, component: ComponentInstance): any;
	/** 挂载应用到容器，容器可以是选择器字符串或元素对象。 */
	mount(container: string | DomElementLike): void;
	/** 从上一次 mount 的容器卸载应用并释放容器引用。 */
	unmount(): void;
};
/** useCustomElement 的包装配置。 */
export interface CustomElementsOptions {
	/** 需要注入到 shadow root 或 host 的样式文本。 */
	styles?: string[];
	/** 自定义元素创建内部 app 后的配置回调，可安装插件或注册组件。 */
	configureApp?: (app: ReturnType<typeof useApp>) => void;
	/** 是否使用 shadow root 承载组件，默认 true。 */
	shadowRoot?: boolean;
	/** 注入 style 标签时使用的 CSP nonce。 */
	nonce?: string;
}
/** Rue 自定义元素实例，额外暴露 props bag。 */
export interface RueCustomElement<P = Record<string, unknown>> extends HTMLElement {
	/** 外部可批量设置的 props 对象，会与 attribute / own property 合并。 */
	props: Partial<P>;
}
/** useCustomElement 返回的 Custom Element 构造器。 */
export type RueCustomElementConstructor<P = Record<string, unknown>> = {
	new (): RueCustomElement<P>;
};
export type CustomElementComponent<P = Record<string, unknown>> = ComponentInstance<P> | {
	setup?: (props: Partial<P>) => any;
	render?: (ctx: any) => RenderableOutput;
};
/** 获取当前自定义元素宿主；不在自定义元素上下文中时尝试从当前容器反查。 */
export declare const useHost: () => HTMLElement | null;
/** 获取当前自定义元素的 shadow root；light DOM 模式下返回 null。 */
export declare const useShadowRoot: () => ShadowRoot | null;
/** 将 Rue 组件包装成原生 Custom Element 构造器。 */
export declare function useCustomElement<P = Record<string, unknown>>(component: CustomElementComponent<P>, options?: CustomElementsOptions): RueCustomElementConstructor<P>;
export interface ContextProviderProps<T> {
	/** 向后代提供的 context 值，允许是 ref、函数或任意对象引用。 */
	value: T;
	/** Provider 包裹的子节点。 */
	children?: ComponentProps["children"];
}
/** createContext 返回的上下文对象。 */
export interface RueContext<T> {
	/** Provider 组件，用于在组件树中写入当前 context 值。 */
	Provider: (props: ContextProviderProps<T>) => unknown;
	/** 没有祖先 Provider 时 useContext 返回的默认值。 */
	defaultValue: T;
}
/** 创建可跨组件树传递值的 Rue context。 */
export declare const createContext: <T>(defaultValue: T) => RueContext<T>;
/** 从当前组件 owner 向上查找 context 值，未命中时返回默认值。 */
export declare const useContext: <T>(context: RueContext<T>) => T;
/** 传给 scoped slot 函数的参数对象。 */
export type SlotRenderProps = Record<string, unknown>;
/** 单个 slot 的值，可以是静态渲染输出或 scoped slot 函数。 */
export type SlotValue = RenderableOutput | ((props: SlotRenderProps) => RenderableOutput);
/** 按 slot 名分组的插槽表。 */
export type SlotBag = Record<string, SlotValue | undefined>;
/** Slot 组件属性。 */
export interface SlotProps extends PropsWithChildren<Record<string, unknown>> {
	/** 插槽名，默认 default。 */
	name?: string;
	/** 传给 scoped slot 的参数。 */
	props?: SlotRenderProps;
	/** 显式插槽来源；未传入时读取当前实例 propsRO。 */
	source?: Record<string, unknown> | null;
}
/** 渲染命名插槽或默认插槽，缺失时渲染 fallback children。 */
export declare const Slot: FC<SlotProps>;
/** <Component> 动态组件属性。 */
export interface DynamicComponentProps extends PropsWithChildren<Record<string, unknown>> {
	/** 目标标签名、已注册组件名或组件函数。 */
	is?: string | ComponentInstance<any> | null;
}
/** 根据 is 属性动态渲染原生标签或已注册组件。 */
export declare const Component: FC<DynamicComponentProps>;
/** KeepAlive 的 include/exclude 匹配模式。 */
export type KeepAliveMatchPattern = string | RegExp | Array<string | RegExp>;
/** KeepAlive 组件属性。 */
export interface KeepAliveProps extends PropsWithChildren<Record<string, unknown>> {
	/** 只缓存命中名称的子组件。字符串支持逗号分隔。 */
	include?: KeepAliveMatchPattern;
	/** 不缓存命中名称的子组件。字符串支持逗号分隔。 */
	exclude?: KeepAliveMatchPattern;
	/** 最大缓存数量，超出后按 LRU 淘汰。 */
	max?: number | string;
}
/** 缓存直接子组件 DOM range，切换时移动到离线片段而不是销毁。 */
export declare const KeepAlive: FC<KeepAliveProps>;
/** Suspense 组件属性。 */
export interface SuspenseProps extends PropsWithChildren<Record<string, unknown>> {
	/** pending 时显示的兜底内容。 */
	fallback?: unknown;
	/** 已有 resolved 内容时，延迟显示 fallback 的毫秒数。 */
	timeout?: number | string;
	/** 进入 pending 状态时触发。 */
	onPending?: () => void;
	/** pending 完成并显示内容时触发。 */
	onResolve?: () => void;
	/** fallback 实际显示时触发。 */
	onFallback?: () => void;
}
/** 为异步子树提供 pending 捕获、fallback 渲染和 resolved 内容恢复。 */
export declare const Suspense: FC<SuspenseProps>;
/** Template 组件属性；运行时只关心 children。 */
export type TemplateProps = PropsWithChildren<Record<string, unknown>>;
/** 无包装渲染 children 的模板占位组件。 */
export declare const Template: FC<TemplateProps>;
/** Teleport 组件属性。 */
export interface TeleportProps {
	/** 目标容器选择器或元素。 */
	to?: string | HTMLElement;
	/** 为 true 时禁用传送，内容留在原位置渲染。 */
	disabled?: boolean;
	/** 预留延迟解析目标的兼容属性。 */
	defer?: boolean;
	/** 需要传送的子内容。 */
	children?: any;
}
/** 将子内容渲染到指定 DOM 目标，并在卸载时清理目标区间。 */
export declare const Teleport: FC<TeleportProps>;
/** 浏览器过渡结束事件类型。 */
export type TransitionType = "transition" | "animation";
/** Rue 过渡阶段。 */
export type TransitionPhase = "enter" | "leave" | "appear";
declare function addClass(el: HTMLElement, cls?: string): void;
declare function removeClass(el: HTMLElement, cls?: string): void;
declare function nextFrame(fn: () => void): void;
declare function forceReflow(el?: HTMLElement): number;
declare function toMs(val: string): number;
declare function inferType(el: HTMLElement, expected?: TransitionType): TransitionType | null;
declare function resolveDuration(el: HTMLElement, expected: TransitionType | undefined, specified: number | {
	enter: number;
	leave: number;
} | undefined, phase: TransitionPhase): number;
declare function whenTransitionEnds(el: HTMLElement, type: TransitionType | null, timeout: number, cb: () => void): void;
/** Transition 与 TransitionGroup 共享的过渡配置。 */
export interface BaseTransitionProps {
	/** CSS 类名前缀，默认 `rue`。 */
	name?: string;
	/** 显式指定监听 transition 还是 animation；未传入时从样式推断。 */
	type?: TransitionType;
	/** 是否启用 CSS class 驱动；为 false 时只执行 JS 钩子。 */
	css?: boolean;
	/** 首次渲染时是否执行 appear 过渡。 */
	appear?: boolean;
	/** 显式过渡时长，优先于样式推断。 */
	duration?: number | {
		enter: number;
		leave: number;
	};
	/** enter 阶段初始类名。 */
	enterFromClass?: string;
	/** enter 阶段激活类名。 */
	enterActiveClass?: string;
	/** enter 阶段结束类名。 */
	enterToClass?: string;
	/** leave 阶段初始类名。 */
	leaveFromClass?: string;
	/** leave 阶段激活类名。 */
	leaveActiveClass?: string;
	/** leave 阶段结束类名。 */
	leaveToClass?: string;
	/** appear 阶段初始类名，默认复用 enterFromClass。 */
	appearFromClass?: string;
	/** appear 阶段激活类名，默认复用 enterActiveClass。 */
	appearActiveClass?: string;
	/** appear 阶段结束类名，默认复用 enterToClass。 */
	appearToClass?: string;
	/** enter 前钩子。 */
	onBeforeEnter?: (el: HTMLElement) => void;
	/** enter 钩子；接管动画时需要调用 done。 */
	onEnter?: (el: HTMLElement, done: () => void) => void;
	/** enter 完成钩子。 */
	onAfterEnter?: (el: HTMLElement) => void;
	/** enter 取消钩子，预留给上层兼容。 */
	onEnterCancelled?: (el: HTMLElement) => void;
	/** leave 前钩子。 */
	onBeforeLeave?: (el: HTMLElement) => void;
	/** leave 钩子；接管动画时需要调用 done。 */
	onLeave?: (el: HTMLElement, done: () => void) => void;
	/** leave 完成钩子。 */
	onAfterLeave?: (el: HTMLElement) => void;
	/** leave 取消钩子，预留给上层兼容。 */
	onLeaveCancelled?: (el: HTMLElement) => void;
	/** appear 前钩子。 */
	onBeforeAppear?: (el: HTMLElement) => void;
	/** appear 钩子；接管动画时需要调用 done。 */
	onAppear?: (el: HTMLElement, done: () => void) => void;
	/** appear 完成钩子。 */
	onAfterAppear?: (el: HTMLElement) => void;
	/** appear 取消钩子，预留给上层兼容。 */
	onAppearCancelled?: (el: HTMLElement) => void;
}
/** 创建过渡运行器
 * @param props 过渡属性配置
 * @returns 过渡执行函数集合：runEnter/runLeave
 */
export declare function createTransitionRunner(props: BaseTransitionProps): {
	runEnter: (el: HTMLElement, phase?: TransitionPhase, onDone?: () => void) => void;
	runLeave: (el: HTMLElement, onDone?: () => void) => void;
};
/* tslint:disable */
/* eslint-disable */
/**
 * unref：若参数是 ref，返回其 .value；否则原样返回
 */
export function unref<T = any>(obj: any): T;
/**
 * useCallback：根据依赖数组缓存回调函数的引用
 */
export function useCallback<T extends (...args: any[]) => any>(fn: T, deps: any[]): T;
/**
 * useMemo：根据依赖数组缓存计算结果，等值依赖不重新计算
 */
export function useMemo<T>(factory: () => T, deps: any[]): T;
/**
 * useRef：在 Hook 插槽上持久化 { current } 容器
 */
export function useRef<T = any>(initial?: T): {
	current: T | undefined;
};
/**
 * useSetup：仅在首次调用时计算一次并缓存
 *
 * - factory 会在组件实例的持久 hook scope 中执行，而不是挂到单次 render scope 上。
 * - 因此 setup 内创建的 watch/watchEffect/createEffect 会随组件实例一起存活，直到组件卸载时统一清理。
 * - 但 setup 首次执行里直接算出来的普通 props 快照仍然只是首帧值；需要动态追踪时，仍应在 computed/watch/effect 中读取 props。
 */
export function useSetup<T>(factory: () => T): T;
/**
 * 侦听选项：{ immediate?: bool, scheduler?: Function, equals?: Function, debounce?: number }
 */
export interface WatchOptions<T = any> {
	immediate?: boolean;
	scheduler?: (run: () => void) => void;
	equals?: (prev: T, next: T) => boolean;
	debounce?: number;
}
/**
 * 侦听副作用：在副作用体内自行读取信号，依赖会自动收集
 * 类似 Vue 的 `watchEffect`
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watchEffect } = wasmModule;
 * const s = createSignal(0);
 * watchEffect(() => {
 *   console.log('value:', s.get());
 * }, {
 *     //可选 scheduler
 * });
 * s.set(1);
 * ```
 */
export function watchEffect(cb: () => void, options?: {
	scheduler?: (run: () => void) => void;
} | null): EffectHandle;
/**
 * 侦听任意 getter 函数的结果变化
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { watchFn } = wasmModule;
 * const obj = { value: 0 };
 * const stop = watchFn(
 *   () => obj.value,
 *   (newv, oldv) => console.log('changed:', oldv, '->', newv),
 *   { immediate: true }
 * );
 * obj.value = 1; // 当 getter 读取到新值时触发 handler
 * ```
 */
export function watchFn<T>(getter: () => T, handler: (newv: T, oldv: T) => void, options?: WatchOptions<T> | null): EffectHandle;
/**
 * 侦听信号值变化：`src` 为信号句柄，`handler` 为值变化时的回调函数
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watchSignal } = wasmModule;
 * const s = createSignal(0);
 * watchSignal(s, (newv, oldv) => {
 *   console.log('value:', oldv, '->', newv);
 * }, { immediate: true });
 * s.set(1); // 当信号值变化时触发 handler
 * ```
 */
export function watchSignal(src: SignalHandle, handler: (newv: any, oldv: any) => void, options?: WatchOptions<any> | null): EffectHandle;
/**
 * 侦听信号值变化（深度）：`src` 为信号句柄，`handler` 为值变化时的回调函数
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watchDeepSignal } = wasmModule;
 * const s = createSignal({ a: 0 });
 * watchDeepSignal(s, (newv, oldv) => {
 *   console.log('value:', oldv, '->', newv);
 * }, { immediate: true });
 * s.set({ a: 1 }); // 当信号值变化时触发 handler
 * ```
 */
export function watchDeepSignal(src: SignalHandle, handler: (newv: any, oldv: any) => void, options?: WatchOptions<any> | null): EffectHandle;
/**
 * 侦听信号路径值变化：`src` 为信号句柄，`path` 为路径（数组或点分字符串），`handler` 为值变化时的回调函数
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watchPath } = wasmModule;
 * const s = createSignal({ a: { b: 0 } });
 * watchPath(s, ['a','b'], (n, o) => {
 *   console.log('b changed:', o, '->', n)
 * }, { immediate: true })
 * s.setPath(['a','b'], 1) // 当路径值变化时触发 handler
 * ```
 */
export function watchPath(src: SignalHandle, path: string | Array<string | number>, handler: (newv: any, oldv: any) => void, options?: WatchOptions<any> | null): EffectHandle;
/**
 * 侦听来源：信号句柄、getter 函数或来源数组（信号句柄 / getter 函数）
 */
export type WatchSource<T = any> = SignalHandle | (() => T) | Array<SignalHandle | (() => any)>;
/**
 * 侦听任意来源变化：`source` 为信号句柄、getter 函数或来源数组（信号句柄 / getter 函数 / 常量），`handler` 为变化时的回调函数
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watch } = wasmModule;
 * const s1 = createSignal(0);
 * const s2 = createSignal(10);
 * watch([s1, s2, 'x'], (n, o) => {
 *   console.log('values:', o, '->', n);
 * }, { immediate: true });
 * s1.set(1); s2.set(11); // 当来源数组中任意值变化时触发 handler
 * ```
 */
export function watch<T>(source: WatchSource<T>, handler: (newv: T | any[], oldv: T | any[]) => void, options?: WatchOptions<T | any[]> | null): EffectHandle;
/**
 * 创建 Reactive：返回一个对象/数组的响应式代理（深/浅、只读可选）
 *
 * 用法（JavaScript / TypeScript）：
 * ```ts
 * // 基础对象：读取与写入都响应式
 * const state = reactive({ user: { name: 'A' }, items: ['x'] })
 * console.log(state.user.name)     // 'A'
 * state.user.name = 'B'            // 写入嵌套字段，触发订阅者
 * state.items.push('y')            // 数组写入也可触发（通过路径写入实现不可变更新）
 *
 * // 在 Vapor JSX 中使用（自动 DOM 更新）
 * // <span>{state.user.name}</span>
 * // <input value={state.user.name} onInput={e => state.user.name = e.target.value} />
 *
 * // 只读代理：禁止写入
 * const ro = reactive({ a: 1 }, { readonly: true })
 * // ro.a = 2 // 将被忽略或导致失败（只读）
 *
 * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
 * const sh = reactive({ nested: { a: 1 } }, { shallow: true })
 * // sh.nested 仍为普通对象（非代理）
 *
 * // 原始类型：普通值会自动包裹为 { value } 并返回其代理
 * const num = reactive(0)
 * console.log(num.value)       // 0
 * num.value = 1               // 写入 value 字段触发订阅者
 * const str = reactive('A')
 * str.value = 'B'             // 原始类型统一通过 value 字段读写
 *
 * // 自定义等值比较：用于控制触发频率
 * const eq = (prev: any, next: any) => _.isEqual(prev, next)
 * const obj = reactive({ a: 1 }, { equals: eq })
 * obj.a = 1 // 不触发（相等）
 * ```
 */
export function reactive<T extends Primitive>(initial: T, options?: ReactiveOptions<T>, forceGlobal?: boolean): {
	value: Widen<T>;
};
export function reactive<T extends object | Function>(initial: T, options?: ReactiveOptions<T>, forceGlobal?: boolean): T;
export function reactive<T = any>(initial: T, options?: ReactiveOptions<T>, forceGlobal?: boolean): any;
/**
 * 创建 Reactive：返回一个对象/数组的响应式代理（浅）
 *
 * 用法（JavaScript / TypeScript）：
 * ```ts
 * // 只读代理：禁止写入
 * const ro = shallowReactive({ a: 1 })
 * // ro.a = 2 // 将被忽略或导致失败（只读）
 *
 * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
 * const sh = shallowReactive({ nested: { a: 1 } })
 * // sh.nested 仍为普通对象（非代理）
 *
 * // 自定义等值比较：用于控制触发频率
 * const eq = (prev: any, next: any) => _.isEqual(prev, next)
 * const obj = shallowReactive({ a: 1 }, { equals: eq })
 * obj.a = 1 // 不触发（相等）
 * ```
 */
export function shallowReactive<T extends object>(initial: T, options?: {
	equals?: Equals<T>;
}, forceGlobal?: boolean): T;
/**
 * 创建 Reactive：返回一个对象/数组的响应式代理（深度只读）
 *
 * 用法（JavaScript / TypeScript）：
 * ```ts
 * // 只读代理：禁止写入
 * const ro = readonly({ a: 1 })
 * // ro.a = 2 // 将被忽略或导致失败（只读）
 * ```
 */
export function readonly<T extends object>(initial: T, forceGlobal?: boolean): T;
/**
 * 创建 Reactive：返回一个对象/数组的响应式代理（第一层只读）
 *
 * 用法（JavaScript / TypeScript）：
 * ```ts
 * // 只读代理：禁止写入
 * const ro = readonly({ a: 1, b: {hello: 'world'} })
 * // ro.a = 2 // 将被忽略或导致失败（只读）
 * // ro.hello = 'new world' // 成功
 * ```
 */
export function shallowReadonly<T extends object>(initial: T, forceGlobal?: boolean): T;
/**
 * 创建 Ref：返回一个带有 `value` 字段的响应式代理对象
 *
 * 用法（JavaScript / TypeScript）：
 * ```ts
 * // 基本使用：读写 value，自动依赖收集
 * const r = ref(0)
 * console.log(r.value)        // 0
 * r.value = 1                 // 触发订阅者
 *
 * // 与 watchEffect 配合（依赖自动收集）
 * const stop = watchEffect(() => {
 *   console.log('ref value =', r.value)
 * })
 * r.value = 2                 // 触发前面的 watchEffect
 * stop()                      // 停止响应
 *
 * // peek：查看当前值，不收集依赖（不会订阅当前副作用）
 * const cur = r.peek()        // 仅返回值，不产生订阅
 *
 * // update：基于当前值计算并写回
 * r.update(prev => prev + 1)  // 等价于 r.value = (prev + 1)
 *
 * // 自定义等值比较：避免无意义的触发
 * const r2 = ref({ a: 1 }, { equals: (p, n) => _.isEqual(p?.value, n?.value) })
 * r2.value = { a: 1 }         // 不触发（相等）
 *
 * // 与组件/DOM 结合（Vapor 模式下自动更新）
 * // <span>{r.value}</span> 会被编译为原生 DOM + 响应式更新
 * ```
 */
export function ref<T = any>(initial: T, options?: {
	equals?: Equals<T>;
} | null, forceGlobal?: boolean): {
	value: T;
};
/**
 * 创建带选项的信号
 * options.equals: Function(prev, next) -> bool，返回 true 表示值相等（不触发）
 * 示例（JavaScript）：
 * ```javascript
 * const count = signal(0);
 * createEffect(() => {
 *   console.log('count =', count.get());
 * });
 * count.set(1); // 触发 effect
 *
 * const eq = (prev, next) => prev === next;
 * const s = signal(0, { equals: eq });
 * s.set(0); // 不触发，因为 equals 返回 true（相等）
 * s.set(2); // 触发订阅者
 * ```
 */
export function signal<T = any>(initial: T, options?: {
	equals?: Equals<T>;
}, forceGlobal?: boolean): SignalHandle<T>;
/**
 * 创建计算属性
 * - 参数：可为函数 `() => any`，或对象 `{ get: () => any }`
 * 返回：一个只读信号句柄（通过 get/peek 读取，内部通过 effect 驱动更新）
 * 示例（JavaScript）：
 * ```javascript
 * const count = signal(1);
 * const double = computed(() => count.get() * 2);
 *
 * createEffect(() => {
 *   console.log('double =', double.get());
 * });
 *
 * count.set(2); // double 将变为 4 并触发订阅者
 * ```
 * 更多用法示例：
 *
 * 1) 对象参数（只读 getter）：
 * ```javascript
 * const first = signal('John');
 * const last = signal('Doe');
 * const fullName = computed({
 *   get: () => first.get() + ' ' + last.get()
 * });
 * createEffect(() => {
 *   console.log('fullName =', fullName.get()); // John Doe
 * });
 * ```
 *
 * 2) 通过更新源信号实现“可写效果”（模拟 Vue3 的 setter 行为）：
 * ```javascript
 * const setFullName = (nv) => {
 *   const [f, l] = nv.split(' ');
 *   first.set(f);
 *   last.set(l);
 * };
 * setFullName('David Smith'); // fullName 将变为 "David Smith"
 * ```
 *
 * 3) 直接使用 `{ get, set }` 创建“可写 computed”，支持 `.set(value)`：
 * ```javascript
 * const fullName = computed({
 *   get: () => first.get() + ' ' + last.get(),
 *   set: (nv) => {
 *     const [f, l] = nv.split(' ');
 *     first.set(f);
 *     last.set(l);
 *   }
 * });
 * fullName.set('David Smith'); // 将调用你的 set 更新源信号，并重算派生值
 * ```
 */
export function computed<T>(get: ComputedGetter<T>, forceGlobal?: boolean): ReadonlySignal<T>;
export function computed<T>(options: ComputedOptions<T>, forceGlobal?: boolean): WritableSignal<T>;
export function computed<T>(arg: any, forceGlobal?: boolean): ReadonlySignal<T> | WritableSignal<T>;
/**
 * 副作用句柄：用于在 JS 侧停止副作用
 */
export interface EffectHandle {
	/** 停止后续运行，并执行最后一次已注册的清理 */
	dispose(): void;
}
/**
 * 创建副作用（立即运行一次），并返回句柄
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, createEffect, onCleanup, untrack, batch } = wasmModule;
 * const s = createSignal(0);
 *
 * // 基本副作用：读取信号并打印
 * createEffect(() => {
 *   console.log('value:', s.get());
 * });
 * s.set(1);
 *
 * // 清理示例：注册定时器并在下一次运行前清理
 * createEffect(() => {
 *   const id = setInterval(() => console.log('tick'), 1000);
 *   onCleanup(() => clearInterval(id));
 * });
 *
 * // 断开依赖收集：不会订阅 other 信号
 * createEffect(() => {
 *   const v = untrack(() => s.get());
 *   console.log('untracked:', v);
 * });
 *
 * 创建副作用（支持自定义调度器与懒执行）
 * options:
 * - scheduler: Function( run: Function )，用于自定义何时调用 run
 * - lazy: bool，true 时不在创建时立即运行
 * 示例（JavaScript）：
 * ```javascript
 * const { createEffect } = wasmModule;
 * const scheduler = (run) => queueMicrotask(run); // 或者使用 requestAnimationFrame
 * createEffect(() => {
 *   // ...effect body
 * }, { scheduler, lazy: false });
 * ```
 */
export declare function createEffect(cb: () => void, options?: {
	scheduler?: (run: () => void) => void;
	lazy?: boolean;
} | null): EffectHandle;
/**
 * 在当前运行的副作用上注册清理函数
 * 清理函数会在下一次该副作用执行之前被调用
 * 用法与示例（JavaScript）：
 * ```js
 * // 需求：每次依赖变化时重建一个定时器，并在下一次运行前清理上一次的定时器
 * const s = createSignal(0)
 * const eh = createEffect(() => {
 *   const v = s.get() // 建立订阅
 *   const id = setInterval(() => console.log('[onCleanup-demo] tick v=', v), 500)
 *   onCleanup(() => clearInterval(id)) // 下次运行前清理上一次的定时器
 * })
 * s.set(1) // 触发重跑：先清理旧定时器，再创建新定时器（只保留一个）
 * s.set(2) // 同理
 * eh.dispose() // 停止后续运行，并执行最后一次已注册的清理（定时器不再 tick）
 * ```
 */
export function onCleanup(cb: () => void): void;
/**
 * 断开依赖收集地执行回调（不记录对 Signal 的订阅）
 *
 * 用途与示例（JavaScript）：
 * - 在同一个副作用中，订阅主依赖 `a`，但临时读取 `b` 并且不希望 `b` 的变化触发该副作用。
 * - `untrack(fn)` 会在执行 `fn` 时临时关闭依赖收集，`fn` 内部对信号的读取不会把当前副作用订阅到这些信号上。
 *
 * ```js
 * const a = createSignal(0)
 * const b = createSignal(0)
 * createEffect(() => {
 *   const av = a.get()                // 订阅 a：a 变化会使该副作用重跑
 *   const bv = untrack(() => b.get()) // 断开依赖读取 b：b 变化不会触发该副作用
 *   console.log('[untrack-demo] run av=', av, 'bv=', bv)
 * })
 * b.set(1)  // 不触发副作用（因为对 b 的读取发生在 untrack 内）
 * b.set(2)  // 不触发副作用
 * a.set(10) // 触发副作用（因为对 a 进行了正常订阅）
 * ```
 *
 * 说明：若仅需“不订阅地读取”某个信号，也可使用 `peek()`（例如 `const v = sig.peek()`）。
 */
export function untrack<T>(cb: () => T): T;
/**
 * 批量更新：在回调期间抑制副作用的即时触发，统一在结束后刷新
 *
 * 用法与示例（JavaScript）：
 * ```js
 * const { createSignal, createEffect, batch } = wasmModule
 *
 * // 示例一：同一信号多次 set，仅在批量结束后重跑一次
 * const count = createSignal(0)
 * createEffect(() => {
 *   console.log('[batch-demo] count =', count.get())
 * })
 * batch(() => {
 *   count.set(1)
 *   count.set(2)
 *   count.set(3)
 *   // 在批量范围内不会立即触发副作用
 * })
 * // 批量结束后只触发一次副作用，打印最新值 3
 *
 * // 示例二：一次性更新多个信号，副作用只合并重跑一次
 * const a = createSignal(0)
 * const b = createSignal(0)
 * createEffect(() => {
 *   console.log('[batch-demo] sum =', a.get() + b.get())
 * })
 *  batch(() => {
 *    a.set(10)
 *    b.set(20)
 *  }) // 仅一次重跑，输出 sum = 30
 * ```
 */
export function batch(cb: () => void): void;
/**
 * 只读信号句柄：仅提供 get/peek 方法，不支持 set/update
 */
export interface ReadonlySignal<T> {
	get(): T;
	peek(): T;
}
/**
 * 可写信号句柄：提供 get/peek/set/update 方法
 */
export interface WritableSignal<T> extends ReadonlySignal<T> {
	set(value: T): void;
	update?(updater: (current: T) => T): void;
}
/**
 * 计算属性 getter 函数类型：`() => any`
 */
export type ComputedGetter<T> = () => T;
/**
 * 计算属性 setter 函数类型：`(value: T) => void`
 */
export type ComputedSetter<T> = (value: T) => void;
/**
 * 计算属性选项：{ get: ComputedGetter<T>, set?: ComputedSetter<T> }
 */
export interface ComputedOptions<T> {
	get: ComputedGetter<T>;
	set?: ComputedSetter<T>;
}
/**
 * 组件实例上下文，用于响应式访问 Hook 插槽
 */
export interface HookContainer {
	states: any[];
	index: number;
	__forcedIndex?: number;
	[key: string]: any;
}
/**
 * 组件实例上下文类型，可用于类型注解
 */
export type HookHost = (Record<string, any> & {
	__hooks?: HookContainer;
}) | null | undefined;
/**
 * 设置当前实例
 * 传入 `null/undefined` 表示清空；否则记录为 Some(instance)
 * 示例（JavaScript）：
 * ```javascript
 * const { setCurrentInstance, getCurrentInstance, withHookSlot, createSignal } = wasmModule;
 * const inst = { name: 'MyComponent' };
 * setCurrentInstance(inst);
 *
 * // 在实例上分配一个 Hook 插槽，用于存储状态对象
 * const state = withHookSlot(() => ({ count: createSignal(0) }));
 * console.log(getCurrentInstance()); // 当前实例或根实例
 * ```
 */
export function setCurrentInstance(instance: HookHost): void;
/**
 * 获取当前实例；若未设置则返回空值（null/undefined），不再构造默认根实例
 * 用法（JavaScript）：
 * ```javascript
 * const { setCurrentInstance, getCurrentInstance, withHookSlot } = wasmModule;
 *
 * // 设置并获取当前实例
 * setCurrentInstance({ name: 'A' });
 * const inst = getCurrentInstance(); // { name: 'A', ... }
 *
 * // 清空当前实例后，获取为空（undefined 或 null）
 * setCurrentInstance(undefined);
 * const none = getCurrentInstance(); // undefined（或 null）
 *
 * // 在有当前实例时，withHookSlot 为该实例分配/复用一个 Hook 插槽
 * setCurrentInstance({});
 * const state = withHookSlot(() => ({ count: 0 })); // 首次创建并缓存到 __hooks.states
 * ```
 */
export function getCurrentInstance(): HookHost;
/**
 * 在当前实例上为 Hook 分配/复用一个插槽
 * - 若无当前实例，则直接执行 factory 返回对象
 * - 有实例时，依据 `__hooks.index` 或 `__forcedIndex` 计算插槽序号
 * 示例（JavaScript）：
 * ```javascript
 * const { setCurrentInstance, withHookSlot } = wasmModule;
 * setCurrentInstance({});
 * const a = withHookSlot(() => ({ id: 1 }));
 * const b = withHookSlot(() => ({ id: 2 }));
 * // 若再次调用 withHookSlot（且未强制索引），将分配下一个插槽
 * ```
 */
export function withHookSlot<T = any>(factory: () => T): T;
/**
 * 自定义等值比较函数类型：`(prev: T, next: T) => boolean`
 */
export type Equals<T> = (prev: T, next: T) => boolean;
/**
 * 响应式选项：用于创建响应式对象/数组
 */
export interface ReactiveOptions<T> {
	equals?: Equals<T>;
	readonly?: boolean;
	shallow?: boolean;
}
/**
 * 信号句柄：包含
 * `{ get, peek, set, update, getPath, setPath, updatePath, peekPath, toJSON, valueOf, toString, value }` 方法/属性
 */
export interface SignalHandle<T> {
	/**
	 * 读取当前值，并在有正在运行的副作用时将其订阅到该信号
	 */
	get(): T;
	/**
	 * 查看当前值：不进行依赖收集（不订阅当前副作用）
	 */
	peek(): T;
	/**
	 * 查看路径值：不进行依赖收集（不订阅当前副作用）
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = signal({ user: { name: 'A' }, items: ['x'] })
	 * const n = s.peekPath('user.name')   // 'A'（不订阅）
	 *
	 * // 边界：
	 * // - 空路径：返回根值（不订阅）
	 * console.log(s.peekPath([]))     // { user: { name: 'A' }, items: ['x'] }
	 * console.log(s.peekPath(''))     // { user: { name: 'A' }, items: ['x'] }
	 * ```
	 */
	peekPath(path: string | Array<string | number>): any;
	/**
	 * 设置新值，按等值比较决定是否通知订阅者
	 */
	set(value: T): void;
	/**
	 * 根据回调对当前值进行计算并设置（相当于 set( updater(current) )）
	 */
	update(updater: (current: T) => T): void;
	/**
	 * JSON 序列化：`JSON.stringify(signal)` 时返回内部值
	 */
	toJSON(): T;
	/**
	 * 原始值表示：`signal.valueOf()` 返回内部值
	 */
	valueOf(): T;
	/**
	 * 字符串表示：`String(signal)` 返回 JSON 字符串或占位文本
	 */
	toString(): string;
	/**
	 * 只读/写属性：`signal.value` 直接读取内部值；写入等价于 `set`
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = signal(0)
	 * console.log(s.value) // 0（不订阅）
	 * s.value = 1          // 等价于 s.set(1)
	 * ```
	 */
	value: T;
	/**
	 * 根据路径读取当前对象/数组的子项值（依赖收集）
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = signal({ user: { profile: { name: 'A' } }, items: ['x'] })
	 * const name1 = s.getPath(['user','profile','name']) // 'A'
	 * const name2 = s.getPath('user.profile.name') // 'A'
	 * // 在 watch 中使用路径读取会自动依赖收集
	 * watchFn(() => s.getPath(['user','profile','name']), (n, o) => {  })
	 * watchFn(() => s.getPath('user.profile.name'), (n, o) => {  })
	 *
	 * // 边界：
	 * // - 空路径：返回根值并订阅
	 * const root = s.getPath([]) // 订阅根
	 * // - 数字字段解析：'items.0' 解析为 ['items', 0]
	 * const first = s.getPath('items.0') // 'x'
	 * ```
	 */
	getPath(path: string | Array<string | number>): any;
	/**
	 * 根据路径设置对象/数组的子项值：不可变更新，生成新的根对象并触发订阅者
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = signal({ user: { profile: { name: 'A' }, age: 20 }, items: ['x'] })
	 * // 设置嵌套对象字段（数组路径）
	 * s.setPath(['user', 'profile', 'name'], 'B')
	 * // 设置数组元素（数组路径）
	 * s.setPath(['items', 0], 'y')
	 * // 字符串路径（以 . 分隔，数字段转为数组索引）
	 * s.setPath('user.profile.name', 'B')
	 * s.setPath('items.0', 'y')
	 * // 若根不是对象/数组，会以空对象作为根进行赋值
	 * s.setPath(['foo', 'bar'], 1)
	 * s.setPath('foo.bar', 1)
	 *
	 * // 边界：
	 * // - 空路径：替换整个根值并触发订阅者
	 * s.setPath([], { user: { profile: { name: 'C' } } })
	 * s.setPath('', { user: { profile: { name: 'D' } } })
	 * // - 缺失中间段：自动以空对象占位
	 * s.setPath(['config','theme','color'], 'red') // 若 'config' 不存在，将创建为 {}
	 * // - 数组越界写入：当目标段为现有数组时会扩展长度
	 * s.setPath(['items', 2], 'z') // items: ['x', undefined, 'z']
	 * // - 函数值不执行：作为普通值读写
	 * const fn = () => 42
	 * s.setPath('cb', fn)
	 * console.log(typeof s.getPath('cb')) // 'function'
	 * ```
	 *
	 * 参数：
	 * - `path`: JS 数组或以 `.` 分隔的字符串（如 `['user','profile','name']`、`['items', 0]` 或 `'user.profile.name'`、`'items.0'`）
	 * - `value`: 目标路径的新值
	 * 行为与边界：
	 * - 路径缺失会自动以空对象占位，数组越界写入会扩展长度
	 * - 根为非对象/数组时以空对象为根进行赋值
	 * - 函数值作为普通值读写，不会被执行
	 */
	setPath(path: string | Array<string | number>, value: any): void;
	/**
	 * 根据路径函数式更新子项：`updater(currentAtPath) -> nextAtPath`
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = signal({ user: { age: 20 }, items: ['x'] })
	 * s.updatePath(['user','age'], prev => prev + 1) // age: 21
	 * s.updatePath(['user','name'], prev => (prev || '').toUpperCase())
	 * // 使用字符串路径
	 * s.updatePath('user.age', prev => prev + 1) // age: 21
	 * s.updatePath('items.0', prev => (prev || '').toUpperCase())
	 *
	 * // 边界：
	 * // - 空路径：以根值为输入进行整体更新
	 * s.updatePath([], root => ({ ...root, flag: true }))
	 * s.updatePath('', root => ({ ...root, mark: 1 }))
	 * // - 缺失段：以空对象占位后再写入
	 * s.updatePath(['config','theme'], prev => ({ ...(prev || {}), mode: 'dark' }))
	 * ```
	 */
	updatePath(path: string | Array<string | number>, updater: (currentAtPath: any) => any): void;
}
/**
 * 设置调度模式
 * - mode="sync"：信号变更时尽可能同步触发副作用
 * - mode="microtask" / 其他值：采用默认微任务合并调度
 * - mode="frame"：在浏览器里按动画帧合并调度，适合拖动/滚动等高频交互
 * 示例（JavaScript）：
 * ```javascript
 * const { setReactiveScheduling } = wasmModule;
 * setReactiveScheduling('sync'); // 适合少量、快速的更新
 * // setReactiveScheduling('microtask'); // 使用默认微任务合并
 * // setReactiveScheduling('frame'); // 浏览器里按帧合并，适合 slider / drag 等高频输入
 * ```
 */
export function setReactiveScheduling(mode: "sync" | "microtask" | "frame" | string): void;
/**
 * 通用取值转换
 * 支持以下输入：
 * - 函数：调用并返回其结果
 * - 对象：优先读取 `value` 字段，其次尝试调用 `get()` 方法
 * - 其他：直接返回原值
 * 示例（JavaScript）：
 * ```javascript
 * const { toValue } = wasmModule;
 * toValue(() => 1); // 1
 * toValue({ value: 2 }); // 2
 * toValue({ get() { return 3; } }); // 3
 * toValue('hello'); // 'hello'
 * ```
 */
export function toValue<T>(x: T | (() => T) | {
	value?: T;
	get?: () => T;
}): T;
/**
 * 原始类型：普通值会自动包裹为 { value } 并返回其代理
 */
export type Primitive = string | number | bigint | boolean | symbol | null | undefined;
/**
 * 扩展原始类型：将原始值包裹为 { value: T } 并返回其代理
 */
export type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T extends null | undefined ? T : never;
/**
 * 调试工具：判断对象是否为 reactive 代理
 */
export function isReactive(obj: any): boolean;
/**
 * 调试工具：获取 reactive 代理背后的原始数据快照
 * - 对 reactive 对象：通过隐藏的 `__signal__` 获取当前值（不收集依赖）
 * - 对 ref：返回其 `.value`
 * - 其他：原样返回
 */
export function toRaw<T = any>(obj: any): T;
declare class EffectHandle {
	private constructor();
	free(): void;
	[Symbol.dispose](): void;
	/**
	 * 销毁副作用：标记为已处置，并清空其清理回调
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const eh = createEffect(() => {
	 *   // ...effect body
	 *   onCleanup(() => {
	 *     // 这里注册的清理会在下一次执行前或 dispose() 时运行
	 *   })
	 * })
	 * // 需要停止该副作用时：
	 * eh.dispose() // 标记为已处置，并执行最后一次已注册的清理
	 * ```
	 */
	dispose(): void;
}
export class SignalHandle {
	private constructor();
	free(): void;
	[Symbol.dispose](): void;
	/**
	 * 读取当前值，并在有正在运行的副作用时将其订阅到该信号
	 */
	get(): any;
	/**
	 * 根据路径读取当前对象/数组的子项值（依赖收集）
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = createSignal({ user: { profile: { name: 'A' } } })
	 * const name1 = s.getPath(['user','profile','name']) // 'A'
	 * const name2 = s.getPath('user.profile.name') // 'A'
	 * // 在 watch 中使用路径读取会自动依赖收集
	 * watchFn(() => s.getPath(['user','profile','name']), (n, o) => {  })
	 * watchFn(() => s.getPath('user.profile.name'), (n, o) => {  })
	 * ```
	 */
	getPath(path: any): any;
	/**
	 * 偷看当前值：不进行依赖收集（不订阅当前副作用）
	 */
	peek(): any;
	/**
	 * 路径偷看：不进行依赖收集（不订阅当前副作用），仅返回当前路径的值
	 * - 支持以 `.` 分隔的字符串路径（如 `user.profile.name`）或数组路径（如 `['user','profile','name']`、`['items', 0]`）
	 * - 行为与 `getPath` 相同，但不会触发依赖收集，适合用于调试/序列化
	 */
	peekPath(path: any): any;
	/**
	 * 设置新值，按等值比较决定是否通知订阅者
	 */
	set(v: any): void;
	/**
	 * 根据路径设置对象/数组的子项值：不可变更新，生成新的根对象并触发订阅者
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = createSignal({ user: { profile: { name: 'A' }, age: 20 }, items: ['x'] })
	 * // 设置嵌套对象字段（数组路径）
	 * s.setPath(['user', 'profile', 'name'], 'B')
	 * // 设置数组元素（数组路径）
	 * s.setPath(['items', 0], 'y')
	 * // 字符串路径（以 . 分隔，数字段转为数组索引）
	 * s.setPath('user.profile.name', 'B')
	 * s.setPath('items.0', 'y')
	 * // 若根不是对象/数组，会以空对象作为根进行赋值
	 * s.setPath(['foo', 'bar'], 1)
	 * s.setPath('foo.bar', 1)
	 * ```
	 *
	 * 参数：
	 * - `path`: JS 数组或以 `.` 分隔的字符串（如 `['user','profile','name']`、`['items', 0]` 或 `'user.profile.name'`、`'items.0'`）
	 * - `value`: 目标路径的新值
	 * 行为与边界：
	 * - 路径缺失会自动以空对象占位，数组越界写入会扩展长度
	 * - 根为非对象/数组时以空对象为根进行赋值
	 * - 函数值作为普通值读写，不会被执行
	 */
	setPath(path: any, value: any): void;
	/**
	 * 便于调试：`JSON.stringify(signal)` 时返回内部值
	 */
	toJSON(): any;
	/**
	 * 便于调试：`String(signal)` 返回值的 JSON 字符串或占位文本
	 */
	toString(): string;
	/**
	 * 手动触发当前信号的订阅者，不修改值且不经过 equals 比较。
	 */
	trigger(): void;
	/**
	 * 手动触发指定路径的订阅者，不修改值且不经过 equals 比较。
	 */
	triggerPath(path: any): void;
	/**
	 * 根据回调对当前值进行计算并设置（相当于 set( updater(current) )）
	 */
	update(updater: Function): void;
	/**
	 * 根据路径函数式更新子项：`updater(currentAtPath) -> nextAtPath`
	 *
	 * 用法（JavaScript）：
	 * ```js
	 * const s = createSignal({ user: { age: 20 }, items: ['x'] })
	 * s.updatePath(['user','age'], prev => prev + 1) // age: 21
	 * s.updatePath(['user','name'], prev => (prev || '').toUpperCase())
	 * // 使用字符串路径
	 * s.updatePath('user.age', prev => prev + 1) // age: 21
	 * s.updatePath('items.0', prev => (prev || '').toUpperCase())
	 * ```
	 */
	updatePath(path: any, updater: Function): void;
	/**
	 * 便于调试：`signal.valueOf()` 返回内部值
	 */
	valueOf(): any;
	/**
	 * readonly 识别标记；无 setter 的 computed 视为只读。
	 */
	readonly __isReadonly__: boolean;
	/**
	 * ref/computed 识别标记；普通 signal 不暴露为 ref。
	 */
	readonly __rue_ref__: boolean;
	/**
	 * 调试身份标记；JS 包装层用它把 Rust 事件目标规范化为用户持有的 SignalHandle。
	 */
	readonly __rue_signal_id__: number;
	/**
	 * 只读调试：`signal.value` 直接返回内部值（不进行依赖收集）
	 */
	value: any;
}
/**
 * 批量更新：在回调期间抑制副作用的即时触发，统一在结束后刷新
 *
 * 用法与示例（JavaScript）：
 * ```js
 * const { createSignal, createEffect, batch } = wasmModule
 *
 * // 示例一：同一信号多次 set，仅在批量结束后重跑一次
 * const count = createSignal(0)
 * createEffect(() => {
 *   console.log('[batch-demo] count =', count.get())
 * })
 * batch(() => {
 *   count.set(1)
 *   count.set(2)
 *   count.set(3)
 *   // 在批量范围内不会立即触发副作用
 * })
 * // 批量结束后只触发一次副作用，打印最新值 3
 *
 * // 示例二：一次性更新多个信号，副作用只合并重跑一次
 * const a = createSignal(0)
 * const b = createSignal(0)
 * createEffect(() => {
 *   console.log('[batch-demo] sum =', a.get() + b.get())
 * })
 * batch(() => {
 *   a.set(10)
 *   b.set(20)
 * }) // 仅一次重跑，输出 sum = 30
 * ```
 */
export function batch(cb: Function): void;
export function computed(arg: any, force_global?: boolean | null): SignalHandle;
/**
 * 创建副作用（立即运行一次），并返回句柄
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, createEffect, onCleanup, untrack, batch } = wasmModule;
 * const s = createSignal(0);
 *
 * // 基本副作用：读取信号并打印
 * createEffect(() => {
 *   console.log('value:', s.get());
 * });
 * s.set(1);
 *
 * // 清理示例：注册定时器并在下一次运行前清理
 * createEffect(() => {
 *   const id = setInterval(() => console.log('tick'), 1000);
 *   onCleanup(() => clearInterval(id));
 * });
 *
 * // 断开依赖收集：不会订阅 other 信号
 * createEffect(() => {
 *   const v = untrack(() => s.get());
 *   console.log('untracked:', v);
 * });
 *
 * 创建副作用（支持自定义调度器与懒执行）
 * options:
 * - scheduler: Function( run: Function )，用于自定义何时调用 run
 * - lazy: bool，true 时不在创建时立即运行
 * 示例（JavaScript）：
 * ```javascript
 * const { createEffect } = wasmModule;
 * const scheduler = (run) => queueMicrotask(run); // 或者使用 requestAnimationFrame
 * createEffect(() => {
 *   // ...effect body
 * }, { scheduler, lazy: false });
 * ```
 */
export declare function createEffect(cb: Function, options?: any | null): EffectHandle;
/**
 * 获取当前实例；若未设置则返回空值（null/undefined），不再构造默认根实例
 * 用法（JavaScript）：
 * ```javascript
 * const { setCurrentInstance, getCurrentInstance, withHookSlot } = wasmModule;
 *
 * // 设置并获取当前实例
 * setCurrentInstance({ name: 'A' });
 * const inst = getCurrentInstance(); // { name: 'A', ... }
 *
 * // 清空当前实例后，获取为空（undefined 或 null）
 * setCurrentInstance(undefined);
 * const none = getCurrentInstance(); // undefined（或 null）
 *
 * // 在有当前实例时，withHookSlot 为该实例分配/复用一个 Hook 插槽
 * setCurrentInstance({});
 * const state = withHookSlot(() => ({ count: 0 })); // 首次创建并缓存到 __hooks.states
 * ```
 */
export function getCurrentInstance(): any;
export function isReactive(obj: any): boolean;
/**
 * 在当前运行的副作用上注册清理函数
 * 清理函数会在下一次该副作用执行之前被调用
 * 用法与示例（JavaScript）：
 * ```js
 * // 需求：每次依赖变化时重建一个定时器，并在下一次运行前清理上一次的定时器
 * const s = createSignal(0)
 * const eh = createEffect(() => {
 *   const v = s.get() // 建立订阅
 *   const id = setInterval(() => console.log('[onCleanup-demo] tick v=', v), 500)
 *   onCleanup(() => clearInterval(id)) // 下次运行前清理上一次的定时器
 * })
 * s.set(1) // 触发重跑：先清理旧定时器，再创建新定时器（只保留一个）
 * s.set(2) // 同理
 * eh.dispose() // 停止后续运行，并执行最后一次已注册的清理（定时器不再 tick）
 * ```
 */
export function onCleanup(cb: Function): void;
export function propsReactive(initial: any, force_global?: boolean | null): any;
export function reactive(initial: any, options?: any | null, force_global?: boolean | null): any;
export function readonly(initial: any, force_global?: boolean | null): any;
export function ref(initial: any, options?: any | null, force_global?: boolean | null): any;
/**
 * 设置当前实例
 * 传入 `null/undefined` 表示清空；否则记录为 Some(instance)
 * 示例（JavaScript）：
 * ```javascript
 * const { setCurrentInstance, getCurrentInstance, withHookSlot, createSignal } = wasmModule;
 * const inst = { name: 'MyComponent' };
 * setCurrentInstance(inst);
 *
 * // 在实例上分配一个 Hook 插槽，用于存储状态对象
 * const state = withHookSlot(() => ({ count: createSignal(0) }));
 * console.log(getCurrentInstance()); // 当前实例或根实例
 * ```
 */
export function setCurrentInstance(i: any): void;
/**
 * 设置调度模式
 * - mode="sync"：信号变更时尽可能同步触发副作用
 * - mode="microtask" / 其他值：采用默认微任务合并调度
 * - mode="frame"：在浏览器里按动画帧合并调度，适合拖动/滚动等高频交互
 * 示例（JavaScript）：
 * ```javascript
 * const { setReactiveScheduling } = wasmModule;
 * setReactiveScheduling('sync'); // 适合少量、快速的更新
 * // setReactiveScheduling('microtask'); // 使用默认微任务合并
 * // setReactiveScheduling('frame'); // 浏览器里按帧合并，适合 slider / drag 等高频输入
 * ```
 */
export function setReactiveScheduling(mode: string): void;
export function shallowReactive(initial: any, options?: any | null, force_global?: boolean | null): any;
export function shallowReadonly(initial: any, force_global?: boolean | null): any;
export function signal(initial: any, options?: any | null, force_global?: boolean | null): SignalHandle;
export function toRaw(obj: any): any;
/**
 * 通用取值转换
 * 支持以下输入：
 * - 函数：调用并返回其结果
 * - 对象：优先读取 `value` 字段，其次尝试调用 `get()` 方法
 * - 其他：直接返回原值
 * 示例（JavaScript）：
 * ```javascript
 * const { toValue } = wasmModule;
 * toValue(() => 1); // 1
 * toValue({ value: 2 }); // 2
 * toValue({ get() { return 3; } }); // 3
 * toValue('hello'); // 'hello'
 * ```
 */
export function toValue(x: any): any;
export function unref(obj: any): any;
/**
 * 断开依赖收集地执行回调（不记录对 Signal 的订阅）
 *
 * 用途与示例（JavaScript）：
 * - 在同一个副作用中，订阅主依赖 `a`，但临时读取 `b` 并且不希望 `b` 的变化触发该副作用。
 * - `untrack(fn)` 会在执行 `fn` 时临时关闭依赖收集，`fn` 内部对信号的读取不会把当前副作用订阅到这些信号上。
 *
 * ```js
 * const a = createSignal(0)
 * const b = createSignal(0)
 * createEffect(() => {
 *   const av = a.get()                // 订阅 a：a 变化会使该副作用重跑
 *   const bv = untrack(() => b.get()) // 断开依赖读取 b：b 变化不会触发该副作用
 *   console.log('[untrack-demo] run av=', av, 'bv=', bv)
 * })
 * b.set(1)  // 不触发副作用（因为对 b 的读取发生在 untrack 内）
 * b.set(2)  // 不触发副作用
 * a.set(10) // 触发副作用（因为对 a 进行了正常订阅）
 * ```
 *
 * 说明：若仅需“不订阅地读取”某个信号，也可使用 `peek()`（例如 `const v = sig.peek()`）。
 */
export function untrack(cb: Function): any;
export function useCallback(func: Function, deps: any): Function;
export function useMemo(factory: Function, deps: any): any;
export function useRef(initial: any): any;
export function useSetup(factory: Function): any;
/**
 * 统一侦听入口：接受函数、信号句柄对象（含 `get` 方法）或来源数组
 *
 * 用法（JavaScript）：
 * ```js
 * // 1) 侦听函数源（等价 watchFn）
 * const stop1 = watch(() => state.count, (n, o) => { console.log(n, o) }, { immediate: true })
 *
 * // 2) 侦听信号句柄对象（含 get 方法）
 * const s = createSignal(0)
 * const stop2 = watch(s, (n, o) => { console.log(n, o) })
 * s.set(1)
 *
 * // 3) 侦听来源数组：函数 / 信号句柄 / 常量混合
 * const s1 = createSignal(0)
 * const s2 = createSignal(10)
 * const stop3 = watch([() => s1.get(), s2, 'x'], ([n1, n2, c], [o1, o2, oc]) => { console.log(n1, n2, c, o1, o2, oc) })
 * s1.set(1); s2.set(11)
 *
 * // 自定义比较：覆盖默认逐项浅比较
 * watch([s1, s2], (n, o) => {}, { equals: (prev, next) => _.isEqual(prev, next) })
 * ```
 */
export function watch(source: any, handler: Function, options_raw?: any | null): EffectHandle;
/**
 * 深度侦听：当对象/数组任意子项变化时触发
 *
 * 用法（JavaScript）：
 * ```js
 * const s = createSignal({ user: { name: 'A' }, items: ['x'] })
 * const stop = watchDeepSignal(s, (newv, oldv) => {
 *   console.log('deep changed', oldv, '->', newv)
 * }, { immediate: true })
 * s.setPath(['user','name'], 'B')
 * s.setPath(['items', 0], 'y')
 * stop.dispose() // 取消侦听
 * ```
 */
export function watchDeepSignal(src: SignalHandle, handler: Function, options?: any | null): EffectHandle;
/**
 * 侦听副作用：在副作用体内自行读取信号，依赖会自动收集
 * 类似 Vue 的 `watchEffect`
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watchEffect } = wasmModule;
 * const s = createSignal(0);
 * watchEffect(() => {
 *   console.log('value:', s.get());
 * }, {
 *     //可选 scheduler
 * });
 * s.set(1);
 * ```
 */
export function watchEffect(cb: Function, options?: any | null): EffectHandle;
/**
 * 侦听任意 getter 函数的结果变化
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { watchFn } = wasmModule;
 * const obj = { value: 0 };
 * const stop = watchFn(
 *   () => obj.value,
 *   (newv, oldv) => console.log('changed:', oldv, '->', newv),
 *   { immediate: true }
 * );
 * obj.value = 1; // 当 getter 读取到新值时触发 handler
 * ```
 */
export function watchFn(getter: Function, handler: Function, options?: any | null): EffectHandle;
/**
 * 侦听指定路径的值变化：`path` 支持 JS 数组或以 `.` 分隔的字符串
 *
 * 用法（JavaScript）：
 * ```js
 * const s = createSignal({ user: { profile: { name: 'A' } } })
 * // 数组路径
 * watchPath(s, ['user','profile','name'], (n, o) => {
 *   console.log('name changed:', o, '->', n)
 * }, { immediate: true })
 * // 字符串路径（数字段会自动转为数组索引）
 * watchPath(s, 'user.profile.name', (n, o) => {
 *   console.log('name changed:', o, '->', n)
 * }, { immediate: true })
 * s.setPath(['user','profile','name'], 'B')
 * s.setPath('user.profile.name', 'B')
 * ```
 */
export function watchPath(src: SignalHandle, path: any, handler: Function, options?: any | null): EffectHandle;
/**
 * 侦听单个信号的变化并在变化时触发处理器
 * options: { immediate?: bool, scheduler?: Function, equals?: Function }
 * 示例（JavaScript）：
 * ```javascript
 * const { createSignal, watchSignal } = wasmModule;
 * const s = createSignal(0);
 * watchSignal(s, (newv, oldv) => {
 *   console.log('signal changed:', oldv, '->', newv);
 * }, { immediate: true });
 * s.set(1);
 * ```
 */
export function watchSignal(src: SignalHandle, handler: Function, options?: any | null): EffectHandle;
/**
 * 在当前实例上为 Hook 分配/复用一个插槽
 * - 若无当前实例，则直接执行 factory 返回对象
 * - 有实例时，依据 `__hooks.index` 或 `__forcedIndex` 计算插槽序号
 * 示例（JavaScript）：
 * ```javascript
 * const { setCurrentInstance, withHookSlot } = wasmModule;
 * setCurrentInstance({});
 * const a = withHookSlot(() => ({ id: 1 }));
 * const b = withHookSlot(() => ({ id: 2 }));
 * // 若再次调用 withHookSlot（且未强制索引），将分配下一个插槽
 * ```
 */
export function withHookSlot(factory: Function): any;
/** 创建浅层 ref，只追踪 value 替换。 */
export declare function shallowRef<T = any>(initial: T, options?: {
	equals?: (prev: T, next: T) => boolean;
} | null, forceGlobal?: boolean): {
	value: T;
};
/** 判断值是否为 Rue ref 或 computed ref。 */
export declare function isRef<T = any>(value: unknown): value is {
	value: T;
};
/** 判断对象是否为 Rue reactive/readonly 代理。 */
export declare function isProxy(obj: any): boolean;
/** 判断对象是否为只读代理或只读 computed。 */
export declare function isReadonly(obj: any): boolean;
/** 手动触发 ref/shallowRef 的 value 订阅者。 */
export declare function triggerRef<T = any>(ref: {
	value: T;
}): void;
/** 对象属性 ref 句柄。 */
export type ObjectRef<T = any> = {
	value: T;
};
/** getter 规范化后的只读 ref。 */
export type GetterRef<T = any> = Readonly<ObjectRef<T>>;
/** 将对象每个属性映射为 ref 句柄的结果类型。 */
export type ToRefs<T extends object> = {
	[K in keyof T]: ObjectRef<T[K]>;
};
/** 将已有 ref 直接返回。 */
export declare function toRef<T>(value: ObjectRef<T>): ObjectRef<T>;
/** 将 getter 规范化为只读 ref。 */
export declare function toRef<T>(getter: () => T): GetterRef<T>;
/** 将普通值包装为独立 ref。 */
export declare function toRef<T>(value: T): ObjectRef<T>;
/** 将对象属性包装为与源对象同步的 ref。 */
export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ObjectRef<T[K]>;
/** 将对象属性包装为 ref，并在属性缺失时提供默认值。 */
export declare function toRef<T extends object, K extends keyof T, D>(object: T, key: K, defaultValue: D): ObjectRef<Exclude<T[K], undefined> | D>;
/** 将对象所有可枚举属性批量转换为 ref。 */
export declare function toRefs<T extends object>(object: T): ToRefs<T>;
/** 渲染依赖调试事件。 */
export type DebuggerEvent = {
	effect: unknown;
	target: unknown;
	type: "get";
	key: unknown;
};
/** 渲染依赖调试回调。 */
export type DebuggerHook = (event: DebuggerEvent) => void;
/** 注册组件 render 依赖收集调试钩子。 */
export declare function onRenderTracked(callback: DebuggerHook): (() => void) | undefined;
/** 在当前 watcher 失效或停止前注册清理函数。 */
export declare function onWatcherCleanup(cleanupFn: () => void, failSilently?: boolean): void;
/** 在当前 effect scope 停止时注册清理函数。 */
export declare function onScopeDispose(cleanupFn: () => void): void;
/** 等待响应式 flush 完成，可选追加回调。 */
export declare function nextTick<T = void>(callback?: () => T | Promise<T>): Promise<T | void>;
/** 在响应式 flush 后运行并追踪依赖的 watch effect。 */
export declare function watchPostEffect(cb: () => void, options?: {
	scheduler?: (run: () => void) => void;
} | null): EffectHandle;
/** 当前 effect scope 的公开句柄。 */
export interface EffectScope {
	readonly active: boolean;
	run<T = any>(fn: () => T): T | undefined;
	stop(): void;
	dispose(): void;
}
/** 读取当前活动 effect scope。 */
export declare function getCurrentScope(): EffectScope | undefined;
/** createResource 返回的响应式资源状态。 */
export type Resource<TData = any> = {
	/** 已解析数据；读取时会把 pending promise 登记到当前 Suspense。 */
	data: SignalHandle<TData>;
	/** 最近一次加载错误。 */
	error: SignalHandle<any>;
	/** 当前是否处于加载中。 */
	loading: SignalHandle<boolean>;
};
type Primitive$1 = string | number | boolean | bigint | symbol | null | undefined;
type Widen$1<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
export type UseStateOptions<T = any> = {
	equals?: (prev: T, next: T) => boolean;
	kind?: "reactive" | "ref" | "signal";
};
export type StateRef<T> = {
	value: T;
};
export type RefStateSetter<T> = (value: T | ((ref: StateRef<T>) => T | void)) => void;
export type ReactiveStateSetter<T> = (value: T | ((state: T) => T | void)) => void;
export type SignalStateSetter<T> = (value: T | ((signal: SignalHandle<T>) => T | void)) => void;
export declare function useState<T extends Primitive$1>(initial: T | (() => T), options?: UseStateOptions<T> & {
	kind?: "reactive" | "ref";
}): [
	StateRef<Widen$1<T>>,
	RefStateSetter<Widen$1<T>>
];
export declare function useState<T extends Primitive$1>(initial: T | (() => T), options: UseStateOptions<T> & {
	kind: "signal";
}): [
	SignalHandle<Widen$1<T>>,
	SignalStateSetter<Widen$1<T>>
];
export declare function useState<T extends object | Function>(initial: T | (() => T), options?: UseStateOptions<T> & {
	kind?: "reactive";
}): [
	T,
	ReactiveStateSetter<T>
];
export declare function useState<T extends object | Function>(initial: T | (() => T), options: UseStateOptions<T> & {
	kind: "ref";
}): [
	StateRef<T>,
	RefStateSetter<T>
];
export declare function useState<T extends object | Function>(initial: T | (() => T), options: UseStateOptions<T> & {
	kind: "signal";
}): [
	SignalHandle<T>,
	SignalStateSetter<T>
];
export declare function useSignal<T>(initial: T, options?: any): any;
export declare function useEffect(...args: any[]): any;
/** 创建异步资源，并自动接入当前 Suspense 边界。 */
export declare function createResource<TSrc, TData>(src: SignalHandle<TSrc>, fetcher: (src: TSrc) => Promise<TData>): Resource<TData>;
type FC$1<P = {}> = FC<P>;
type PropsWithChildren$1<P = {}> = PropsWithChildren<P>;
/** Transition 组件属性，继承基础过渡配置并接收一个直接子节点。 */
export type TransitionProps = PropsWithChildren$1<BaseTransitionProps>;
/** Transition 组件：为区间内首个元素应用过渡 */
export declare const Transition: FC$1<TransitionProps>;
/** TransitionGroup 组件属性，面向 keyed 多子节点列表。 */
export type TransitionGroupProps = PropsWithChildren<BaseTransitionProps & {
	/** 渲染容器标签，默认 span + display: contents。 */
	tag?: string;
	/** FLIP 移动过渡使用的类名，默认 `${name}-move`。 */
	moveClass?: string;
}>;
/** TransitionGroup：为多元素列表应用过渡与 FLIP 移动 */
export declare const TransitionGroup: FC<TransitionGroupProps>;
/** 安装错误处理能力
 * @param opts overlay/console 开关
 * @returns 组合 API：on/emit/installConsole/installOverlay
 */
export declare function useError(opts?: {
	/** 是否立即安装页面错误覆盖层。 */
	overlay?: boolean;
	/** 是否立即安装控制台错误输出。 */
	console?: boolean;
}): {
	on: (fn: (error: any, instance?: any) => void) => any;
	emit: (error: any, instance?: any) => void;
	installConsole: () => void;
	installOverlay: () => void;
};
/** 异步组件加载函数，支持直接返回组件或动态 import 的 default 导出。 */
export type AsyncComponentLoader<P = any> = () => Promise<{
	default: FC<P>;
} | FC<P>>;
/** 定义异步组件时的完整选项。 */
export interface AsyncComponentOptions<P = any> {
	/** 实际的动态加载函数。 */
	loader: AsyncComponentLoader<P>;
	/** 加载中占位组件。 */
	loadingComponent?: FC<any>;
	/** 加载失败占位组件。 */
	errorComponent?: FC<{
		error: any;
	}>;
	/** 显示 loadingComponent 前的延迟毫秒数。 */
	delay?: number;
	/** 加载超时时间，超时后进入错误状态。 */
	timeout?: number;
	/** 是否把 pending promise 登记到 Suspense 边界。 */
	suspensible?: boolean;
	/** 加载失败处理器，可调用 retry 或 fail 控制后续流程。 */
	onError?: (error: Error, retry: () => void, fail: () => void, attempts: number) => any;
}
/** useComponent 的兼容选项，支持新旧 loading/error 命名。 */
export interface UseComponentOptions<_P = any> {
	/** @deprecated Prefer loadingComponent. */
	loading?: FC<any>;
	/** @deprecated Prefer errorComponent. */
	error?: FC<{
		error: any;
	}>;
	/** 加载中占位组件。 */
	loadingComponent?: FC<any>;
	/** 加载失败占位组件。 */
	errorComponent?: FC<{
		error: any;
	}>;
	/** 显示 loadingComponent 前的延迟毫秒数。 */
	delay?: number;
	/** 加载超时时间，超时后进入错误状态。 */
	timeout?: number;
	/** 是否把 pending promise 登记到 Suspense 边界。 */
	suspensible?: boolean;
	/** 加载失败处理器，可调用 retry 或 fail 控制后续流程。 */
	onError?: (error: Error, retry: () => void, fail: () => void, attempts: number) => any;
}
/** 异步组件加载 Hook
 * @param loader 返回组件或 { default } 的动态导入函数
 * @param opts 可选占位组件：loading / error
 * @returns 异步组件 FC
 */
export declare function useComponent<P = any>(source: AsyncComponentLoader<P> | AsyncComponentOptions<P>, opts?: UseComponentOptions<P>): FC<P>;

declare namespace TransitionUtils {
	export { TransitionPhase, TransitionType, addClass, forceReflow, inferType, nextFrame, removeClass, resolveDuration, toMs, whenTransitionEnds };
}

export {
	TransitionUtils,
	createEffect as effect,
};

export {};
