@vue/runtime-core 3.4.0-alpha.3 → 3.4.0-beta.1

package/dist/runtime-core.d.ts

@@ -14,7 +14,7 @@ declare const SlotSymbol: unique symbol;
 export type SlotsType<T extends Record<string, any> = Record<string, any>> = {
     [SlotSymbol]?: T;
 };
-type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T>;
+type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
 type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{
     [K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? T[K] : Slot<T[K]>;
 }>>;
@@ -58,12 +58,15 @@ export declare function queuePostFlushCb(cb: SchedulerJobs): void;
 export type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
 export type EmitsOptions = ObjectEmitsOptions | string[];
 type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
-    [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
+    [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
 } : T extends ObjectEmitsOptions ? {
-    [K in string & `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}` ? T[Uncapitalize<C>] extends null ? (...args: any[]) => any : (...args: T[Uncapitalize<C>] extends (...args: infer P) => any ? P : never) => any : never;
+    [K in `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}` ? (...args: T[Uncapitalize<C>] extends (...args: infer P) => any ? P : T[Uncapitalize<C>] extends null ? any[] : never) => any : never;
 } : {};
+type ShortEmitsToObject<E> = E extends Record<string, any[]> ? {
+    [K in keyof E]: (...args: E[K]) => any;
+} : E;
 type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{
-    [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : (event: key, ...args: any[]) => void;
+    [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void;
 }[Event]>;
 
 /**
@@ -128,7 +131,7 @@ C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOpt
     $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R]) => any : (...args: any) => any, options?: WatchOptions): WatchStopHandle;
 } & IfAny<P, P, Omit<P, keyof ShallowUnwrapRef<B>>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>;
 
-declare const enum LifecycleHooks {
+declare enum LifecycleHooks {
     BEFORE_CREATE = "bc",
     CREATED = "c",
     BEFORE_MOUNT = "bm",
@@ -160,7 +163,7 @@ export interface SuspenseProps {
 declare const SuspenseImpl: {
     name: string;
     __isSuspense: boolean;
-    process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
+    process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
     hydrate: typeof hydrateSuspense;
     create: typeof createSuspenseBoundary;
     normalize: typeof normalizeSuspenseChildren;
@@ -179,7 +182,7 @@ export interface SuspenseBoundary {
     vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
     parent: SuspenseBoundary | null;
     parentComponent: ComponentInternalInstance | null;
-    isSVG: boolean;
+    namespace: ElementNamespace;
     container: RendererElement;
     hiddenContainer: RendererElement;
     anchor: RendererNode | null;
@@ -199,8 +202,8 @@ export interface SuspenseBoundary {
     registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn): void;
     unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
 }
-declare function createSuspenseBoundary(vnode: VNode, parentSuspense: SuspenseBoundary | null, parentComponent: ComponentInternalInstance | null, container: RendererElement, hiddenContainer: RendererElement, anchor: RendererNode | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, isHydrating?: boolean): SuspenseBoundary;
-declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function createSuspenseBoundary(vnode: VNode, parentSuspense: SuspenseBoundary | null, parentComponent: ComponentInternalInstance | null, container: RendererElement, hiddenContainer: RendererElement, anchor: RendererNode | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, isHydrating?: boolean): SuspenseBoundary;
+declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
 declare function normalizeSuspenseChildren(vnode: VNode): void;
 
 export type RootHydrateFunction = (vnode: VNode<Node, Element>, container: (Element | ShadowRoot) & {
@@ -277,12 +280,13 @@ export interface Renderer<HostElement = RendererElement> {
 export interface HydrationRenderer extends Renderer<Element | ShadowRoot> {
     hydrate: RootHydrateFunction;
 }
-export type RootRenderFunction<HostElement = RendererElement> = (vnode: VNode | null, container: HostElement, isSVG?: boolean) => void;
+export type ElementNamespace = 'svg' | 'mathml' | undefined;
+export type RootRenderFunction<HostElement = RendererElement> = (vnode: VNode | null, container: HostElement, namespace?: ElementNamespace) => void;
 export interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
-    patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, isSVG?: boolean, prevChildren?: VNode<HostNode, HostElement>[], parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, unmountChildren?: UnmountChildrenFn): void;
+    patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, prevChildren?: VNode<HostNode, HostElement>[], parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, unmountChildren?: UnmountChildrenFn): void;
     insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
     remove(el: HostNode): void;
-    createElement(type: string, isSVG?: boolean, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
+    createElement(type: string, namespace?: ElementNamespace, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
         [key: string]: any;
     }) | null): HostElement;
     createText(text: string): HostNode;
@@ -294,7 +298,7 @@ export interface RendererOptions<HostNode = RendererNode, HostElement = Renderer
     querySelector?(selector: string): HostElement | null;
     setScopeId?(el: HostElement, id: string): void;
     cloneNode?(node: HostNode): HostNode;
-    insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, isSVG: boolean, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
+    insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
 }
 export interface RendererNode {
     [key: string]: any;
@@ -314,18 +318,18 @@ interface RendererInternals<HostNode = RendererNode, HostElement = RendererEleme
     o: RendererOptions<HostNode, HostElement>;
 }
 type PatchFn = (n1: VNode | null, // null means this is a mount
-n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, isSVG?: boolean, slotScopeIds?: string[] | null, optimized?: boolean) => void;
-type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
-type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean) => void;
-type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null) => void;
+n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
+type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
+type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
+type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
 type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
 type NextFn = (vnode: VNode) => RendererNode | null;
 type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
 type RemoveFn = (vnode: VNode) => void;
 type UnmountChildrenFn = (children: VNode[], parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean, start?: number) => void;
-type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
-type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
-declare const enum MoveType {
+type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+declare enum MoveType {
     ENTER = 0,
     LEAVE = 1,
     REORDER = 2
@@ -389,7 +393,7 @@ interface PropOptions<T = any, D = T> {
     type?: PropType<T> | true | null;
     required?: boolean;
     default?: D | DefaultFactory<D> | null | undefined | object;
-    validator?(value: unknown): boolean;
+    validator?(value: unknown, props: Data): boolean;
 }
 export type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
 type PropConstructor<T = any> = {
@@ -514,7 +518,7 @@ export type DirectiveArguments = Array<[Directive | undefined] | [Directive | un
  */
 export declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T;
 
-export declare const enum DeprecationTypes {
+declare enum DeprecationTypes$1 {
     GLOBAL_MOUNT = "GLOBAL_MOUNT",
     GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
     GLOBAL_EXTEND = "GLOBAL_EXTEND",
@@ -558,7 +562,7 @@ export declare const enum DeprecationTypes {
     FILTERS = "FILTERS",
     PRIVATE_APIS = "PRIVATE_APIS"
 }
-type CompatConfig = Partial<Record<DeprecationTypes, boolean | 'suppress-warning'>> & {
+type CompatConfig = Partial<Record<DeprecationTypes$1, boolean | 'suppress-warning'>> & {
     MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
 };
 declare function configureCompat(config: CompatConfig): void;
@@ -737,7 +741,7 @@ export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T
  */
 export declare function hasInjectionContext(): boolean;
 
-type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+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 = {}> = ComponentPublicInstanceConstructor<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, PP & Props, Defaults, true, {}, S>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S> & PP;
 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'> & {
@@ -764,9 +768,9 @@ export interface App<HostElement = any> {
     mixin(mixin: ComponentOptions): this;
     component(name: string): Component | undefined;
     component(name: string, component: Component | DefineComponent): this;
-    directive(name: string): Directive | undefined;
-    directive(name: string, directive: Directive): this;
-    mount(rootContainer: HostElement | string, isHydrate?: boolean, isSVG?: boolean): ComponentPublicInstance;
+    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;
     unmount(): void;
     provide<T>(key: InjectionKey<T> | string, value: T): this;
     /**
@@ -805,11 +809,6 @@ export interface AppConfig {
      * @deprecated use config.compilerOptions.isCustomElement
      */
     isCustomElement?: (tag: string) => boolean;
-    /**
-     * Temporary config for opt-in to unwrap injected refs.
-     * @deprecated this no longer has effect. 3.3 always unwraps injected refs.
-     */
-    unwrapInjectedRef?: boolean;
 }
 export interface AppContext {
     app: App;
@@ -819,12 +818,12 @@ export interface AppContext {
     directives: Record<string, Directive>;
     provides: Record<string | symbol, any>;
 }
-type PluginInstallFunction<Options> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
-export type Plugin<Options = any[]> = (PluginInstallFunction<Options> & {
-    install?: PluginInstallFunction<Options>;
-}) | {
+type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
+export type ObjectPlugin<Options = any[]> = {
     install: PluginInstallFunction<Options>;
 };
+export type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
+export type Plugin<Options = any[]> = FunctionPlugin<Options> | ObjectPlugin<Options>;
 export type CreateAppFunction<HostElement> = (rootComponent: Component, rootProps?: Data | null) => App<HostElement>;
 
 type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
@@ -835,12 +834,12 @@ export interface TeleportProps {
 declare const TeleportImpl: {
     name: string;
     __isTeleport: boolean;
-    process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
+    process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
     remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, optimized: boolean, { um: unmount, o: { remove: hostRemove } }: RendererInternals, doRemove: boolean): void;
     move: typeof moveTeleport;
     hydrate: typeof hydrateTeleport;
 };
-declare const enum TeleportMoveTypes {
+declare enum TeleportMoveTypes {
     TARGET_CHANGE = 0,
     TOGGLE = 1,
     REORDER = 2
@@ -1012,6 +1011,21 @@ export declare function createCommentVNode(text?: string, asBlock?: boolean): VN
 export declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
 
 type Data = Record<string, unknown>;
+/**
+ * Public utility type for extracting the instance type of a component.
+ * Works with all valid component definition types. This is intended to replace
+ * the usage of `InstanceType<typeof Comp>` which only works for
+ * constructor-based component definition types.
+ *
+ * Exmaple:
+ * ```ts
+ * const MyComp = { ... }
+ * declare const instance: ComponentInstance<typeof MyComp>
+ * ```
+ */
+export type ComponentInstance<T> = T extends {
+    new (): ComponentPublicInstance;
+} ? InstanceType<T> : T extends FunctionalComponent<infer Props, infer Emits> ? ComponentPublicInstance<Props, {}, {}, {}, {}, ShortEmitsToObject<Emits>> : T extends Component<infer Props, infer RawBindings, infer D, infer C, infer M> ? ComponentPublicInstance<unknown extends Props ? {} : Props, unknown extends RawBindings ? {} : RawBindings, unknown extends D ? {} : D, C, M> : never;
 /**
  * For extending allowed non-declared props on components in TSX
  */
@@ -1038,10 +1052,10 @@ interface ComponentInternalOptions {
      */
     __name?: string;
 }
-export interface FunctionalComponent<P = {}, E extends EmitsOptions = {}, S extends Record<string, any> = any> extends ComponentInternalOptions {
-    (props: P, ctx: Omit<SetupContext<E, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
+export interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
+    (props: P & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
     props?: ComponentPropsOptions<P>;
-    emits?: E | (keyof E)[];
+    emits?: EE | (keyof EE)[];
     slots?: IfAny<S, Slots, SlotsType<S>>;
     inheritAttrs?: boolean;
     displayName?: string;
@@ -1057,12 +1071,12 @@ interface ClassComponent {
  * values, e.g. checking if its a function or not. This is mostly for internal
  * implementation code.
  */
-export type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, any>;
+export type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
 /**
  * A type used in public APIs where a component type is expected.
  * The constructor type is an artificial type returned by defineComponent().
  */
-export type Component<Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = ConcreteComponent<Props, RawBindings, D, C, M> | ComponentPublicInstanceConstructor<Props>;
+export type Component<Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<Props, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<Props>;
 
 export type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
     attrs: Data;
@@ -1187,9 +1201,9 @@ export declare function defineAsyncComponent<T extends Component = {
  *   foo?: string
  *   bar: number
  * }>()
+ * ```
  *
  * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
- * ```
  *
  * This is only usable inside `<script setup>`, is compiled away in the
  * output and should **not** be actually called at runtime.
@@ -1199,7 +1213,7 @@ export declare function defineProps<PropNames extends string = string>(props: Pr
 }>>;
 export declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
 export declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
-type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
+export type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
     readonly [K in BKeys]-?: boolean;
 };
 type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
@@ -1215,8 +1229,9 @@ type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends
  * Example type-based declaration:
  * ```ts
  * const emit = defineEmits<{
- *   (event: 'change'): void
- *   (event: 'update', id: number): void
+ *   // <eventName>: <expected arguments>
+ *   change: []
+ *   update: [value: string] // named tuple syntax
  * }>()
  *
  * emit('change')
@@ -1264,7 +1279,7 @@ export declare function defineOptions<RawBindings = {}, D = {}, C extends Comput
 }): void;
 export declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
 /**
- * (**Experimental**) Vue `<script setup>` compiler macro for declaring a
+ * Vue `<script setup>` compiler macro for declaring a
  * two-way binding prop that can be consumed via `v-model` from the parent
  * component. This will declare a prop with the same name and a corresponding
  * `update:propName` event.
@@ -1273,9 +1288,11 @@ export declare function defineSlots<S extends Record<string, any> = Record<strin
  * Otherwise the prop name will default to "modelValue". In both cases, you
  * can also pass an additional object which will be used as the prop's options.
  *
- * The options object can also specify an additional option, `local`. When set
- * to `true`, the ref can be locally mutated even if the parent did not pass
- * the matching `v-model`.
+ * The the returned ref behaves differently depending on whether the parent
+ * provided the corresponding v-model props or not:
+ * - If yes, the returned ref's value will always be in sync with the parent
+ *   prop.
+ * - If not, the returned ref will behave like a normal local ref.
  *
  * @example
  * ```ts
@@ -1292,29 +1309,22 @@ export declare function defineSlots<S extends Record<string, any> = Record<strin
  *
  * // with specified name and default value
  * const count = defineModel<number>('count', { default: 0 })
- *
- * // local mutable model, can be mutated locally
- * // even if the parent did not pass the matching `v-model`.
- * const count = defineModel<number>('count', { local: true, default: 0 })
  * ```
  */
 export declare function defineModel<T>(options: {
     required: true;
-} & PropOptions<T> & DefineModelOptions): Ref<T>;
+} & PropOptions<T>): Ref<T>;
 export declare function defineModel<T>(options: {
     default: any;
-} & PropOptions<T> & DefineModelOptions): Ref<T>;
-export declare function defineModel<T>(options?: PropOptions<T> & DefineModelOptions): Ref<T | undefined>;
+} & PropOptions<T>): Ref<T>;
+export declare function defineModel<T>(options?: PropOptions<T>): Ref<T | undefined>;
 export declare function defineModel<T>(name: string, options: {
     required: true;
-} & PropOptions<T> & DefineModelOptions): Ref<T>;
+} & PropOptions<T>): Ref<T>;
 export declare function defineModel<T>(name: string, options: {
     default: any;
-} & PropOptions<T> & DefineModelOptions): Ref<T>;
-export declare function defineModel<T>(name: string, options?: PropOptions<T> & DefineModelOptions): Ref<T | undefined>;
-interface DefineModelOptions {
-    local?: boolean;
-}
+} & PropOptions<T>): Ref<T>;
+export declare function defineModel<T>(name: string, options?: PropOptions<T>): Ref<T | undefined>;
 type NotUndefined<T> = T extends undefined ? never : T;
 type InferDefaults<T> = {
     [K in keyof T]?: InferDefault<T, T[K]>;
@@ -1349,9 +1359,7 @@ type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof
 export declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
 export declare function useSlots(): SetupContext['slots'];
 export declare function useAttrs(): SetupContext['attrs'];
-export declare function useModel<T extends Record<string, any>, K extends keyof T>(props: T, name: K, options?: {
-    local?: boolean;
-}): Ref<T[K]>;
+export declare function useModel<T extends Record<string, any>, K extends keyof T>(props: T, name: K): Ref<T[K]>;
 
 type RawProps = VNodeProps & {
     __v_isVNode?: never;
@@ -1366,6 +1374,11 @@ interface Constructor<P = any> {
         $props: P;
     };
 }
+type HTMLElementEventHandler = {
+    [K in keyof HTMLElementEventMap as `on${Capitalize<K>}`]?: (ev: HTMLElementEventMap[K]) => any;
+};
+export declare function h<K extends keyof HTMLElementTagNameMap>(type: K, children?: RawChildren): VNode;
+export declare function h<K extends keyof HTMLElementTagNameMap>(type: K, props?: (RawProps & HTMLElementEventHandler) | null, children?: RawChildren | RawSlots): VNode;
 export declare function h(type: string, children?: RawChildren): VNode;
 export declare function h(type: string, props?: RawProps | null, children?: RawChildren | RawSlots): VNode;
 export declare function h(type: typeof Text | typeof Comment, children?: string | number | boolean): VNode;
@@ -1393,7 +1406,7 @@ export declare const useSSRContext: <T = Record<string, any>>() => T | undefined
 
 export declare function warn(msg: string, ...args: any[]): void;
 
-export declare const enum ErrorCodes {
+export declare enum ErrorCodes {
     SETUP_FUNCTION = 0,
     RENDER_FUNCTION = 1,
     WATCH_GETTER = 2,
@@ -1578,8 +1591,8 @@ export type CompatVue = Pick<App, 'version' | 'component' | 'directive'> & {
     mixin(mixin: ComponentOptions): CompatVue;
     component(name: string): Component | undefined;
     component(name: string, component: Component): CompatVue;
-    directive(name: string): Directive | undefined;
-    directive(name: string, directive: Directive): CompatVue;
+    directive<T = any, V = any>(name: string): Directive<T, V> | undefined;
+    directive<T = any, V = any>(name: string, directive: Directive<T, V>): CompatVue;
     compile(template: string): RenderFunction;
     /**
      * @deprecated Vue 3 no longer supports extending constructors.
@@ -1613,6 +1626,8 @@ declare module '@vue/reactivity' {
     }
 }
 
+export declare const DeprecationTypes: typeof DeprecationTypes$1;
+
 export { createBaseVNode as createElementVNode,  };
 // Note: this file is auto concatenated to the end of the bundled d.ts during
 // build.