@vue/runtime-core 3.5.0-alpha.5 → 3.5.0-beta.2

package/dist/runtime-core.d.ts

@@ -334,7 +334,7 @@ type InferDefaults<T> = {
 type NativeType = null | number | string | boolean | symbol | Function;
 type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
 type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = Readonly<MappedOmit<T, keyof Defaults>> & {
-    readonly [K in keyof Defaults]-?: K extends keyof T ? Defaults[K] extends undefined ? T[K] : NotUndefined<T[K]> : never;
+    readonly [K in keyof Defaults]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never;
 } & {
     readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean;
 };
@@ -419,7 +419,7 @@ export interface ObjectDirective<HostElement = any, Value = any, Modifiers exten
 export type FunctionDirective<HostElement = any, V = any, Modifiers extends string = string, Arg extends string = string> = DirectiveHook<HostElement, any, V, Modifiers, Arg>;
 export type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg extends string = string> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
 type DirectiveModifiers<K extends string = string> = Record<K, boolean>;
-export type DirectiveArguments = Array<[Directive | undefined] | [Directive | undefined, any] | [Directive | undefined, any, string] | [Directive | undefined, any, string, DirectiveModifiers]>;
+export type DirectiveArguments = Array<[Directive | undefined] | [Directive | undefined, any] | [Directive | undefined, any, string] | [Directive | undefined, any, string | undefined, DirectiveModifiers]>;
 /**
  * Adds directives to a VNode.
  */
@@ -434,7 +434,7 @@ export declare function withDirectives<T extends VNode>(vnode: T, directives: Di
  * import { createApp } from 'vue'
  * import { Router, createRouter } from 'vue-router'
  *
- * declare module '@vue/runtime-core' {
+ * declare module 'vue' {
  *   interface ComponentCustomProperties {
  *     $router: Router
  *   }
@@ -478,20 +478,21 @@ export type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends Comp
  * inference everywhere internally, but it has to be a new type to avoid
  * breaking types that relies on previous arguments order (#10842)
  */
-export type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed>;
+export type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs>;
 type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
 export type ComponentPublicInstance<P = {}, // props type extracted from props option
 B = {}, // raw bindings returned from setup()
 D = {}, // return from data()
-C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = ''> = {
+C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data = {}> = {
     $: ComponentInternalInstance;
     $data: D;
     $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
     $attrs: Data;
-    $refs: Data;
+    $refs: Data & TypeRefs;
     $slots: UnwrapSlotsType<S>;
     $root: ComponentPublicInstance | null;
     $parent: ComponentPublicInstance | null;
+    $host: Element | null;
     $emit: EmitFn<E>;
     $el: any;
     $options: Options & MergedComponentOptionsOverride;
@@ -537,6 +538,7 @@ declare const SuspenseImpl: {
     normalize: typeof normalizeSuspenseChildren;
 };
 export declare const Suspense: {
+    __isSuspense: true;
     new (): {
         $props: VNodeProps & SuspenseProps;
         $slots: {
@@ -544,7 +546,6 @@ export declare const Suspense: {
             fallback(): VNode[];
         };
     };
-    __isSuspense: true;
 };
 export interface SuspenseBoundary {
     vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
@@ -612,27 +613,13 @@ export interface TransitionState {
     leavingVNodes: Map<any, Record<string, VNode>>;
 }
 export declare function useTransitionState(): TransitionState;
-export declare const BaseTransitionPropsValidators: {
-    mode: StringConstructor;
-    appear: BooleanConstructor;
-    persisted: BooleanConstructor;
-    onBeforeEnter: (ArrayConstructor | FunctionConstructor)[];
-    onEnter: (ArrayConstructor | FunctionConstructor)[];
-    onAfterEnter: (ArrayConstructor | FunctionConstructor)[];
-    onEnterCancelled: (ArrayConstructor | FunctionConstructor)[];
-    onBeforeLeave: (ArrayConstructor | FunctionConstructor)[];
-    onLeave: (ArrayConstructor | FunctionConstructor)[];
-    onAfterLeave: (ArrayConstructor | FunctionConstructor)[];
-    onLeaveCancelled: (ArrayConstructor | FunctionConstructor)[];
-    onBeforeAppear: (ArrayConstructor | FunctionConstructor)[];
-    onAppear: (ArrayConstructor | FunctionConstructor)[];
-    onAfterAppear: (ArrayConstructor | FunctionConstructor)[];
-    onAppearCancelled: (ArrayConstructor | FunctionConstructor)[];
-};
-export declare const BaseTransition: new () => {
-    $props: BaseTransitionProps<any>;
-    $slots: {
-        default(): VNode[];
+export declare const BaseTransitionPropsValidators: Record<string, any>;
+export declare const BaseTransition: {
+    new (): {
+        $props: BaseTransitionProps<any>;
+        $slots: {
+            default(): VNode[];
+        };
     };
 };
 export declare function resolveTransitionHooks(vnode: VNode, props: BaseTransitionProps<any>, state: TransitionState, instance: ComponentInternalInstance, postClone?: (hooks: TransitionHooks) => void): TransitionHooks;
@@ -724,27 +711,28 @@ export interface KeepAliveProps {
     max?: number | string;
 }
 export declare const KeepAlive: {
+    __isKeepAlive: true;
     new (): {
         $props: VNodeProps & KeepAliveProps;
         $slots: {
             default(): VNode[];
         };
     };
-    __isKeepAlive: true;
 };
 export declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void;
 export declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void;
 
-export declare const onBeforeMount: (hook: () => any, target?: ComponentInternalInstance | null) => void;
-export declare const onMounted: (hook: () => any, target?: ComponentInternalInstance | null) => void;
-export declare const onBeforeUpdate: (hook: () => any, target?: ComponentInternalInstance | null) => void;
-export declare const onUpdated: (hook: () => any, target?: ComponentInternalInstance | null) => void;
-export declare const onBeforeUnmount: (hook: () => any, target?: ComponentInternalInstance | null) => void;
-export declare const onUnmounted: (hook: () => any, target?: ComponentInternalInstance | null) => void;
-export declare const onServerPrefetch: (hook: () => any, target?: ComponentInternalInstance | null) => void;
+type CreateHook<T = any> = (hook: T, target?: ComponentInternalInstance | null) => void;
+export declare const onBeforeMount: CreateHook;
+export declare const onMounted: CreateHook;
+export declare const onBeforeUpdate: CreateHook;
+export declare const onUpdated: CreateHook;
+export declare const onBeforeUnmount: CreateHook;
+export declare const onUnmounted: CreateHook;
+export declare const onServerPrefetch: CreateHook;
 type DebuggerHook = (e: DebuggerEvent) => void;
-export declare const onRenderTriggered: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => void;
-export declare const onRenderTracked: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => void;
+export declare const onRenderTriggered: CreateHook<DebuggerHook>;
+export declare const onRenderTracked: CreateHook<DebuggerHook>;
 type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
 export declare function onErrorCaptured<TError = Error>(hook: ErrorCapturedHook<TError>, target?: ComponentInternalInstance | null): void;
 
@@ -802,7 +790,7 @@ declare function configureCompat(config: CompatConfig): void;
  *
  * @example
  * ```ts
- * declare module '@vue/runtime-core' {
+ * declare module 'vue' {
  *   interface ComponentCustomOptions {
  *     beforeRouteUpdate?(
  *       to: Route,
@@ -975,8 +963,9 @@ export type ComponentOptionsWithObjectProps<PropsOptions = ComponentObjectPropsO
     props: PropsOptions & ThisType<void>;
 } & ThisType<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I, S, LC, Directives>>;
 
-export interface InjectionKey<T> extends Symbol {
+interface InjectionConstraint<T> {
 }
+export type InjectionKey<T> = symbol & InjectionConstraint<T>;
 export declare function provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): void;
 export declare function inject<T>(key: InjectionKey<T> | string): T | undefined;
 export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T, treatDefaultAsFactory?: false): T;
@@ -990,7 +979,7 @@ export declare function hasInjectionContext(): boolean;
 
 export type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
 type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
-export type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP & Props, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+export type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP & Props, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
 export type DefineSetupFnComponent<P extends Record<string, any>, E extends EmitsOptions = {}, S extends SlotsType = SlotsType, Props = P & EmitsToProps<E>, PP = PublicProps> = new (props: Props & PP) => CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, E, PP, {}, false, {}, S>;
 export declare function defineComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, 'name' | 'inheritAttrs'> & {
     props?: (keyof Props)[];
@@ -1004,7 +993,7 @@ export declare function defineComponent<Props extends Record<string, any>, E ext
 }): DefineSetupFnComponent<Props, E, S>;
 export declare function defineComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, InjectOptions extends ComponentInjectOptions = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, ResolvedEmits extends EmitsOptions = {} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions, InferredProps = unknown extends TypeProps ? string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : {
     [key in RuntimePropsKeys]?: any;
-} : TypeProps, ResolvedProps = Readonly<InferredProps & EmitsToProps<ResolvedEmits>>>(options: {
+} : TypeProps, ResolvedProps = Readonly<InferredProps & EmitsToProps<ResolvedEmits>>, TypeRefs extends Record<string, unknown> = {}>(options: {
     props?: (RuntimePropsOptions & ThisType<void>) | RuntimePropsKeys[];
     /**
      * @private for language-tools use only
@@ -1014,8 +1003,12 @@ export declare function defineComponent<TypeProps, RuntimePropsOptions extends C
      * @private for language-tools use only
      */
     __typeEmits?: TypeEmits;
+    /**
+     * @private for language-tools use only
+     */
+    __typeRefs?: TypeRefs;
 } & ComponentOptionsBase<ResolvedProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, RuntimeEmitsOptions, RuntimeEmitsKeys, {}, // Defaults
-InjectOptions, InjectKeys, Slots, LocalComponents, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<ResolvedProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, RuntimeEmitsKeys, {}, false, InjectOptions, Slots, LocalComponents, Directives, Exposed>>): DefineComponent<InferredProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, RuntimeEmitsKeys, PublicProps, ResolvedProps, ExtractDefaultPropTypes<RuntimePropsOptions>, Slots, LocalComponents, Directives, Exposed, Provide, unknown extends TypeProps ? true : false>;
+InjectOptions, InjectKeys, Slots, LocalComponents, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<ResolvedProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, RuntimeEmitsKeys, {}, false, InjectOptions, Slots, LocalComponents, Directives, Exposed>>): DefineComponent<InferredProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, RuntimeEmitsKeys, PublicProps, ResolvedProps, ExtractDefaultPropTypes<RuntimePropsOptions>, Slots, LocalComponents, Directives, Exposed, Provide, unknown extends TypeProps ? true : false, TypeRefs>;
 
 export interface App<HostElement = any> {
     version: string;
@@ -1027,7 +1020,19 @@ export interface App<HostElement = any> {
     component<T extends Component | DefineComponent>(name: string, component: T): this;
     directive<T = any, V = any>(name: string): Directive<T, V> | undefined;
     directive<T = any, V = any>(name: string, directive: Directive<T, V>): this;
-    mount(rootContainer: HostElement | string, isHydrate?: boolean, namespace?: boolean | ElementNamespace): ComponentPublicInstance;
+    mount(rootContainer: HostElement | string, 
+    /**
+     * @internal
+     */
+    isHydrate?: boolean, 
+    /**
+     * @internal
+     */
+    namespace?: boolean | ElementNamespace, 
+    /**
+     * @internal
+     */
+    vnode?: VNode): ComponentPublicInstance;
     unmount(): void;
     onUnmount(cb: () => void): void;
     provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): this;
@@ -1121,13 +1126,13 @@ declare enum TeleportMoveTypes {
 declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, moveType?: TeleportMoveTypes): void;
 declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, { o: { nextSibling, parentNode, querySelector, insert, createText }, }: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
 export declare const Teleport: {
+    __isTeleport: true;
     new (): {
         $props: VNodeProps & TeleportProps;
         $slots: {
             default(): VNode[];
         };
     };
-    __isTeleport: true;
 };
 
 /**
@@ -1145,10 +1150,10 @@ export declare function resolveDynamicComponent(component: unknown): VNodeTypes;
 export declare function resolveDirective(name: string): Directive | undefined;
 
 export declare const Fragment: {
+    __isFragment: true;
     new (): {
         $props: VNodeProps;
     };
-    __isFragment: true;
 };
 export declare const Text: unique symbol;
 export declare const Comment: unique symbol;
@@ -1255,9 +1260,7 @@ export declare function setBlockTracking(value: number): void;
 /**
  * @private
  */
-export declare function createElementBlock(type: string | typeof Fragment, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[], shapeFlag?: number): VNode<RendererNode, RendererElement, {
-    [key: string]: any;
-}>;
+export declare function createElementBlock(type: string | typeof Fragment, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[], shapeFlag?: number): VNode;
 /**
  * Create a block root vnode. Takes the same exact arguments as `createVNode`.
  * A block root keeps track of dynamic nodes within the block in the
@@ -1275,9 +1278,7 @@ declare let vnodeArgsTransformer: ((args: Parameters<typeof _createVNode>, insta
  * typings
  */
 export declare function transformVNodeArgs(transformer?: typeof vnodeArgsTransformer): void;
-export declare function createBaseVNode(type: VNodeTypes | ClassComponent | typeof NULL_DYNAMIC_COMPONENT, props?: (Data & VNodeProps) | null, children?: unknown, patchFlag?: number, dynamicProps?: string[] | null, shapeFlag?: number, isBlockNode?: boolean, needFullChildrenNormalization?: boolean): VNode<RendererNode, RendererElement, {
-    [key: string]: any;
-}>;
+export declare function createBaseVNode(type: VNodeTypes | ClassComponent | typeof NULL_DYNAMIC_COMPONENT, props?: (Data & VNodeProps) | null, children?: unknown, patchFlag?: number, dynamicProps?: string[] | null, shapeFlag?: number, isBlockNode?: boolean, needFullChildrenNormalization?: boolean): VNode;
 
 export declare const createVNode: typeof _createVNode;
 declare function _createVNode(type: VNodeTypes | ClassComponent | typeof NULL_DYNAMIC_COMPONENT, props?: (Data & VNodeProps) | null, children?: unknown, patchFlag?: number, dynamicProps?: string[] | null, isBlockNode?: boolean): VNode;
@@ -1459,6 +1460,8 @@ export declare const getCurrentInstance: () => ComponentInternalInstance | null;
  */
 export declare function registerRuntimeCompiler(_compile: any): void;
 export declare const isRuntimeOnly: () => boolean;
+export interface ComponentCustomElementInterface {
+}
 
 export type WatchEffect = (onCleanup: OnCleanup) => void;
 export type WatchSource<T = any> = Ref<T, any> | ComputedRef<T> | (() => T);
@@ -1473,18 +1476,23 @@ export interface WatchOptionsBase extends DebuggerOptions {
 }
 export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
     immediate?: Immediate;
-    deep?: boolean;
+    deep?: boolean | number;
     once?: boolean;
 }
 export type WatchStopHandle = () => void;
-export declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchStopHandle;
+export interface WatchHandle extends WatchStopHandle {
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+}
+export declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchHandle;
 export declare function watchPostEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
 export declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
-type MultiWatchSources = (WatchSource<unknown> | object)[];
-export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
-export declare function watch<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: readonly [...T] | T, cb: [T] extends [ReactiveMarker] ? WatchCallback<T, MaybeUndefined<T, Immediate>> : WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
-export declare function watch<T extends MultiWatchSources, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
-export declare function watch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export type MultiWatchSources = (WatchSource<unknown> | object)[];
+export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
+export declare function watch<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: readonly [...T] | T, cb: [T] extends [ReactiveMarker] ? WatchCallback<T, MaybeUndefined<T, Immediate>> : WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
+export declare function watch<T extends MultiWatchSources, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
+export declare function watch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
 
 /**
  * A lazy hydration strategy for async components.
@@ -1496,11 +1504,11 @@ export declare function watch<T extends object, Immediate extends Readonly<boole
  *          listeners.
  */
 export type HydrationStrategy = (hydrate: () => void, forEachElement: (cb: (el: Element) => any) => void) => (() => void) | void;
-export type HydrationStrategyFactory<Options = any> = (options?: Options) => HydrationStrategy;
-export declare const hydrateOnIdle: HydrationStrategyFactory;
-export declare const hydrateOnVisible: HydrationStrategyFactory<string | number>;
+export type HydrationStrategyFactory<Options> = (options?: Options) => HydrationStrategy;
+export declare const hydrateOnIdle: HydrationStrategyFactory<number>;
+export declare const hydrateOnVisible: HydrationStrategyFactory<IntersectionObserverInit>;
 export declare const hydrateOnMediaQuery: HydrationStrategyFactory<string>;
-export declare const hydrateOnInteraction: HydrationStrategyFactory<string | string[]>;
+export declare const hydrateOnInteraction: HydrationStrategyFactory<keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap>>;
 
 type AsyncComponentResolveResult<T = Component> = T | {
     default: T;
@@ -1523,7 +1531,7 @@ export declare function defineAsyncComponent<T extends Component = {
 
 export declare function useModel<M extends PropertyKey, T extends Record<string, any>, K extends keyof T>(props: T, name: K, options?: DefineModelOptions<T[K]>): ModelRef<T[K], M>;
 
-export declare function useTemplateRef<T = unknown>(key: string): Readonly<ShallowRef<T | null>>;
+export declare function useTemplateRef<T = unknown, Keys extends string = string>(key: Keys): Readonly<ShallowRef<T | null>>;
 
 export declare function useId(): string | undefined;
 
@@ -1697,9 +1705,7 @@ interface CompiledSlotDescriptor {
  */
 export declare function createSlots(slots: Record<string, SSRSlot>, dynamicSlots: (CompiledSlotDescriptor | CompiledSlotDescriptor[] | undefined)[]): Record<string, SSRSlot>;
 
-export declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any, {
-    [key: string]: any;
-}>;
+export declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any>;
 export declare function isMemoSame(cached: VNode, memo: any[]): boolean;
 
 export type LegacyConfig = {