@vue/runtime-core 3.3.0-alpha.1 → 3.3.0-alpha.11

package/dist/runtime-core.d.ts

@@ -1,23 +1,30 @@
 import { computed as computed$1, ShallowUnwrapRef, UnwrapNestedRefs, DebuggerEvent, ComputedGetter, WritableComputedOptions, Ref, ReactiveFlags, ReactiveEffect, EffectScope, ComputedRef, DebuggerOptions, reactive } from '@vue/reactivity';
-export { ComputedGetter, ComputedRef, ComputedSetter, CustomRefFactory, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, EffectScheduler, EffectScope, Raw, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags, Ref, ShallowReactive, ShallowRef, ShallowUnwrapRef, ToRef, ToRefs, TrackOpTypes, TriggerOpTypes, UnwrapNestedRefs, UnwrapRef, WritableComputedOptions, WritableComputedRef, customRef, effect, effectScope, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, triggerRef, unref } from '@vue/reactivity';
-import { SlotFlags, UnionToIntersection, IfAny, LooseRequired, ShapeFlags } from '@vue/shared';
+export { ComputedGetter, ComputedRef, ComputedSetter, CustomRefFactory, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, EffectScheduler, EffectScope, MaybeRef, MaybeRefOrGetter, Raw, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags, Ref, ShallowReactive, ShallowRef, ShallowUnwrapRef, ToRef, ToRefs, TrackOpTypes, TriggerOpTypes, UnwrapNestedRefs, UnwrapRef, WritableComputedOptions, WritableComputedRef, customRef, effect, effectScope, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';
+import { IfAny, Prettify, SlotFlags, UnionToIntersection, LooseRequired } from '@vue/shared';
 export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
 
-declare const computed: typeof computed$1;
+export declare const computed: typeof computed$1;
 
-export type Slot = (...args: any[]) => VNode[];
-export type InternalSlots = {
+export type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
+type InternalSlots = {
     [name: string]: Slot | undefined;
 };
 export type Slots = Readonly<InternalSlots>;
-export type RawSlots = {
+declare const SlotSymbol: unique symbol;
+export type SlotsType<T extends Record<string, any> = Record<string, any>> = {
+    [SlotSymbol]?: T;
+};
+type TypedSlots<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]>;
+}>>;
+type RawSlots = {
     [name: string]: unknown;
     $stable?: boolean;
     /* removed internal: _ctx */
     /* removed internal: _ */
 };
 
-export interface SchedulerJob extends Function {
+interface SchedulerJob extends Function {
     id?: number;
     pre?: boolean;
     active?: boolean;
@@ -45,18 +52,18 @@ export interface SchedulerJob extends Function {
      */
     ownerInstance?: ComponentInternalInstance;
 }
-export type SchedulerJobs = SchedulerJob | SchedulerJob[];
-declare function nextTick<T = void>(this: T, fn?: (this: T) => void): Promise<void>;
-declare function queuePostFlushCb(cb: SchedulerJobs): void;
+type SchedulerJobs = SchedulerJob | SchedulerJob[];
+export declare function nextTick<T = void>(this: T, fn?: (this: T) => void): Promise<void>;
+export declare function queuePostFlushCb(cb: SchedulerJobs): void;
 
 export type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
 export type EmitsOptions = ObjectEmitsOptions | string[];
-export type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
+type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
     [K in string & `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;
 } : {};
-export 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<{
+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;
 }[Event]>;
 
@@ -87,31 +94,31 @@ export type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = k
  */
 export interface ComponentCustomProperties {
 }
-export type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
-export type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
-export type ExtractMixin<T> = {
+type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
+type ExtractMixin<T> = {
     Mixin: MixinToOptionTypes<T>;
 }[T extends ComponentOptionsMixin ? 'Mixin' : never];
-export type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType<{}, {}, {}, {}, {}> : UnionToIntersection<ExtractMixin<T>>;
-export type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
-export type EnsureNonVoid<T> = T extends void ? {} : T;
-export type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
+type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType<{}, {}, {}, {}, {}> : UnionToIntersection<ExtractMixin<T>>;
+type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
+type EnsureNonVoid<T> = T extends void ? {} : T;
+type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
     new (...args: any[]): T;
 };
-export type CreateComponentPublicInstance<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 = {}, 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>, I>;
+export type CreateComponentPublicInstance<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 = {}, 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>, I, S>;
 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 = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}> = {
+C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}> = {
     $: ComponentInternalInstance;
     $data: D;
-    $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults> : P & PublicProps;
+    $props: Prettify<MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults> : P & PublicProps>;
     $attrs: Data;
     $refs: Data;
-    $slots: Slots;
+    $slots: TypedSlots<S>;
     $root: ComponentPublicInstance | null;
     $parent: ComponentPublicInstance | null;
     $emit: EmitFn<E>;
@@ -153,7 +160,7 @@ declare const SuspenseImpl: {
     create: typeof createSuspenseBoundary;
     normalize: typeof normalizeSuspenseChildren;
 };
-declare const Suspense: {
+export declare const Suspense: {
     new (): {
         $props: VNodeProps & SuspenseProps;
     };
@@ -222,7 +229,7 @@ export interface RendererNode {
 }
 export interface RendererElement extends RendererNode {
 }
-export interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
+interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
     p: PatchFn;
     um: UnmountFn;
     r: RemoveFn;
@@ -234,18 +241,18 @@ export interface RendererInternals<HostNode = RendererNode, HostElement = Render
     n: NextFn;
     o: RendererOptions<HostNode, HostElement>;
 }
-export type PatchFn = (n1: VNode | null, // null means this is a mount
+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;
-export 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;
-export 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;
-export type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null) => void;
-export type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
-export type NextFn = (vnode: VNode) => RendererNode | null;
-export type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
-export type RemoveFn = (vnode: VNode) => void;
-export type UnmountChildrenFn = (children: VNode[], parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean, start?: number) => void;
-export type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
-export type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, 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;
+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 {
     ENTER = 0,
     LEAVE = 1,
@@ -266,63 +273,65 @@ declare const enum MoveType {
  * })
  * ```
  */
-declare function createRenderer<HostNode = RendererNode, HostElement = RendererElement>(options: RendererOptions<HostNode, HostElement>): Renderer<HostElement>;
-declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer;
+export declare function createRenderer<HostNode = RendererNode, HostElement = RendererElement>(options: RendererOptions<HostNode, HostElement>): Renderer<HostElement>;
+export declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer;
 
-export type MatchPattern = string | RegExp | (string | RegExp)[];
+type MatchPattern = string | RegExp | (string | RegExp)[];
 export interface KeepAliveProps {
     include?: MatchPattern;
     exclude?: MatchPattern;
     max?: number | string;
 }
-declare const KeepAlive: {
+export declare const KeepAlive: {
     new (): {
         $props: VNodeProps & KeepAliveProps;
     };
     __isKeepAlive: true;
 };
-declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void;
-declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void;
+export declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void;
+export declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void;
 
-declare const onBeforeMount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onMounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onBeforeUpdate: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onUpdated: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onBeforeUnmount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onUnmounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onServerPrefetch: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
-export type DebuggerHook = (e: DebuggerEvent) => void;
-declare const onRenderTriggered: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
-declare const onRenderTracked: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
-export type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
-declare function onErrorCaptured<TError = Error>(hook: ErrorCapturedHook<TError>, target?: ComponentInternalInstance | null): void;
+export declare const onBeforeMount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onMounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onBeforeUpdate: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onUpdated: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onBeforeUnmount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onUnmounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onServerPrefetch: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
+type DebuggerHook = (e: DebuggerEvent) => void;
+export declare const onRenderTriggered: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
+export declare const onRenderTracked: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
+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;
 
 export type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
 export type ComponentObjectPropsOptions<P = Data> = {
     [K in keyof P]: Prop<P[K]> | null;
 };
 export type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
-export type DefaultFactory<T> = (props: Data) => T | null | undefined;
-export interface PropOptions<T = any, D = T> {
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+interface PropOptions<T = any, D = T> {
     type?: PropType<T> | true | null;
     required?: boolean;
     default?: D | DefaultFactory<D> | null | undefined | object;
     validator?(value: unknown): boolean;
+    /* removed internal: skipCheck */
+    /* removed internal: skipFactory */
 }
 export type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
-export type PropConstructor<T = any> = {
+type PropConstructor<T = any> = {
     new (...args: any[]): T & {};
 } | {
     (): T;
 } | PropMethod<T>;
-export type PropMethod<T, TConstructor = any> = [T] extends [
+type PropMethod<T, TConstructor = any> = [T] extends [
     ((...args: any) => any) | undefined
 ] ? {
     new (): TConstructor;
     (): T;
     readonly prototype: TConstructor;
 } : never;
-export type RequiredKeys<T> = {
+type RequiredKeys<T> = {
     [K in keyof T]: T[K] extends {
         required: true;
     } | {
@@ -333,8 +342,8 @@ export type RequiredKeys<T> = {
         default: undefined | (() => undefined);
     } ? never : K : never;
 }[keyof T];
-export type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-export type DefaultKeys<T> = {
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type DefaultKeys<T> = {
     [K in keyof T]: T[K] extends {
         default: any;
     } | BooleanConstructor | {
@@ -344,7 +353,7 @@ export type DefaultKeys<T> = {
         required: true;
     } ? never : K : never;
 }[keyof T];
-export type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
     type: null | true;
 }] ? any : [T] extends [ObjectConstructor | {
     type: ObjectConstructor;
@@ -367,12 +376,12 @@ declare const enum BooleanFlags {
 export type ExtractDefaultPropTypes<O> = O extends object ? {
     [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>;
 } : {};
-export type NormalizedProp = null | (PropOptions & {
+type NormalizedProp = null | (PropOptions & {
     [BooleanFlags.shouldCast]?: boolean;
     [BooleanFlags.shouldCastTrue]?: boolean;
 });
-export type NormalizedProps = Record<string, NormalizedProp>;
-export type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
+type NormalizedProps = Record<string, NormalizedProp>;
+type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
 
 /**
 Runtime helper for applying directives to a vnode. Example usage:
@@ -396,7 +405,7 @@ export interface DirectiveBinding<V = any> {
     dir: ObjectDirective<any, V>;
 }
 export type DirectiveHook<T = any, Prev = VNode<any, T> | null, V = any> = (el: T, binding: DirectiveBinding<V>, vnode: VNode<any, T>, prevVNode: Prev) => void;
-export type SSRDirectiveHook = (binding: DirectiveBinding, vnode: VNode) => Data | undefined;
+type SSRDirectiveHook = (binding: DirectiveBinding, vnode: VNode) => Data | undefined;
 export interface ObjectDirective<T = any, V = any> {
     created?: DirectiveHook<T, null, V>;
     beforeMount?: DirectiveHook<T, null, V>;
@@ -410,14 +419,14 @@ export interface ObjectDirective<T = any, V = any> {
 }
 export type FunctionDirective<T = any, V = any> = DirectiveHook<T, any, V>;
 export type Directive<T = any, V = any> = ObjectDirective<T, V> | FunctionDirective<T, V>;
-export type DirectiveModifiers = Record<string, boolean>;
+type DirectiveModifiers = Record<string, boolean>;
 export type DirectiveArguments = Array<[Directive | undefined] | [Directive | undefined, any] | [Directive | undefined, any, string] | [Directive | undefined, any, string, DirectiveModifiers]>;
 /**
  * Adds directives to a VNode.
  */
-declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T;
+export declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T;
 
-declare const enum DeprecationTypes {
+export declare const enum DeprecationTypes {
     GLOBAL_MOUNT = "GLOBAL_MOUNT",
     GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
     GLOBAL_EXTEND = "GLOBAL_EXTEND",
@@ -462,7 +471,7 @@ declare const enum DeprecationTypes {
     PRIVATE_APIS = "PRIVATE_APIS"
 }
 declare function warnDeprecation(key: DeprecationTypes, instance: ComponentInternalInstance | null, ...args: any[]): void;
-export type CompatConfig = Partial<Record<DeprecationTypes, boolean | 'suppress-warning'>> & {
+type CompatConfig = Partial<Record<DeprecationTypes, boolean | 'suppress-warning'>> & {
     MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
 };
 declare function configureCompat(config: CompatConfig): void;
@@ -498,16 +507,8 @@ declare function checkCompatEnabled(key: DeprecationTypes, instance: ComponentIn
 export interface ComponentCustomOptions {
 }
 export type RenderFunction = () => VNodeChild;
-export type ExtractOptionProp<T> = T extends ComponentOptionsBase<infer P, // Props
-any, // RawBindings
-any, // D
-any, // C
-any, // M
-any, // Mixin
-any, // Extends
-any> ? unknown extends P ? {} : P : {};
-export interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II>, ComponentInternalOptions, ComponentCustomOptions {
-    setup?: (this: void, props: Readonly<LooseRequired<Props & UnionToIntersection<ExtractOptionProp<Mixin>> & UnionToIntersection<ExtractOptionProp<Extends>>>>, ctx: SetupContext<E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
+export interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II>, ComponentInternalOptions, ComponentCustomOptions {
+    setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
     name?: string;
     template?: string | object;
     render?: Function;
@@ -515,6 +516,7 @@ export interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedO
     directives?: Record<string, Directive>;
     inheritAttrs?: boolean;
     emits?: (E | EE[]) & ThisType<void>;
+    slots?: S;
     expose?: string[];
     serverPrefetch?(): void | Promise<any>;
     compilerOptions?: RuntimeCompilerOptions;
@@ -537,47 +539,47 @@ export interface RuntimeCompilerOptions {
     comments?: boolean;
     delimiters?: [string, string];
 }
-export type ComponentOptionsWithoutProps<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, PE = Props & EmitsToProps<E>> = ComponentOptionsBase<PE, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II> & {
+export type ComponentOptionsWithoutProps<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, PE = Props & EmitsToProps<E>> = ComponentOptionsBase<PE, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II, S> & {
     props?: undefined;
-} & ThisType<CreateComponentPublicInstance<PE, RawBindings, D, C, M, Mixin, Extends, E, PE, {}, false, I>>;
-export type ComponentOptionsWithArrayProps<PropNames extends string = string, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<{
+} & ThisType<CreateComponentPublicInstance<PE, RawBindings, D, C, M, Mixin, Extends, E, PE, {}, false, I, S>>;
+export type ComponentOptionsWithArrayProps<PropNames extends string = string, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Props = Prettify<Readonly<{
     [key in PropNames]?: any;
-}> & EmitsToProps<E>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II> & {
+} & EmitsToProps<E>>>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II, S> & {
     props: PropNames[];
-} & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I>>;
-export type ComponentOptionsWithObjectProps<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<ExtractPropTypes<PropsOptions>> & EmitsToProps<E>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> & {
+} & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I, S>>;
+export type ComponentOptionsWithObjectProps<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Props = Prettify<Readonly<ExtractPropTypes<PropsOptions> & EmitsToProps<E>>>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II, S> & {
     props: PropsOptions & ThisType<void>;
-} & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I>>;
-export type ComponentOptions<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = any> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E> & ThisType<CreateComponentPublicInstance<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>>>;
-export type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any>;
+} & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I, S>>;
+export type ComponentOptions<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = any, S extends SlotsType = any> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, string, S> & ThisType<CreateComponentPublicInstance<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>>>;
+export type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any>;
 export type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
 export interface MethodOptions {
     [key: string]: Function;
 }
-export type ExtractComputedReturns<T extends any> = {
+type ExtractComputedReturns<T extends any> = {
     [key in keyof T]: T[key] extends {
         get: (...args: any[]) => infer TReturn;
     } ? TReturn : T[key] extends (...args: any[]) => infer TReturn ? TReturn : never;
 };
-export type ObjectWatchOptionItem = {
+type ObjectWatchOptionItem = {
     handler: WatchCallback | string;
 } & WatchOptions;
-export type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
-export type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
-export type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
+type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
+type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
+type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
 export type ComponentProvideOptions = ObjectProvideOptions | Function;
-export type ObjectProvideOptions = Record<string | symbol, unknown>;
+type ObjectProvideOptions = Record<string | symbol, unknown>;
 export type ComponentInjectOptions = string[] | ObjectInjectOptions;
-export type ObjectInjectOptions = Record<string | symbol, string | symbol | {
+type ObjectInjectOptions = Record<string | symbol, string | symbol | {
     from?: string | symbol;
     default?: unknown;
 }>;
-export type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
+type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
     [K in T[number]]?: unknown;
 } : T extends ObjectInjectOptions ? {
     [K in keyof T]?: unknown;
 } : never;
-export interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string> {
+interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string> {
     compatConfig?: CompatConfig;
     [key: string]: any;
     data?: (this: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
@@ -621,9 +623,9 @@ export interface LegacyOptions<Props, D, C extends ComputedOptions, M extends Me
      */
     __differentiator?: keyof D | keyof C | keyof M;
 }
-export type MergedHook<T = () => void> = T | T[];
-export type MergedComponentOptions = ComponentOptions & MergedComponentOptionsOverride;
-export type MergedComponentOptionsOverride = {
+type MergedHook<T = () => void> = T | T[];
+type MergedComponentOptions = ComponentOptions & MergedComponentOptionsOverride;
+type MergedComponentOptionsOverride = {
     beforeCreate?: MergedHook;
     created?: MergedHook;
     beforeMount?: MergedHook;
@@ -642,8 +644,8 @@ export type MergedComponentOptionsOverride = {
     renderTriggered?: MergedHook<DebuggerHook>;
     errorCaptured?: MergedHook<ErrorCapturedHook>;
 };
-export type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
-export type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
+type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
+type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
     P: P;
     B: B;
     D: D;
@@ -654,10 +656,10 @@ export type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions =
 
 export interface InjectionKey<T> extends Symbol {
 }
-declare function provide<T>(key: InjectionKey<T> | string | number, value: T): void;
-declare function inject<T>(key: InjectionKey<T> | string): T | undefined;
-declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T, treatDefaultAsFactory?: false): T;
-declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T | (() => T), treatDefaultAsFactory: true): T;
+export declare function provide<T>(key: InjectionKey<T> | string | number, value: 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;
+export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T | (() => T), treatDefaultAsFactory: true): T;
 
 export interface App<HostElement = any> {
     version: string;
@@ -672,6 +674,13 @@ export interface App<HostElement = any> {
     mount(rootContainer: HostElement | string, isHydrate?: boolean, isSVG?: boolean): ComponentPublicInstance;
     unmount(): void;
     provide<T>(key: InjectionKey<T> | string, value: T): this;
+    /**
+     * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
+     * to variables provided via `app.provide()`.
+     *
+     * @param fn - function to run with the app as active instance
+     */
+    runWithContext<T>(fn: () => T): T;
     _uid: number;
     _component: ConcreteComponent;
     _props: Data | null;
@@ -721,7 +730,7 @@ export interface AppContext {
     /* removed internal: reload */
     /* removed internal: filters */
 }
-export type PluginInstallFunction<Options> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => 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>;
 }) | {
@@ -729,7 +738,7 @@ export type Plugin<Options = any[]> = (PluginInstallFunction<Options> & {
 };
 export type CreateAppFunction<HostElement> = (rootComponent: Component, rootProps?: Data | null) => App<HostElement>;
 
-export type Hook<T = () => void> = T | T[];
+type Hook<T = () => void> = T | T[];
 export interface BaseTransitionProps<HostElement = RendererElement> {
     mode?: 'in-out' | 'out-in' | 'default';
     appear?: boolean;
@@ -764,8 +773,8 @@ export interface TransitionState {
     isUnmounting: boolean;
     leavingVNodes: Map<any, Record<string, VNode>>;
 }
-declare function useTransitionState(): TransitionState;
-declare const BaseTransitionPropsValidators: {
+export declare function useTransitionState(): TransitionState;
+export declare const BaseTransitionPropsValidators: {
     mode: StringConstructor;
     appear: BooleanConstructor;
     persisted: BooleanConstructor;
@@ -782,14 +791,14 @@ declare const BaseTransitionPropsValidators: {
     onAfterAppear: (ArrayConstructor | FunctionConstructor)[];
     onAppearCancelled: (ArrayConstructor | FunctionConstructor)[];
 };
-declare const BaseTransition: new () => {
+export declare const BaseTransition: new () => {
     $props: BaseTransitionProps<any>;
 };
-declare function resolveTransitionHooks(vnode: VNode, props: BaseTransitionProps<any>, state: TransitionState, instance: ComponentInternalInstance): TransitionHooks;
-declare function setTransitionHooks(vnode: VNode, hooks: TransitionHooks): void;
-declare function getTransitionRawChildren(children: VNode[], keepComment?: boolean, parentKey?: VNode['key']): VNode[];
+export declare function resolveTransitionHooks(vnode: VNode, props: BaseTransitionProps<any>, state: TransitionState, instance: ComponentInternalInstance): TransitionHooks;
+export declare function setTransitionHooks(vnode: VNode, hooks: TransitionHooks): void;
+export declare function getTransitionRawChildren(children: VNode[], keepComment?: boolean, parentKey?: VNode['key']): VNode[];
 
-export type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
+type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
 export interface TeleportProps {
     to: string | RendererElement | null | undefined;
     disabled?: boolean;
@@ -808,7 +817,7 @@ declare const 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 } }: 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;
-declare const Teleport: {
+export declare const Teleport: {
     new (): {
         $props: VNodeProps & TeleportProps;
     };
@@ -818,38 +827,38 @@ declare const Teleport: {
 /**
  * @private
  */
-declare function resolveComponent(name: string, maybeSelfReference?: boolean): ConcreteComponent | string;
+export declare function resolveComponent(name: string, maybeSelfReference?: boolean): ConcreteComponent | string;
 declare const NULL_DYNAMIC_COMPONENT: unique symbol;
 /**
  * @private
  */
-declare function resolveDynamicComponent(component: unknown): VNodeTypes;
+export declare function resolveDynamicComponent(component: unknown): VNodeTypes;
 /**
  * @private
  */
-declare function resolveDirective(name: string): Directive | undefined;
+export declare function resolveDirective(name: string): Directive | undefined;
 /* removed internal: resolveFilter$1 */
 
-declare const Fragment: {
+export declare const Fragment: {
     new (): {
         $props: VNodeProps;
     };
     __isFragment: true;
 };
-declare const Text: unique symbol;
-declare const Comment: unique symbol;
-declare const Static: unique symbol;
+export declare const Text: unique symbol;
+export declare const Comment: unique symbol;
+export declare const Static: unique symbol;
 export type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
 export type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
-export type VNodeNormalizedRefAtom = {
+type VNodeNormalizedRefAtom = {
     i: ComponentInternalInstance;
     r: VNodeRef;
     k?: string;
     f?: boolean;
 };
-export type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
-export type VNodeMountHook = (vnode: VNode) => void;
-export type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
+type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
+type VNodeMountHook = (vnode: VNode) => void;
+type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
 export type VNodeProps = {
     key?: string | number | symbol;
     ref?: VNodeRef;
@@ -862,7 +871,7 @@ export type VNodeProps = {
     onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
     onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
 };
-export type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
 export type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
 export type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
 export type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
@@ -919,7 +928,7 @@ export interface VNode<HostNode = RendererNode, HostElement = RendererElement, E
  *
  * @private
  */
-declare function openBlock(disableTracking?: boolean): void;
+export declare function openBlock(disableTracking?: boolean): void;
 /**
  * Block tracking sometimes needs to be disabled, for example during the
  * creation of a tree that needs to be cached by v-once. The compiler generates
@@ -936,11 +945,11 @@ declare function openBlock(disableTracking?: boolean): void;
  *
  * @private
  */
-declare function setBlockTracking(value: number): void;
+export declare function setBlockTracking(value: number): void;
 /**
  * @private
  */
-declare function createElementBlock(type: string | typeof Fragment, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[], shapeFlag?: number): VNode<RendererNode, RendererElement, {
+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;
 }>;
 /**
@@ -950,8 +959,8 @@ declare function createElementBlock(type: string | typeof Fragment, props?: Reco
  *
  * @private
  */
-declare function createBlock(type: VNodeTypes | ClassComponent, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[]): VNode;
-declare function isVNode(value: any): value is VNode;
+export declare function createBlock(type: VNodeTypes | ClassComponent, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[]): VNode;
+export declare function isVNode(value: any): value is VNode;
 declare let vnodeArgsTransformer: ((args: Parameters<typeof _createVNode>, instance: ComponentInternalInstance | null) => Parameters<typeof _createVNode>) | undefined;
 /**
  * Internal API for registering an arguments transform for createVNode
@@ -959,31 +968,31 @@ declare let vnodeArgsTransformer: ((args: Parameters<typeof _createVNode>, insta
  * It is *internal* but needs to be exposed for test-utils to pick up proper
  * typings
  */
-declare function transformVNodeArgs(transformer?: typeof vnodeArgsTransformer): void;
-declare function createBaseVNode(type: VNodeTypes | ClassComponent | typeof NULL_DYNAMIC_COMPONENT, props?: (Data & VNodeProps) | null, children?: unknown, patchFlag?: number, dynamicProps?: string[] | null, shapeFlag?: number | ShapeFlags, isBlockNode?: boolean, needFullChildrenNormalization?: boolean): VNode<RendererNode, RendererElement, {
+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;
 }>;
 
-declare const createVNode: typeof _createVNode;
+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;
-declare function guardReactiveProps(props: (Data & VNodeProps) | null): (Data & VNodeProps) | null;
-declare function cloneVNode<T, U>(vnode: VNode<T, U>, extraProps?: (Data & VNodeProps) | null, mergeRef?: boolean): VNode<T, U>;
+export declare function guardReactiveProps(props: (Data & VNodeProps) | null): (Data & VNodeProps) | null;
+export declare function cloneVNode<T, U>(vnode: VNode<T, U>, extraProps?: (Data & VNodeProps) | null, mergeRef?: boolean): VNode<T, U>;
 /**
  * @private
  */
-declare function createTextVNode(text?: string, flag?: number): VNode;
+export declare function createTextVNode(text?: string, flag?: number): VNode;
 /**
  * @private
  */
-declare function createStaticVNode(content: string, numberOfNodes: number): VNode;
+export declare function createStaticVNode(content: string, numberOfNodes: number): VNode;
 /**
  * @private
  */
-declare function createCommentVNode(text?: string, asBlock?: boolean): VNode;
+export declare function createCommentVNode(text?: string, asBlock?: boolean): VNode;
 declare function normalizeVNode(child: VNodeChild): VNode;
-declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
+export declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
 
-export type Data = Record<string, unknown>;
+type Data = Record<string, unknown>;
 /**
  * For extending allowed non-declared props on components in TSX
  */
@@ -996,7 +1005,7 @@ export interface AllowedComponentProps {
     class?: unknown;
     style?: unknown;
 }
-export interface ComponentInternalOptions {
+interface ComponentInternalOptions {
     /* removed internal: __scopeId */
     /* removed internal: __cssModules */
     /* removed internal: __hmrId */
@@ -1013,15 +1022,16 @@ export interface ComponentInternalOptions {
      */
     __name?: string;
 }
-export interface FunctionalComponent<P = {}, E extends EmitsOptions = {}> extends ComponentInternalOptions {
-    (props: P, ctx: Omit<SetupContext<E>, 'expose'>): any;
+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;
     props?: ComponentPropsOptions<P>;
     emits?: E | (keyof E)[];
+    slots?: IfAny<S, Slots, SlotsType<S>>;
     inheritAttrs?: boolean;
     displayName?: string;
     compatConfig?: CompatConfig;
 }
-export interface ClassComponent {
+interface ClassComponent {
     new (...args: any[]): ComponentPublicInstance<any, any, any, any, any>;
     __vccOpts: ComponentOptions;
 }
@@ -1031,17 +1041,17 @@ export 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> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, any, any>;
 /**
  * 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 LifecycleHook<TFn = Function> = TFn[] | null;
-export type SetupContext<E = EmitsOptions> = E extends any ? {
+type LifecycleHook<TFn = Function> = TFn[] | null;
+export type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
     attrs: Data;
-    slots: Slots;
+    slots: TypedSlots<S>;
     emit: EmitFn<E>;
     expose: (exposed?: Record<string, any>) => void;
 } : never;
@@ -1129,22 +1139,22 @@ export interface ComponentInternalInstance {
     /* removed internal: ut */
 }
 declare function createComponentInstance(vnode: VNode, parent: ComponentInternalInstance | null, suspense: SuspenseBoundary | null): ComponentInternalInstance;
-declare const getCurrentInstance: () => ComponentInternalInstance | null;
+export declare const getCurrentInstance: () => ComponentInternalInstance | null;
 declare function setupComponent(instance: ComponentInternalInstance, isSSR?: boolean): Promise<void> | undefined;
 /**
  * For runtime-dom to register the compiler.
  * Note the exported method uses any to avoid d.ts relying on the compiler types.
  */
-declare function registerRuntimeCompiler(_compile: any): void;
-declare const isRuntimeOnly: () => boolean;
+export declare function registerRuntimeCompiler(_compile: any): void;
+export declare const isRuntimeOnly: () => boolean;
 
 export type WatchEffect = (onCleanup: OnCleanup) => void;
 export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T);
 export type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
-export type MapSources<T, Immediate> = {
+type MapSources<T, Immediate> = {
     [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : T[K] extends object ? Immediate extends true ? T[K] | undefined : T[K] : never;
 };
-export type OnCleanup = (cleanupFn: () => void) => void;
+type OnCleanup = (cleanupFn: () => void) => void;
 export interface WatchOptionsBase extends DebuggerOptions {
     flush?: 'pre' | 'post' | 'sync';
 }
@@ -1153,25 +1163,35 @@ export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
     deep?: boolean;
 }
 export type WatchStopHandle = () => void;
-declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchStopHandle;
-declare function watchPostEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
-declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
-export type MultiWatchSources = (WatchSource<unknown> | object)[];
-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;
-declare function watch<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
-declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
-declare function watch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchStopHandle;
+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 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 Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
 
-export type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
-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 = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>), Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>> = ComponentPublicInstanceConstructor<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, PP & Props, Defaults, true> & Props> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults> & PP;
-declare function defineComponent<Props, RawBindings = object>(setup: (props: Readonly<Props>, ctx: SetupContext) => RawBindings | RenderFunction): DefineComponent<Props, RawBindings>;
-declare function defineComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): DefineComponent<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-declare function defineComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): DefineComponent<Readonly<{
+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> & Props> & 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'> & {
+    props?: (keyof Props)[];
+    emits?: E | EE[];
+    slots?: S;
+}): (props: Props & EmitsToProps<E>) => any;
+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?: ComponentObjectPropsOptions<Props>;
+    emits?: E | EE[];
+    slots?: S;
+}): (props: Props & EmitsToProps<E>) => any;
+export declare function defineComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S>): DefineComponent<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, PublicProps, ResolveProps<Props, E>, ExtractDefaultPropTypes<Props>, S>;
+export declare function defineComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<{
     [key in PropNames]?: any;
-}>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-declare function defineComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+}>>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S>): DefineComponent<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, PublicProps, ResolveProps<Props, E>, ExtractDefaultPropTypes<Props>, S>;
+export declare function defineComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S>): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, PublicProps, ResolveProps<PropsOptions, E>, ExtractDefaultPropTypes<PropsOptions>, S>;
 
-export type AsyncComponentResolveResult<T = Component> = T | {
+type AsyncComponentResolveResult<T = Component> = T | {
     default: T;
 };
 export type AsyncComponentLoader<T = any> = () => Promise<AsyncComponentResolveResult<T>>;
@@ -1184,7 +1204,7 @@ export interface AsyncComponentOptions<T = any> {
     suspensible?: boolean;
     onError?: (error: Error, retry: () => void, fail: () => void, attempts: number) => any;
 }
-declare function defineAsyncComponent<T extends Component = {
+export declare function defineAsyncComponent<T extends Component = {
     new (): ComponentPublicInstance;
 }>(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>): T;
 
@@ -1213,18 +1233,22 @@ 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.
  */
-declare function defineProps<PropNames extends string = string>(props: PropNames[]): Readonly<{
+export declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{
     [key in PropNames]?: any;
-}>;
-declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Readonly<ExtractPropTypes<PP>>;
-declare function defineProps<TypeProps>(): Readonly<Omit<TypeProps, BooleanKey<TypeProps>> & {
-    [K in keyof Pick<TypeProps, BooleanKey<TypeProps>>]-?: NotUndefined<TypeProps[K]>;
-}>;
+}>>;
+export declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
+export declare function defineProps<TypeProps>(): DefineProps<TypeProps>;
+type DefineProps<T> = Readonly<T> & {
+    readonly [K in BooleanKey<T>]-?: boolean;
+};
+type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
 /**
  * Vue `<script setup>` compiler macro for declaring a component's emitted
  * events. The expected argument is the same as the component `emits` option.
@@ -1247,10 +1271,16 @@ declare function defineProps<TypeProps>(): Readonly<Omit<TypeProps, BooleanKey<T
  *
  * This is only usable inside `<script setup>`, is compiled away in the
  * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
  */
-declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
-declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
-declare function defineEmits<TypeEmit>(): TypeEmit;
+export declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
+export declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
+export declare function defineEmits<T extends ((...args: any[]) => any) | Record<string, any[]>>(): T extends (...args: any[]) => any ? T : ShortEmits<T>;
+type RecordToUnion<T extends Record<string, any>> = T[keyof T];
+type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{
+    [K in keyof T]: (evt: K, ...args: T[K]) => void;
+}>>;
 /**
  * Vue `<script setup>` compiler macro for declaring a component's exposed
  * instance properties when it is accessed by a parent component via template
@@ -1262,15 +1292,81 @@ declare function defineEmits<TypeEmit>(): TypeEmit;
  *
  * This is only usable inside `<script setup>`, is compiled away in the
  * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
  */
-declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
-export type NotUndefined<T> = T extends undefined ? never : T;
-export type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
-export type InferDefaults<T> = {
+export declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's additional
+ * options. This should be used only for options that cannot be expressed via
+ * Composition API - e.g. `inhertiAttrs`.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
+ */
+export declare function defineOptions<RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin>(options?: ComponentOptionsWithoutProps<{}, RawBindings, D, C, M, Mixin, Extends> & {
+    emits?: undefined;
+    expose?: undefined;
+    slots?: undefined;
+}): void;
+export declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): TypedSlots<SlotsType<S>>;
+/**
+ * (**Experimental**) 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.
+ *
+ * If the first argument is a string, it will be used as the prop name;
+ * 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`.
+ *
+ * @example
+ * ```ts
+ * // default model (consumed via `v-model`)
+ * const modelValue = defineModel<string>()
+ * modelValue.value = "hello"
+ *
+ * // default model with options
+ * const modelValue = defineModel<stirng>({ required: true })
+ *
+ * // with specified name (consumed via `v-model:count`)
+ * const count = defineModel<number>('count')
+ * count.value++
+ *
+ * // 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>;
+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>;
+export declare function defineModel<T>(name: string, options: {
+    required: true;
+} & PropOptions<T> & DefineModelOptions): 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;
+}
+type NotUndefined<T> = T extends undefined ? never : T;
+type InferDefaults<T> = {
     [K in keyof T]?: InferDefault<T, NotUndefined<T[K]>>;
 };
-export type InferDefault<P, T> = T extends null | number | string | boolean | symbol | Function ? T | ((props: P) => T) : (props: P) => T;
-export type PropsWithDefaults<Base, Defaults> = Base & {
+type InferDefault<P, T> = T extends null | number | string | boolean | symbol | Function ? T | ((props: P) => T) : (props: P) => T;
+type PropsWithDefaults<Base, Defaults> = Base & {
     [K in keyof Defaults]: K extends keyof Base ? Defaults[K] extends undefined ? Base[K] : NotUndefined<Base[K]> : never;
 };
 /**
@@ -1290,20 +1386,26 @@ export type PropsWithDefaults<Base, Defaults> = Base & {
  *
  * This is only usable inside `<script setup>`, is compiled away in the output
  * and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
  */
-declare function withDefaults<Props, Defaults extends InferDefaults<Props>>(props: Props, defaults: Defaults): PropsWithDefaults<Props, Defaults>;
-declare function useSlots(): SetupContext['slots'];
-declare function useAttrs(): SetupContext['attrs'];
+export declare function withDefaults<Props, Defaults extends InferDefaults<Props>>(props: Props, defaults: Defaults): PropsWithDefaults<Props, Defaults>;
+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]>;
 /* removed internal: mergeDefaults */
+/* removed internal: mergeModels */
 /* removed internal: createPropsRestProxy */
 /* removed internal: withAsyncContext */
 
-export type RawProps = VNodeProps & {
+type RawProps = VNodeProps & {
     __v_isVNode?: never;
     [Symbol.iterator]?: never;
 } & Record<string, any>;
-export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-export interface Constructor<P = any> {
+type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
+interface Constructor<P = any> {
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
@@ -1311,33 +1413,33 @@ export interface Constructor<P = any> {
         $props: P;
     };
 }
-declare function h(type: string, children?: RawChildren): VNode;
-declare function h(type: string, props?: RawProps | null, children?: RawChildren | RawSlots): VNode;
-declare function h(type: typeof Text | typeof Comment, children?: string | number | boolean): VNode;
-declare function h(type: typeof Text | typeof Comment, props?: null, children?: string | number | boolean): VNode;
-declare function h(type: typeof Fragment, children?: VNodeArrayChildren): VNode;
-declare function h(type: typeof Fragment, props?: RawProps | null, children?: VNodeArrayChildren): VNode;
-declare function h(type: typeof Teleport, props: RawProps & TeleportProps, children: RawChildren | RawSlots): VNode;
-declare function h(type: typeof Suspense, children?: RawChildren): VNode;
-declare function h(type: typeof Suspense, props?: (RawProps & SuspenseProps) | null, children?: RawChildren | RawSlots): VNode;
-declare function h<P, E extends EmitsOptions = {}>(type: FunctionalComponent<P, E>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
-declare function h(type: Component, children?: RawChildren): VNode;
-declare function h<P>(type: ConcreteComponent | string, children?: RawChildren): VNode;
-declare function h<P>(type: ConcreteComponent<P> | string, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren): VNode;
-declare function h<P>(type: Component<P>, props?: (RawProps & P) | null, children?: RawChildren | RawSlots): VNode;
-declare function h<P>(type: ComponentOptions<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
-declare function h(type: Constructor, children?: RawChildren): VNode;
-declare function h<P>(type: Constructor<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
-declare function h(type: DefineComponent, children?: RawChildren): VNode;
-declare function h<P>(type: DefineComponent<P>, props?: (RawProps & P) | ({} extends P ? null : never), 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;
+export declare function h(type: typeof Text | typeof Comment, props?: null, children?: string | number | boolean): VNode;
+export declare function h(type: typeof Fragment, children?: VNodeArrayChildren): VNode;
+export declare function h(type: typeof Fragment, props?: RawProps | null, children?: VNodeArrayChildren): VNode;
+export declare function h(type: typeof Teleport, props: RawProps & TeleportProps, children: RawChildren | RawSlots): VNode;
+export declare function h(type: typeof Suspense, children?: RawChildren): VNode;
+export declare function h(type: typeof Suspense, props?: (RawProps & SuspenseProps) | null, children?: RawChildren | RawSlots): VNode;
+export declare function h<P, E extends EmitsOptions = {}, S extends Record<string, any> = {}>(type: FunctionalComponent<P, E, S>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
+export declare function h(type: Component, children?: RawChildren): VNode;
+export declare function h<P>(type: ConcreteComponent | string, children?: RawChildren): VNode;
+export declare function h<P>(type: ConcreteComponent<P> | string, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren): VNode;
+export declare function h<P>(type: Component<P>, props?: (RawProps & P) | null, children?: RawChildren | RawSlots): VNode;
+export declare function h<P>(type: ComponentOptions<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
+export declare function h(type: Constructor, children?: RawChildren): VNode;
+export declare function h<P>(type: Constructor<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
+export declare function h(type: DefineComponent, children?: RawChildren): VNode;
+export declare function h<P>(type: DefineComponent<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
 
-declare const ssrContextKey: unique symbol;
-declare const useSSRContext: <T = Record<string, any>>() => T | undefined;
+export declare const ssrContextKey: unique symbol;
+export declare const useSSRContext: <T = Record<string, any>>() => T | undefined;
 
-declare function warn(msg: string, ...args: any[]): void;
+export declare function warn(msg: string, ...args: any[]): void;
 /* removed internal: assertNumber */
 
-declare const enum ErrorCodes {
+export declare const enum ErrorCodes {
     SETUP_FUNCTION = 0,
     RENDER_FUNCTION = 1,
     WATCH_GETTER = 2,
@@ -1354,20 +1456,20 @@ declare const enum ErrorCodes {
     ASYNC_COMPONENT_LOADER = 13,
     SCHEDULER = 14
 }
-export type ErrorTypes = LifecycleHooks | ErrorCodes;
-declare function callWithErrorHandling(fn: Function, instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any;
-declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any[];
-declare function handleError(err: unknown, instance: ComponentInternalInstance | null, type: ErrorTypes, throwInDev?: boolean): void;
+type ErrorTypes = LifecycleHooks | ErrorCodes;
+export declare function callWithErrorHandling(fn: Function, instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any;
+export declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any[];
+export declare function handleError(err: unknown, instance: ComponentInternalInstance | null, type: ErrorTypes, throwInDev?: boolean): void;
 
-declare function initCustomFormatter(): void;
+export declare function initCustomFormatter(): void;
 
-export interface AppRecord {
+interface AppRecord {
     id: number;
     app: App;
     version: string;
     types: Record<string, string | Symbol>;
 }
-export interface DevtoolsHook {
+interface DevtoolsHook {
     enabled?: boolean;
     emit: (event: string, ...payload: any[]) => void;
     on: (event: string, handler: Function) => void;
@@ -1380,10 +1482,10 @@ export interface DevtoolsHook {
      */
     cleanupBuffer?: (matchArg: unknown) => boolean;
 }
-declare let devtools: DevtoolsHook;
-declare function setDevtoolsHook(hook: DevtoolsHook, target: any): void;
+export declare let devtools: DevtoolsHook;
+export declare function setDevtoolsHook(hook: DevtoolsHook, target: any): void;
 
-export type HMRComponent = ComponentOptions | ClassComponent;
+type HMRComponent = ComponentOptions | ClassComponent;
 export interface HMRRuntime {
     createRecord: typeof createRecord;
     rerender: typeof rerender;
@@ -1408,60 +1510,60 @@ declare function setCurrentRenderingInstance(instance: ComponentInternalInstance
  * Set scope id when creating hoisted vnodes.
  * @private compiler helper
  */
-declare function pushScopeId(id: string | null): void;
+export declare function pushScopeId(id: string | null): void;
 /**
  * Technically we no longer need this after 3.0.8 but we need to keep the same
  * API for backwards compat w/ code generated by compilers.
  * @private
  */
-declare function popScopeId(): void;
+export declare function popScopeId(): void;
 /**
  * Only for backwards compat
  * @private
  */
-declare const withScopeId: (_id: string) => typeof withCtx;
+export declare const withScopeId: (_id: string) => typeof withCtx;
 /**
  * Wrap a slot function to memoize current rendering instance
  * @private compiler helper
  */
-declare function withCtx(fn: Function, ctx?: ComponentInternalInstance | null, isNonScopedSlot?: boolean): Function;
+export declare function withCtx(fn: Function, ctx?: ComponentInternalInstance | null, isNonScopedSlot?: boolean): Function;
 
 /**
  * v-for string
  * @private
  */
-declare function renderList(source: string, renderItem: (value: string, index: number) => VNodeChild): VNodeChild[];
+export declare function renderList(source: string, renderItem: (value: string, index: number) => VNodeChild): VNodeChild[];
 /**
  * v-for number
  */
-declare function renderList(source: number, renderItem: (value: number, index: number) => VNodeChild): VNodeChild[];
+export declare function renderList(source: number, renderItem: (value: number, index: number) => VNodeChild): VNodeChild[];
 /**
  * v-for array
  */
-declare function renderList<T>(source: T[], renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
+export declare function renderList<T>(source: T[], renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
 /**
  * v-for iterable
  */
-declare function renderList<T>(source: Iterable<T>, renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
+export declare function renderList<T>(source: Iterable<T>, renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
 /**
  * v-for object
  */
-declare function renderList<T>(source: T, renderItem: <K extends keyof T>(value: T[K], key: K, index: number) => VNodeChild): VNodeChild[];
+export declare function renderList<T>(source: T, renderItem: <K extends keyof T>(value: T[K], key: K, index: number) => VNodeChild): VNodeChild[];
 
 /**
  * For prefixing keys in v-on="obj" with "on"
  * @private
  */
-declare function toHandlers(obj: Record<string, any>, preserveCaseIfNecessary?: boolean): Record<string, any>;
+export declare function toHandlers(obj: Record<string, any>, preserveCaseIfNecessary?: boolean): Record<string, any>;
 
 /**
  * Compiler runtime helper for rendering `<slot/>`
  * @private
  */
-declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode;
+export declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode;
 
-export type SSRSlot = (...args: any[]) => VNode[] | undefined;
-export interface CompiledSlotDescriptor {
+type SSRSlot = (...args: any[]) => VNode[] | undefined;
+interface CompiledSlotDescriptor {
     name: string;
     fn: SSRSlot;
     key?: string;
@@ -1470,12 +1572,12 @@ export interface CompiledSlotDescriptor {
  * Compiler runtime helper for creating dynamic slots object
  * @private
  */
-declare function createSlots(slots: Record<string, SSRSlot>, dynamicSlots: (CompiledSlotDescriptor | CompiledSlotDescriptor[] | undefined)[]): Record<string, SSRSlot>;
+export declare function createSlots(slots: Record<string, SSRSlot>, dynamicSlots: (CompiledSlotDescriptor | CompiledSlotDescriptor[] | undefined)[]): Record<string, SSRSlot>;
 
-declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any, {
+export declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any, {
     [key: string]: any;
 }>;
-declare function isMemoSame(cached: VNode, memo: any[]): boolean;
+export declare function isMemoSame(cached: VNode, memo: any[]): boolean;
 
 declare function renderComponentRoot(instance: ComponentInternalInstance): VNode;
 
@@ -1506,8 +1608,8 @@ export type LegacyConfig = {
     productionTip?: boolean;
 };
 
-export type LegacyPublicInstance = ComponentPublicInstance & LegacyPublicProperties;
-export interface LegacyPublicProperties {
+type LegacyPublicInstance = ComponentPublicInstance & LegacyPublicProperties;
+interface LegacyPublicProperties {
     $set(target: object, key: string, value: any): void;
     $delete(target: object, key: string): void;
     $mount(el?: string | Element): this;
@@ -1565,7 +1667,7 @@ export type CompatVue = Pick<App, 'version' | 'component' | 'directive'> & {
 };
 declare function createCompatVue(createApp: CreateAppFunction<Element>, createSingletonApp: CreateAppFunction<Element>): CompatVue;
 
-declare const version: string;
+export declare const version: string;
 
 declare module '@vue/reactivity' {
     interface RefUnwrapBailTypes {
@@ -1580,17 +1682,23 @@ declare module '@vue/reactivity' {
 
 
 
-export { BaseTransition, BaseTransitionPropsValidators, Comment, DeprecationTypes, ErrorCodes, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, computed, createBlock, createCommentVNode, createElementBlock, createBaseVNode as createElementVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, defineEmits, defineExpose, defineProps, devtools, getCurrentInstance, getTransitionRawChildren, guardReactiveProps, h, handleError, initCustomFormatter, inject, isMemoSame, isRuntimeOnly, isVNode, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, toHandlers, transformVNodeArgs, useAttrs, useSSRContext, useSlots, useTransitionState, version, warn, watch, watchEffect, watchPostEffect, watchSyncEffect, withCtx, withDefaults, withDirectives, withMemo, withScopeId };
+export { createBaseVNode as createElementVNode,  };
 // Note: this file is auto concatenated to the end of the bundled d.ts during
 // build.
 type _defineProps = typeof defineProps
 type _defineEmits = typeof defineEmits
 type _defineExpose = typeof defineExpose
+type _defineOptions = typeof defineOptions
+type _defineSlots = typeof defineSlots
+type _defineModel = typeof defineModel
 type _withDefaults = typeof withDefaults
 
 declare global {
   const defineProps: _defineProps
   const defineEmits: _defineEmits
   const defineExpose: _defineExpose
+  const defineOptions: _defineOptions
+  const defineSlots: _defineSlots
+  const defineModel: _defineModel
   const withDefaults: _withDefaults
 }