@vue/runtime-core 3.3.0-alpha.5 → 3.3.0-alpha.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/runtime-core.cjs.js +27 -9
  2. package/dist/runtime-core.cjs.prod.js +19 -7
  3. package/dist/runtime-core.d.ts +286 -237
  4. package/dist/runtime-core.esm-bundler.js +26 -11
  5. package/package.json +3 -3
package/dist/runtime-core.d.ts CHANGED
@@ -1,23 +1,30 @@
1
1
  import { computed as computed$1, ShallowUnwrapRef, UnwrapNestedRefs, DebuggerEvent, ComputedGetter, WritableComputedOptions, Ref, ReactiveFlags, ReactiveEffect, EffectScope, ComputedRef, DebuggerOptions, reactive } from '@vue/reactivity';
2
- 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';
3
- import { SlotFlags, UnionToIntersection, Prettify, IfAny, LooseRequired } from '@vue/shared';
2
+ 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';
3
+ import { IfAny, Prettify, SlotFlags, UnionToIntersection, LooseRequired } from '@vue/shared';
4
4
  export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
5
5
 
6
- declare const computed: typeof computed$1;
6
+ export declare const computed: typeof computed$1;
7
7
 
8
- export type Slot = (...args: any[]) => VNode[];
9
- export type InternalSlots = {
8
+ export type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
9
+ type InternalSlots = {
10
10
  [name: string]: Slot | undefined;
11
11
  };
12
12
  export type Slots = Readonly<InternalSlots>;
13
- export type RawSlots = {
13
+ declare const SlotSymbol: unique symbol;
14
+ export type SlotsType<T extends Record<string, any> = Record<string, any>> = {
15
+ [SlotSymbol]?: T;
16
+ };
17
+ type TypedSlots<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{
18
+ [K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? T[K] : Slot<T[K]>;
19
+ }>>;
20
+ type RawSlots = {
14
21
  [name: string]: unknown;
15
22
  $stable?: boolean;
16
23
  /* removed internal: _ctx */
17
24
  /* removed internal: _ */
18
25
  };
19
26
 
20
- export interface SchedulerJob extends Function {
27
+ interface SchedulerJob extends Function {
21
28
  id?: number;
22
29
  pre?: boolean;
23
30
  active?: boolean;
@@ -45,18 +52,18 @@ export interface SchedulerJob extends Function {
45
52
  */
46
53
  ownerInstance?: ComponentInternalInstance;
47
54
  }
48
- export type SchedulerJobs = SchedulerJob | SchedulerJob[];
49
- declare function nextTick<T = void>(this: T, fn?: (this: T) => void): Promise<void>;
50
- declare function queuePostFlushCb(cb: SchedulerJobs): void;
55
+ type SchedulerJobs = SchedulerJob | SchedulerJob[];
56
+ export declare function nextTick<T = void>(this: T, fn?: (this: T) => void): Promise<void>;
57
+ export declare function queuePostFlushCb(cb: SchedulerJobs): void;
51
58
 
52
59
  export type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
53
60
  export type EmitsOptions = ObjectEmitsOptions | string[];
54
- export type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
61
+ type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
55
62
  [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
56
63
  } : T extends ObjectEmitsOptions ? {
57
64
  [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;
58
65
  } : {};
59
- 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<{
66
+ 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<{
60
67
  [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : (event: key, ...args: any[]) => void;
61
68
  }[Event]>;
62
69
 
@@ -87,31 +94,31 @@ export type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = k
87
94
  */
88
95
  export interface ComponentCustomProperties {
89
96
  }
90
- export type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
91
- 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;
92
- export type ExtractMixin<T> = {
97
+ type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
98
+ type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, any, infer Defaults> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
99
+ type ExtractMixin<T> = {
93
100
  Mixin: MixinToOptionTypes<T>;
94
101
  }[T extends ComponentOptionsMixin ? 'Mixin' : never];
95
- export type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType<{}, {}, {}, {}, {}> : UnionToIntersection<ExtractMixin<T>>;
96
- export type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
97
- export type EnsureNonVoid<T> = T extends void ? {} : T;
98
- 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> = {
102
+ type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType<{}, {}, {}, {}, {}> : UnionToIntersection<ExtractMixin<T>>;
103
+ type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
104
+ type EnsureNonVoid<T> = T extends void ? {} : T;
105
+ 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> = {
99
106
  __isFragment?: never;
100
107
  __isTeleport?: never;
101
108
  __isSuspense?: never;
102
109
  new (...args: any[]): T;
103
110
  };
104
- 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>;
111
+ export type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, S extends SlotsType = {}, 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, S, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, S, Defaults>, I>;
105
112
  export type ComponentPublicInstance<P = {}, // props type extracted from props option
106
113
  B = {}, // raw bindings returned from setup()
107
114
  D = {}, // return from data()
108
- 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 = {}> = {
115
+ C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, S extends SlotsType = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}> = {
109
116
  $: ComponentInternalInstance;
110
117
  $data: D;
111
118
  $props: Prettify<MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults> : P & PublicProps>;
112
119
  $attrs: Data;
113
120
  $refs: Data;
114
- $slots: Slots;
121
+ $slots: TypedSlots<S>;
115
122
  $root: ComponentPublicInstance | null;
116
123
  $parent: ComponentPublicInstance | null;
117
124
  $emit: EmitFn<E>;
@@ -153,7 +160,7 @@ declare const SuspenseImpl: {
153
160
  create: typeof createSuspenseBoundary;
154
161
  normalize: typeof normalizeSuspenseChildren;
155
162
  };
156
- declare const Suspense: {
163
+ export declare const Suspense: {
157
164
  new (): {
158
165
  $props: VNodeProps & SuspenseProps;
159
166
  };
@@ -222,7 +229,7 @@ export interface RendererNode {
222
229
  }
223
230
  export interface RendererElement extends RendererNode {
224
231
  }
225
- export interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
232
+ interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
226
233
  p: PatchFn;
227
234
  um: UnmountFn;
228
235
  r: RemoveFn;
@@ -234,18 +241,18 @@ export interface RendererInternals<HostNode = RendererNode, HostElement = Render
234
241
  n: NextFn;
235
242
  o: RendererOptions<HostNode, HostElement>;
236
243
  }
237
- export type PatchFn = (n1: VNode | null, // null means this is a mount
244
+ type PatchFn = (n1: VNode | null, // null means this is a mount
238
245
  n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, isSVG?: boolean, slotScopeIds?: string[] | null, optimized?: boolean) => void;
239
- 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;
240
- 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;
241
- export type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null) => void;
242
- export type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
243
- export type NextFn = (vnode: VNode) => RendererNode | null;
244
- export type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
245
- export type RemoveFn = (vnode: VNode) => void;
246
- export type UnmountChildrenFn = (children: VNode[], parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean, start?: number) => void;
247
- export type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
248
- export type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
246
+ 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;
247
+ 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;
248
+ type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null) => void;
249
+ type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
250
+ type NextFn = (vnode: VNode) => RendererNode | null;
251
+ type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
252
+ type RemoveFn = (vnode: VNode) => void;
253
+ type UnmountChildrenFn = (children: VNode[], parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean, start?: number) => void;
254
+ type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
255
+ type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
249
256
  declare const enum MoveType {
250
257
  ENTER = 0,
251
258
  LEAVE = 1,
@@ -266,63 +273,65 @@ declare const enum MoveType {
266
273
  * })
267
274
  * ```
268
275
  */
269
- declare function createRenderer<HostNode = RendererNode, HostElement = RendererElement>(options: RendererOptions<HostNode, HostElement>): Renderer<HostElement>;
270
- declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer;
276
+ export declare function createRenderer<HostNode = RendererNode, HostElement = RendererElement>(options: RendererOptions<HostNode, HostElement>): Renderer<HostElement>;
277
+ export declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer;
271
278
 
272
- export type MatchPattern = string | RegExp | (string | RegExp)[];
279
+ type MatchPattern = string | RegExp | (string | RegExp)[];
273
280
  export interface KeepAliveProps {
274
281
  include?: MatchPattern;
275
282
  exclude?: MatchPattern;
276
283
  max?: number | string;
277
284
  }
278
- declare const KeepAlive: {
285
+ export declare const KeepAlive: {
279
286
  new (): {
280
287
  $props: VNodeProps & KeepAliveProps;
281
288
  };
282
289
  __isKeepAlive: true;
283
290
  };
284
- declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void;
285
- declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void;
291
+ export declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void;
292
+ export declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void;
286
293
 
287
- declare const onBeforeMount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
288
- declare const onMounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
289
- declare const onBeforeUpdate: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
290
- declare const onUpdated: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
291
- declare const onBeforeUnmount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
292
- declare const onUnmounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
293
- declare const onServerPrefetch: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
294
- export type DebuggerHook = (e: DebuggerEvent) => void;
295
- declare const onRenderTriggered: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
296
- declare const onRenderTracked: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
297
- export type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
298
- declare function onErrorCaptured<TError = Error>(hook: ErrorCapturedHook<TError>, target?: ComponentInternalInstance | null): void;
294
+ export declare const onBeforeMount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
295
+ export declare const onMounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
296
+ export declare const onBeforeUpdate: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
297
+ export declare const onUpdated: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
298
+ export declare const onBeforeUnmount: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
299
+ export declare const onUnmounted: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
300
+ export declare const onServerPrefetch: (hook: () => any, target?: ComponentInternalInstance | null) => false | Function | undefined;
301
+ type DebuggerHook = (e: DebuggerEvent) => void;
302
+ export declare const onRenderTriggered: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
303
+ export declare const onRenderTracked: (hook: DebuggerHook, target?: ComponentInternalInstance | null) => false | Function | undefined;
304
+ type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
305
+ export declare function onErrorCaptured<TError = Error>(hook: ErrorCapturedHook<TError>, target?: ComponentInternalInstance | null): void;
299
306
 
300
307
  export type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
301
308
  export type ComponentObjectPropsOptions<P = Data> = {
302
309
  [K in keyof P]: Prop<P[K]> | null;
303
310
  };
304
311
  export type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
305
- export type DefaultFactory<T> = (props: Data) => T | null | undefined;
306
- export interface PropOptions<T = any, D = T> {
312
+ type DefaultFactory<T> = (props: Data) => T | null | undefined;
313
+ interface PropOptions<T = any, D = T> {
307
314
  type?: PropType<T> | true | null;
308
315
  required?: boolean;
309
316
  default?: D | DefaultFactory<D> | null | undefined | object;
310
317
  validator?(value: unknown): boolean;
318
+ /* removed internal: skipCheck */
319
+ /* removed internal: skipFactory */
311
320
  }
312
321
  export type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
313
- export type PropConstructor<T = any> = {
322
+ type PropConstructor<T = any> = {
314
323
  new (...args: any[]): T & {};
315
324
  } | {
316
325
  (): T;
317
326
  } | PropMethod<T>;
318
- export type PropMethod<T, TConstructor = any> = [T] extends [
327
+ type PropMethod<T, TConstructor = any> = [T] extends [
319
328
  ((...args: any) => any) | undefined
320
329
  ] ? {
321
330
  new (): TConstructor;
322
331
  (): T;
323
332
  readonly prototype: TConstructor;
324
333
  } : never;
325
- export type RequiredKeys<T> = {
334
+ type RequiredKeys<T> = {
326
335
  [K in keyof T]: T[K] extends {
327
336
  required: true;
328
337
  } | {
@@ -333,8 +342,8 @@ export type RequiredKeys<T> = {
333
342
  default: undefined | (() => undefined);
334
343
  } ? never : K : never;
335
344
  }[keyof T];
336
- export type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
337
- export type DefaultKeys<T> = {
345
+ type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
346
+ type DefaultKeys<T> = {
338
347
  [K in keyof T]: T[K] extends {
339
348
  default: any;
340
349
  } | BooleanConstructor | {
@@ -344,7 +353,7 @@ export type DefaultKeys<T> = {
344
353
  required: true;
345
354
  } ? never : K : never;
346
355
  }[keyof T];
347
- export type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
356
+ type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
348
357
  type: null | true;
349
358
  }] ? any : [T] extends [ObjectConstructor | {
350
359
  type: ObjectConstructor;
@@ -367,12 +376,12 @@ declare const enum BooleanFlags {
367
376
  export type ExtractDefaultPropTypes<O> = O extends object ? {
368
377
  [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>;
369
378
  } : {};
370
- export type NormalizedProp = null | (PropOptions & {
379
+ type NormalizedProp = null | (PropOptions & {
371
380
  [BooleanFlags.shouldCast]?: boolean;
372
381
  [BooleanFlags.shouldCastTrue]?: boolean;
373
382
  });
374
- export type NormalizedProps = Record<string, NormalizedProp>;
375
- export type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
383
+ type NormalizedProps = Record<string, NormalizedProp>;
384
+ type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
376
385
 
377
386
  /**
378
387
  Runtime helper for applying directives to a vnode. Example usage:
@@ -396,7 +405,7 @@ export interface DirectiveBinding<V = any> {
396
405
  dir: ObjectDirective<any, V>;
397
406
  }
398
407
  export type DirectiveHook<T = any, Prev = VNode<any, T> | null, V = any> = (el: T, binding: DirectiveBinding<V>, vnode: VNode<any, T>, prevVNode: Prev) => void;
399
- export type SSRDirectiveHook = (binding: DirectiveBinding, vnode: VNode) => Data | undefined;
408
+ type SSRDirectiveHook = (binding: DirectiveBinding, vnode: VNode) => Data | undefined;
400
409
  export interface ObjectDirective<T = any, V = any> {
401
410
  created?: DirectiveHook<T, null, V>;
402
411
  beforeMount?: DirectiveHook<T, null, V>;
@@ -410,14 +419,14 @@ export interface ObjectDirective<T = any, V = any> {
410
419
  }
411
420
  export type FunctionDirective<T = any, V = any> = DirectiveHook<T, any, V>;
412
421
  export type Directive<T = any, V = any> = ObjectDirective<T, V> | FunctionDirective<T, V>;
413
- export type DirectiveModifiers = Record<string, boolean>;
422
+ type DirectiveModifiers = Record<string, boolean>;
414
423
  export type DirectiveArguments = Array<[Directive | undefined] | [Directive | undefined, any] | [Directive | undefined, any, string] | [Directive | undefined, any, string, DirectiveModifiers]>;
415
424
  /**
416
425
  * Adds directives to a VNode.
417
426
  */
418
- declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T;
427
+ export declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T;
419
428
 
420
- declare const enum DeprecationTypes {
429
+ export declare const enum DeprecationTypes {
421
430
  GLOBAL_MOUNT = "GLOBAL_MOUNT",
422
431
  GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
423
432
  GLOBAL_EXTEND = "GLOBAL_EXTEND",
@@ -462,7 +471,7 @@ declare const enum DeprecationTypes {
462
471
  PRIVATE_APIS = "PRIVATE_APIS"
463
472
  }
464
473
  declare function warnDeprecation(key: DeprecationTypes, instance: ComponentInternalInstance | null, ...args: any[]): void;
465
- export type CompatConfig = Partial<Record<DeprecationTypes, boolean | 'suppress-warning'>> & {
474
+ type CompatConfig = Partial<Record<DeprecationTypes, boolean | 'suppress-warning'>> & {
466
475
  MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
467
476
  };
468
477
  declare function configureCompat(config: CompatConfig): void;
@@ -498,8 +507,8 @@ declare function checkCompatEnabled(key: DeprecationTypes, instance: ComponentIn
498
507
  export interface ComponentCustomOptions {
499
508
  }
500
509
  export type RenderFunction = () => VNodeChild;
501
- 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 {
502
- setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
510
+ 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, S extends SlotsType = {}, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II>, ComponentInternalOptions, ComponentCustomOptions {
511
+ setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
503
512
  name?: string;
504
513
  template?: string | object;
505
514
  render?: Function;
@@ -507,6 +516,7 @@ export interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedO
507
516
  directives?: Record<string, Directive>;
508
517
  inheritAttrs?: boolean;
509
518
  emits?: (E | EE[]) & ThisType<void>;
519
+ slots?: S;
510
520
  expose?: string[];
511
521
  serverPrefetch?(): void | Promise<any>;
512
522
  compilerOptions?: RuntimeCompilerOptions;
@@ -529,47 +539,47 @@ export interface RuntimeCompilerOptions {
529
539
  comments?: boolean;
530
540
  delimiters?: [string, string];
531
541
  }
532
- 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> & {
542
+ 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, S extends SlotsType = {}, I extends ComponentInjectOptions = {}, II extends string = string, PE = Props & EmitsToProps<E>> = ComponentOptionsBase<PE, RawBindings, D, C, M, Mixin, Extends, E, EE, S, {}, I, II> & {
533
543
  props?: undefined;
534
- } & ThisType<CreateComponentPublicInstance<PE, RawBindings, D, C, M, Mixin, Extends, E, PE, {}, false, I>>;
535
- 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 = Prettify<Readonly<{
544
+ } & ThisType<CreateComponentPublicInstance<PE, RawBindings, D, C, M, Mixin, Extends, E, S, PE, {}, false, I>>;
545
+ 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, S extends SlotsType = {}, I extends ComponentInjectOptions = {}, II extends string = string, Props = Prettify<Readonly<{
536
546
  [key in PropNames]?: any;
537
- } & EmitsToProps<E>>>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II> & {
547
+ } & EmitsToProps<E>>>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, S, {}, I, II> & {
538
548
  props: PropNames[];
539
- } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I>>;
540
- 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 = Prettify<Readonly<ExtractPropTypes<PropsOptions> & EmitsToProps<E>>>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> & {
549
+ } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, S, Props, {}, false, I>>;
550
+ 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, S extends SlotsType = {}, I extends ComponentInjectOptions = {}, II extends string = string, Props = Prettify<Readonly<ExtractPropTypes<PropsOptions> & EmitsToProps<E>>>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, S, Defaults, I, II> & {
541
551
  props: PropsOptions & ThisType<void>;
542
- } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I>>;
543
- 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>>>;
544
- export type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any>;
552
+ } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, S, Props, Defaults, false, I>>;
553
+ 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>>>;
554
+ export type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any>;
545
555
  export type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
546
556
  export interface MethodOptions {
547
557
  [key: string]: Function;
548
558
  }
549
- export type ExtractComputedReturns<T extends any> = {
559
+ type ExtractComputedReturns<T extends any> = {
550
560
  [key in keyof T]: T[key] extends {
551
561
  get: (...args: any[]) => infer TReturn;
552
562
  } ? TReturn : T[key] extends (...args: any[]) => infer TReturn ? TReturn : never;
553
563
  };
554
- export type ObjectWatchOptionItem = {
564
+ type ObjectWatchOptionItem = {
555
565
  handler: WatchCallback | string;
556
566
  } & WatchOptions;
557
- export type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
558
- export type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
559
- export type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
567
+ type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
568
+ type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
569
+ type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
560
570
  export type ComponentProvideOptions = ObjectProvideOptions | Function;
561
- export type ObjectProvideOptions = Record<string | symbol, unknown>;
571
+ type ObjectProvideOptions = Record<string | symbol, unknown>;
562
572
  export type ComponentInjectOptions = string[] | ObjectInjectOptions;
563
- export type ObjectInjectOptions = Record<string | symbol, string | symbol | {
573
+ type ObjectInjectOptions = Record<string | symbol, string | symbol | {
564
574
  from?: string | symbol;
565
575
  default?: unknown;
566
576
  }>;
567
- export type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
577
+ type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
568
578
  [K in T[number]]?: unknown;
569
579
  } : T extends ObjectInjectOptions ? {
570
580
  [K in keyof T]?: unknown;
571
581
  } : never;
572
- export interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string> {
582
+ interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string> {
573
583
  compatConfig?: CompatConfig;
574
584
  [key: string]: any;
575
585
  data?: (this: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
@@ -613,9 +623,9 @@ export interface LegacyOptions<Props, D, C extends ComputedOptions, M extends Me
613
623
  */
614
624
  __differentiator?: keyof D | keyof C | keyof M;
615
625
  }
616
- export type MergedHook<T = () => void> = T | T[];
617
- export type MergedComponentOptions = ComponentOptions & MergedComponentOptionsOverride;
618
- export type MergedComponentOptionsOverride = {
626
+ type MergedHook<T = () => void> = T | T[];
627
+ type MergedComponentOptions = ComponentOptions & MergedComponentOptionsOverride;
628
+ type MergedComponentOptionsOverride = {
619
629
  beforeCreate?: MergedHook;
620
630
  created?: MergedHook;
621
631
  beforeMount?: MergedHook;
@@ -634,8 +644,8 @@ export type MergedComponentOptionsOverride = {
634
644
  renderTriggered?: MergedHook<DebuggerHook>;
635
645
  errorCaptured?: MergedHook<ErrorCapturedHook>;
636
646
  };
637
- export type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
638
- export type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
647
+ type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
648
+ type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
639
649
  P: P;
640
650
  B: B;
641
651
  D: D;
@@ -646,10 +656,10 @@ export type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions =
646
656
 
647
657
  export interface InjectionKey<T> extends Symbol {
648
658
  }
649
- declare function provide<T>(key: InjectionKey<T> | string | number, value: T): void;
650
- declare function inject<T>(key: InjectionKey<T> | string): T | undefined;
651
- declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T, treatDefaultAsFactory?: false): T;
652
- declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T | (() => T), treatDefaultAsFactory: true): T;
659
+ export declare function provide<T>(key: InjectionKey<T> | string | number, value: T): void;
660
+ export declare function inject<T>(key: InjectionKey<T> | string): T | undefined;
661
+ export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T, treatDefaultAsFactory?: false): T;
662
+ export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T | (() => T), treatDefaultAsFactory: true): T;
653
663
 
654
664
  export interface App<HostElement = any> {
655
665
  version: string;
@@ -713,7 +723,7 @@ export interface AppContext {
713
723
  /* removed internal: reload */
714
724
  /* removed internal: filters */
715
725
  }
716
- export type PluginInstallFunction<Options> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
726
+ type PluginInstallFunction<Options> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
717
727
  export type Plugin<Options = any[]> = (PluginInstallFunction<Options> & {
718
728
  install?: PluginInstallFunction<Options>;
719
729
  }) | {
@@ -721,7 +731,7 @@ export type Plugin<Options = any[]> = (PluginInstallFunction<Options> & {
721
731
  };
722
732
  export type CreateAppFunction<HostElement> = (rootComponent: Component, rootProps?: Data | null) => App<HostElement>;
723
733
 
724
- export type Hook<T = () => void> = T | T[];
734
+ type Hook<T = () => void> = T | T[];
725
735
  export interface BaseTransitionProps<HostElement = RendererElement> {
726
736
  mode?: 'in-out' | 'out-in' | 'default';
727
737
  appear?: boolean;
@@ -756,8 +766,8 @@ export interface TransitionState {
756
766
  isUnmounting: boolean;
757
767
  leavingVNodes: Map<any, Record<string, VNode>>;
758
768
  }
759
- declare function useTransitionState(): TransitionState;
760
- declare const BaseTransitionPropsValidators: {
769
+ export declare function useTransitionState(): TransitionState;
770
+ export declare const BaseTransitionPropsValidators: {
761
771
  mode: StringConstructor;
762
772
  appear: BooleanConstructor;
763
773
  persisted: BooleanConstructor;
@@ -774,14 +784,14 @@ declare const BaseTransitionPropsValidators: {
774
784
  onAfterAppear: (ArrayConstructor | FunctionConstructor)[];
775
785
  onAppearCancelled: (ArrayConstructor | FunctionConstructor)[];
776
786
  };
777
- declare const BaseTransition: new () => {
787
+ export declare const BaseTransition: new () => {
778
788
  $props: BaseTransitionProps<any>;
779
789
  };
780
- declare function resolveTransitionHooks(vnode: VNode, props: BaseTransitionProps<any>, state: TransitionState, instance: ComponentInternalInstance): TransitionHooks;
781
- declare function setTransitionHooks(vnode: VNode, hooks: TransitionHooks): void;
782
- declare function getTransitionRawChildren(children: VNode[], keepComment?: boolean, parentKey?: VNode['key']): VNode[];
790
+ export declare function resolveTransitionHooks(vnode: VNode, props: BaseTransitionProps<any>, state: TransitionState, instance: ComponentInternalInstance): TransitionHooks;
791
+ export declare function setTransitionHooks(vnode: VNode, hooks: TransitionHooks): void;
792
+ export declare function getTransitionRawChildren(children: VNode[], keepComment?: boolean, parentKey?: VNode['key']): VNode[];
783
793
 
784
- export type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
794
+ type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
785
795
  export interface TeleportProps {
786
796
  to: string | RendererElement | null | undefined;
787
797
  disabled?: boolean;
@@ -800,7 +810,7 @@ declare const enum TeleportMoveTypes {
800
810
  }
801
811
  declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, moveType?: TeleportMoveTypes): void;
802
812
  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;
803
- declare const Teleport: {
813
+ export declare const Teleport: {
804
814
  new (): {
805
815
  $props: VNodeProps & TeleportProps;
806
816
  };
@@ -810,38 +820,38 @@ declare const Teleport: {
810
820
  /**
811
821
  * @private
812
822
  */
813
- declare function resolveComponent(name: string, maybeSelfReference?: boolean): ConcreteComponent | string;
823
+ export declare function resolveComponent(name: string, maybeSelfReference?: boolean): ConcreteComponent | string;
814
824
  declare const NULL_DYNAMIC_COMPONENT: unique symbol;
815
825
  /**
816
826
  * @private
817
827
  */
818
- declare function resolveDynamicComponent(component: unknown): VNodeTypes;
828
+ export declare function resolveDynamicComponent(component: unknown): VNodeTypes;
819
829
  /**
820
830
  * @private
821
831
  */
822
- declare function resolveDirective(name: string): Directive | undefined;
832
+ export declare function resolveDirective(name: string): Directive | undefined;
823
833
  /* removed internal: resolveFilter$1 */
824
834
 
825
- declare const Fragment: {
835
+ export declare const Fragment: {
826
836
  new (): {
827
837
  $props: VNodeProps;
828
838
  };
829
839
  __isFragment: true;
830
840
  };
831
- declare const Text: unique symbol;
832
- declare const Comment: unique symbol;
833
- declare const Static: unique symbol;
841
+ export declare const Text: unique symbol;
842
+ export declare const Comment: unique symbol;
843
+ export declare const Static: unique symbol;
834
844
  export type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
835
845
  export type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
836
- export type VNodeNormalizedRefAtom = {
846
+ type VNodeNormalizedRefAtom = {
837
847
  i: ComponentInternalInstance;
838
848
  r: VNodeRef;
839
849
  k?: string;
840
850
  f?: boolean;
841
851
  };
842
- export type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
843
- export type VNodeMountHook = (vnode: VNode) => void;
844
- export type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
852
+ type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
853
+ type VNodeMountHook = (vnode: VNode) => void;
854
+ type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
845
855
  export type VNodeProps = {
846
856
  key?: string | number | symbol;
847
857
  ref?: VNodeRef;
@@ -854,7 +864,7 @@ export type VNodeProps = {
854
864
  onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
855
865
  onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
856
866
  };
857
- export type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
867
+ type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
858
868
  export type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
859
869
  export type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
860
870
  export type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
@@ -911,7 +921,7 @@ export interface VNode<HostNode = RendererNode, HostElement = RendererElement, E
911
921
  *
912
922
  * @private
913
923
  */
914
- declare function openBlock(disableTracking?: boolean): void;
924
+ export declare function openBlock(disableTracking?: boolean): void;
915
925
  /**
916
926
  * Block tracking sometimes needs to be disabled, for example during the
917
927
  * creation of a tree that needs to be cached by v-once. The compiler generates
@@ -928,11 +938,11 @@ declare function openBlock(disableTracking?: boolean): void;
928
938
  *
929
939
  * @private
930
940
  */
931
- declare function setBlockTracking(value: number): void;
941
+ export declare function setBlockTracking(value: number): void;
932
942
  /**
933
943
  * @private
934
944
  */
935
- declare function createElementBlock(type: string | typeof Fragment, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[], shapeFlag?: number): VNode<RendererNode, RendererElement, {
945
+ export declare function createElementBlock(type: string | typeof Fragment, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[], shapeFlag?: number): VNode<RendererNode, RendererElement, {
936
946
  [key: string]: any;
937
947
  }>;
938
948
  /**
@@ -942,8 +952,8 @@ declare function createElementBlock(type: string | typeof Fragment, props?: Reco
942
952
  *
943
953
  * @private
944
954
  */
945
- declare function createBlock(type: VNodeTypes | ClassComponent, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[]): VNode;
946
- declare function isVNode(value: any): value is VNode;
955
+ export declare function createBlock(type: VNodeTypes | ClassComponent, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[]): VNode;
956
+ export declare function isVNode(value: any): value is VNode;
947
957
  declare let vnodeArgsTransformer: ((args: Parameters<typeof _createVNode>, instance: ComponentInternalInstance | null) => Parameters<typeof _createVNode>) | undefined;
948
958
  /**
949
959
  * Internal API for registering an arguments transform for createVNode
@@ -951,31 +961,31 @@ declare let vnodeArgsTransformer: ((args: Parameters<typeof _createVNode>, insta
951
961
  * It is *internal* but needs to be exposed for test-utils to pick up proper
952
962
  * typings
953
963
  */
954
- declare function transformVNodeArgs(transformer?: typeof vnodeArgsTransformer): void;
955
- 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, {
964
+ export declare function transformVNodeArgs(transformer?: typeof vnodeArgsTransformer): void;
965
+ 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, {
956
966
  [key: string]: any;
957
967
  }>;
958
968
 
959
- declare const createVNode: typeof _createVNode;
969
+ export declare const createVNode: typeof _createVNode;
960
970
  declare function _createVNode(type: VNodeTypes | ClassComponent | typeof NULL_DYNAMIC_COMPONENT, props?: (Data & VNodeProps) | null, children?: unknown, patchFlag?: number, dynamicProps?: string[] | null, isBlockNode?: boolean): VNode;
961
- declare function guardReactiveProps(props: (Data & VNodeProps) | null): (Data & VNodeProps) | null;
962
- declare function cloneVNode<T, U>(vnode: VNode<T, U>, extraProps?: (Data & VNodeProps) | null, mergeRef?: boolean): VNode<T, U>;
971
+ export declare function guardReactiveProps(props: (Data & VNodeProps) | null): (Data & VNodeProps) | null;
972
+ export declare function cloneVNode<T, U>(vnode: VNode<T, U>, extraProps?: (Data & VNodeProps) | null, mergeRef?: boolean): VNode<T, U>;
963
973
  /**
964
974
  * @private
965
975
  */
966
- declare function createTextVNode(text?: string, flag?: number): VNode;
976
+ export declare function createTextVNode(text?: string, flag?: number): VNode;
967
977
  /**
968
978
  * @private
969
979
  */
970
- declare function createStaticVNode(content: string, numberOfNodes: number): VNode;
980
+ export declare function createStaticVNode(content: string, numberOfNodes: number): VNode;
971
981
  /**
972
982
  * @private
973
983
  */
974
- declare function createCommentVNode(text?: string, asBlock?: boolean): VNode;
984
+ export declare function createCommentVNode(text?: string, asBlock?: boolean): VNode;
975
985
  declare function normalizeVNode(child: VNodeChild): VNode;
976
- declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
986
+ export declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
977
987
 
978
- export type Data = Record<string, unknown>;
988
+ type Data = Record<string, unknown>;
979
989
  /**
980
990
  * For extending allowed non-declared props on components in TSX
981
991
  */
@@ -988,7 +998,7 @@ export interface AllowedComponentProps {
988
998
  class?: unknown;
989
999
  style?: unknown;
990
1000
  }
991
- export interface ComponentInternalOptions {
1001
+ interface ComponentInternalOptions {
992
1002
  /* removed internal: __scopeId */
993
1003
  /* removed internal: __cssModules */
994
1004
  /* removed internal: __hmrId */
@@ -1005,15 +1015,16 @@ export interface ComponentInternalOptions {
1005
1015
  */
1006
1016
  __name?: string;
1007
1017
  }
1008
- export interface FunctionalComponent<P = {}, E extends EmitsOptions = {}> extends ComponentInternalOptions {
1009
- (props: P, ctx: Omit<SetupContext<E>, 'expose'>): any;
1018
+ export interface FunctionalComponent<P = {}, E extends EmitsOptions = {}, S extends Record<string, any> = any> extends ComponentInternalOptions {
1019
+ (props: P, ctx: Omit<SetupContext<E, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
1010
1020
  props?: ComponentPropsOptions<P>;
1011
1021
  emits?: E | (keyof E)[];
1022
+ slots?: IfAny<S, Slots, SlotsType<S>>;
1012
1023
  inheritAttrs?: boolean;
1013
1024
  displayName?: string;
1014
1025
  compatConfig?: CompatConfig;
1015
1026
  }
1016
- export interface ClassComponent {
1027
+ interface ClassComponent {
1017
1028
  new (...args: any[]): ComponentPublicInstance<any, any, any, any, any>;
1018
1029
  __vccOpts: ComponentOptions;
1019
1030
  }
@@ -1023,17 +1034,17 @@ export interface ClassComponent {
1023
1034
  * values, e.g. checking if its a function or not. This is mostly for internal
1024
1035
  * implementation code.
1025
1036
  */
1026
- 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>;
1037
+ 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>;
1027
1038
  /**
1028
1039
  * A type used in public APIs where a component type is expected.
1029
1040
  * The constructor type is an artificial type returned by defineComponent().
1030
1041
  */
1031
1042
  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>;
1032
1043
 
1033
- export type LifecycleHook<TFn = Function> = TFn[] | null;
1034
- export type SetupContext<E = EmitsOptions> = E extends any ? {
1044
+ type LifecycleHook<TFn = Function> = TFn[] | null;
1045
+ export type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
1035
1046
  attrs: Data;
1036
- slots: Slots;
1047
+ slots: TypedSlots<S>;
1037
1048
  emit: EmitFn<E>;
1038
1049
  expose: (exposed?: Record<string, any>) => void;
1039
1050
  } : never;
@@ -1121,22 +1132,22 @@ export interface ComponentInternalInstance {
1121
1132
  /* removed internal: ut */
1122
1133
  }
1123
1134
  declare function createComponentInstance(vnode: VNode, parent: ComponentInternalInstance | null, suspense: SuspenseBoundary | null): ComponentInternalInstance;
1124
- declare const getCurrentInstance: () => ComponentInternalInstance | null;
1135
+ export declare const getCurrentInstance: () => ComponentInternalInstance | null;
1125
1136
  declare function setupComponent(instance: ComponentInternalInstance, isSSR?: boolean): Promise<void> | undefined;
1126
1137
  /**
1127
1138
  * For runtime-dom to register the compiler.
1128
1139
  * Note the exported method uses any to avoid d.ts relying on the compiler types.
1129
1140
  */
1130
- declare function registerRuntimeCompiler(_compile: any): void;
1131
- declare const isRuntimeOnly: () => boolean;
1141
+ export declare function registerRuntimeCompiler(_compile: any): void;
1142
+ export declare const isRuntimeOnly: () => boolean;
1132
1143
 
1133
1144
  export type WatchEffect = (onCleanup: OnCleanup) => void;
1134
1145
  export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T);
1135
1146
  export type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
1136
- export type MapSources<T, Immediate> = {
1147
+ type MapSources<T, Immediate> = {
1137
1148
  [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;
1138
1149
  };
1139
- export type OnCleanup = (cleanupFn: () => void) => void;
1150
+ type OnCleanup = (cleanupFn: () => void) => void;
1140
1151
  export interface WatchOptionsBase extends DebuggerOptions {
1141
1152
  flush?: 'pre' | 'post' | 'sync';
1142
1153
  }
@@ -1145,25 +1156,34 @@ export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
1145
1156
  deep?: boolean;
1146
1157
  }
1147
1158
  export type WatchStopHandle = () => void;
1148
- declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchStopHandle;
1149
- declare function watchPostEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
1150
- declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
1151
- export type MultiWatchSources = (WatchSource<unknown> | object)[];
1152
- 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;
1153
- 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;
1154
- 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;
1155
- 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;
1159
+ export declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchStopHandle;
1160
+ export declare function watchPostEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
1161
+ export declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
1162
+ type MultiWatchSources = (WatchSource<unknown> | object)[];
1163
+ 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;
1164
+ 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;
1165
+ 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;
1166
+ 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;
1156
1167
 
1157
- export type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
1158
- 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;
1159
- declare function defineComponent<Props, RawBindings = object>(setup: (props: Readonly<Props>, ctx: SetupContext) => RawBindings | RenderFunction): DefineComponent<Props, RawBindings>;
1160
- 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>;
1161
- 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<{
1168
+ type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
1169
+ 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, S extends SlotsType = {}, 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, S, PP & Props, Defaults, true> & Props> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, S, Defaults> & PP;
1170
+ 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'> & {
1171
+ props?: (keyof Props)[];
1172
+ emits?: E | EE[];
1173
+ slots?: S;
1174
+ }): (props: Props & EmitsToProps<E>) => any;
1175
+ 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'> & {
1176
+ props?: ComponentObjectPropsOptions<Props>;
1177
+ emits?: E | EE[];
1178
+ slots?: S;
1179
+ }): (props: Props & EmitsToProps<E>) => any;
1180
+ 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, S, I, II>): DefineComponent<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, S>;
1181
+ 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>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, S, I, II>): DefineComponent<Readonly<{
1162
1182
  [key in PropNames]?: any;
1163
- }>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
1164
- 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>;
1183
+ }>, RawBindings, D, C, M, Mixin, Extends, E, EE, S>;
1184
+ 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, S, I, II>): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, S>;
1165
1185
 
1166
- export type AsyncComponentResolveResult<T = Component> = T | {
1186
+ type AsyncComponentResolveResult<T = Component> = T | {
1167
1187
  default: T;
1168
1188
  };
1169
1189
  export type AsyncComponentLoader<T = any> = () => Promise<AsyncComponentResolveResult<T>>;
@@ -1176,7 +1196,7 @@ export interface AsyncComponentOptions<T = any> {
1176
1196
  suspensible?: boolean;
1177
1197
  onError?: (error: Error, retry: () => void, fail: () => void, attempts: number) => any;
1178
1198
  }
1179
- declare function defineAsyncComponent<T extends Component = {
1199
+ export declare function defineAsyncComponent<T extends Component = {
1180
1200
  new (): ComponentPublicInstance;
1181
1201
  }>(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>): T;
1182
1202
 
@@ -1205,20 +1225,22 @@ declare function defineAsyncComponent<T extends Component = {
1205
1225
  * foo?: string
1206
1226
  * bar: number
1207
1227
  * }>()
1228
+ *
1229
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
1208
1230
  * ```
1209
1231
  *
1210
1232
  * This is only usable inside `<script setup>`, is compiled away in the
1211
1233
  * output and should **not** be actually called at runtime.
1212
1234
  */
1213
- declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{
1235
+ export declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{
1214
1236
  [key in PropNames]?: any;
1215
1237
  }>>;
1216
- declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
1217
- declare function defineProps<TypeProps>(): ResolveProps<TypeProps>;
1218
- export type ResolveProps<T, BooleanKeys extends keyof T = BooleanKey<T>> = Prettify<Readonly<T & {
1238
+ export declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
1239
+ export declare function defineProps<TypeProps>(): ResolveProps<TypeProps>;
1240
+ type ResolveProps<T, BooleanKeys extends keyof T = BooleanKey<T>> = Prettify<Readonly<T & {
1219
1241
  [K in BooleanKeys]-?: boolean;
1220
1242
  }>>;
1221
- export type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
1243
+ type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
1222
1244
  /**
1223
1245
  * Vue `<script setup>` compiler macro for declaring a component's emitted
1224
1246
  * events. The expected argument is the same as the component `emits` option.
@@ -1241,10 +1263,16 @@ export type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]]
1241
1263
  *
1242
1264
  * This is only usable inside `<script setup>`, is compiled away in the
1243
1265
  * output and should **not** be actually called at runtime.
1266
+ *
1267
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
1244
1268
  */
1245
- declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
1246
- declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
1247
- declare function defineEmits<TypeEmit>(): TypeEmit;
1269
+ export declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
1270
+ export declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
1271
+ export declare function defineEmits<T extends ((...args: any[]) => any) | Record<string, any[]>>(): T extends (...args: any[]) => any ? T : ShortEmits<T>;
1272
+ type RecordToUnion<T extends Record<string, any>> = T[keyof T];
1273
+ type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{
1274
+ [K in keyof T]: (evt: K, ...args: T[K]) => void;
1275
+ }>>;
1248
1276
  /**
1249
1277
  * Vue `<script setup>` compiler macro for declaring a component's exposed
1250
1278
  * instance properties when it is accessed by a parent component via template
@@ -1256,14 +1284,29 @@ declare function defineEmits<TypeEmit>(): TypeEmit;
1256
1284
  *
1257
1285
  * This is only usable inside `<script setup>`, is compiled away in the
1258
1286
  * output and should **not** be actually called at runtime.
1287
+ *
1288
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
1259
1289
  */
1260
- declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
1261
- export type NotUndefined<T> = T extends undefined ? never : T;
1262
- export type InferDefaults<T> = {
1290
+ export declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
1291
+ /**
1292
+ * Vue `<script setup>` compiler macro for declaring a component's additional
1293
+ * options. This should be used only for options that cannot be expressed via
1294
+ * Composition API - e.g. `inhertiAttrs`.
1295
+ *
1296
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
1297
+ */
1298
+ 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> & {
1299
+ emits?: undefined;
1300
+ expose?: undefined;
1301
+ slots?: undefined;
1302
+ }): void;
1303
+ export declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): TypedSlots<SlotsType<S>>;
1304
+ type NotUndefined<T> = T extends undefined ? never : T;
1305
+ type InferDefaults<T> = {
1263
1306
  [K in keyof T]?: InferDefault<T, NotUndefined<T[K]>>;
1264
1307
  };
1265
- export type InferDefault<P, T> = T extends null | number | string | boolean | symbol | Function ? T | ((props: P) => T) : (props: P) => T;
1266
- export type PropsWithDefaults<Base, Defaults> = Base & {
1308
+ type InferDefault<P, T> = T extends null | number | string | boolean | symbol | Function ? T | ((props: P) => T) : (props: P) => T;
1309
+ type PropsWithDefaults<Base, Defaults> = Base & {
1267
1310
  [K in keyof Defaults]: K extends keyof Base ? Defaults[K] extends undefined ? Base[K] : NotUndefined<Base[K]> : never;
1268
1311
  };
1269
1312
  /**
@@ -1283,20 +1326,22 @@ export type PropsWithDefaults<Base, Defaults> = Base & {
1283
1326
  *
1284
1327
  * This is only usable inside `<script setup>`, is compiled away in the output
1285
1328
  * and should **not** be actually called at runtime.
1329
+ *
1330
+ * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
1286
1331
  */
1287
- declare function withDefaults<Props, Defaults extends InferDefaults<Props>>(props: Props, defaults: Defaults): PropsWithDefaults<Props, Defaults>;
1288
- declare function useSlots(): SetupContext['slots'];
1289
- declare function useAttrs(): SetupContext['attrs'];
1332
+ export declare function withDefaults<Props, Defaults extends InferDefaults<Props>>(props: Props, defaults: Defaults): PropsWithDefaults<Props, Defaults>;
1333
+ export declare function useSlots(): SetupContext['slots'];
1334
+ export declare function useAttrs(): SetupContext['attrs'];
1290
1335
  /* removed internal: mergeDefaults */
1291
1336
  /* removed internal: createPropsRestProxy */
1292
1337
  /* removed internal: withAsyncContext */
1293
1338
 
1294
- export type RawProps = VNodeProps & {
1339
+ type RawProps = VNodeProps & {
1295
1340
  __v_isVNode?: never;
1296
1341
  [Symbol.iterator]?: never;
1297
1342
  } & Record<string, any>;
1298
- export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
1299
- export interface Constructor<P = any> {
1343
+ type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
1344
+ interface Constructor<P = any> {
1300
1345
  __isFragment?: never;
1301
1346
  __isTeleport?: never;
1302
1347
  __isSuspense?: never;
@@ -1304,33 +1349,33 @@ export interface Constructor<P = any> {
1304
1349
  $props: P;
1305
1350
  };
1306
1351
  }
1307
- declare function h(type: string, children?: RawChildren): VNode;
1308
- declare function h(type: string, props?: RawProps | null, children?: RawChildren | RawSlots): VNode;
1309
- declare function h(type: typeof Text | typeof Comment, children?: string | number | boolean): VNode;
1310
- declare function h(type: typeof Text | typeof Comment, props?: null, children?: string | number | boolean): VNode;
1311
- declare function h(type: typeof Fragment, children?: VNodeArrayChildren): VNode;
1312
- declare function h(type: typeof Fragment, props?: RawProps | null, children?: VNodeArrayChildren): VNode;
1313
- declare function h(type: typeof Teleport, props: RawProps & TeleportProps, children: RawChildren | RawSlots): VNode;
1314
- declare function h(type: typeof Suspense, children?: RawChildren): VNode;
1315
- declare function h(type: typeof Suspense, props?: (RawProps & SuspenseProps) | null, children?: RawChildren | RawSlots): VNode;
1316
- declare function h<P, E extends EmitsOptions = {}>(type: FunctionalComponent<P, E>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1317
- declare function h(type: Component, children?: RawChildren): VNode;
1318
- declare function h<P>(type: ConcreteComponent | string, children?: RawChildren): VNode;
1319
- declare function h<P>(type: ConcreteComponent<P> | string, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren): VNode;
1320
- declare function h<P>(type: Component<P>, props?: (RawProps & P) | null, children?: RawChildren | RawSlots): VNode;
1321
- declare function h<P>(type: ComponentOptions<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1322
- declare function h(type: Constructor, children?: RawChildren): VNode;
1323
- declare function h<P>(type: Constructor<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1324
- declare function h(type: DefineComponent, children?: RawChildren): VNode;
1325
- declare function h<P>(type: DefineComponent<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1352
+ export declare function h(type: string, children?: RawChildren): VNode;
1353
+ export declare function h(type: string, props?: RawProps | null, children?: RawChildren | RawSlots): VNode;
1354
+ export declare function h(type: typeof Text | typeof Comment, children?: string | number | boolean): VNode;
1355
+ export declare function h(type: typeof Text | typeof Comment, props?: null, children?: string | number | boolean): VNode;
1356
+ export declare function h(type: typeof Fragment, children?: VNodeArrayChildren): VNode;
1357
+ export declare function h(type: typeof Fragment, props?: RawProps | null, children?: VNodeArrayChildren): VNode;
1358
+ export declare function h(type: typeof Teleport, props: RawProps & TeleportProps, children: RawChildren | RawSlots): VNode;
1359
+ export declare function h(type: typeof Suspense, children?: RawChildren): VNode;
1360
+ export declare function h(type: typeof Suspense, props?: (RawProps & SuspenseProps) | null, children?: RawChildren | RawSlots): VNode;
1361
+ 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;
1362
+ export declare function h(type: Component, children?: RawChildren): VNode;
1363
+ export declare function h<P>(type: ConcreteComponent | string, children?: RawChildren): VNode;
1364
+ export declare function h<P>(type: ConcreteComponent<P> | string, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren): VNode;
1365
+ export declare function h<P>(type: Component<P>, props?: (RawProps & P) | null, children?: RawChildren | RawSlots): VNode;
1366
+ export declare function h<P>(type: ComponentOptions<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1367
+ export declare function h(type: Constructor, children?: RawChildren): VNode;
1368
+ export declare function h<P>(type: Constructor<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1369
+ export declare function h(type: DefineComponent, children?: RawChildren): VNode;
1370
+ export declare function h<P>(type: DefineComponent<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
1326
1371
 
1327
- declare const ssrContextKey: unique symbol;
1328
- declare const useSSRContext: <T = Record<string, any>>() => T | undefined;
1372
+ export declare const ssrContextKey: unique symbol;
1373
+ export declare const useSSRContext: <T = Record<string, any>>() => T | undefined;
1329
1374
 
1330
- declare function warn(msg: string, ...args: any[]): void;
1375
+ export declare function warn(msg: string, ...args: any[]): void;
1331
1376
  /* removed internal: assertNumber */
1332
1377
 
1333
- declare const enum ErrorCodes {
1378
+ export declare const enum ErrorCodes {
1334
1379
  SETUP_FUNCTION = 0,
1335
1380
  RENDER_FUNCTION = 1,
1336
1381
  WATCH_GETTER = 2,
@@ -1347,20 +1392,20 @@ declare const enum ErrorCodes {
1347
1392
  ASYNC_COMPONENT_LOADER = 13,
1348
1393
  SCHEDULER = 14
1349
1394
  }
1350
- export type ErrorTypes = LifecycleHooks | ErrorCodes;
1351
- declare function callWithErrorHandling(fn: Function, instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any;
1352
- declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any[];
1353
- declare function handleError(err: unknown, instance: ComponentInternalInstance | null, type: ErrorTypes, throwInDev?: boolean): void;
1395
+ type ErrorTypes = LifecycleHooks | ErrorCodes;
1396
+ export declare function callWithErrorHandling(fn: Function, instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any;
1397
+ export declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any[];
1398
+ export declare function handleError(err: unknown, instance: ComponentInternalInstance | null, type: ErrorTypes, throwInDev?: boolean): void;
1354
1399
 
1355
- declare function initCustomFormatter(): void;
1400
+ export declare function initCustomFormatter(): void;
1356
1401
 
1357
- export interface AppRecord {
1402
+ interface AppRecord {
1358
1403
  id: number;
1359
1404
  app: App;
1360
1405
  version: string;
1361
1406
  types: Record<string, string | Symbol>;
1362
1407
  }
1363
- export interface DevtoolsHook {
1408
+ interface DevtoolsHook {
1364
1409
  enabled?: boolean;
1365
1410
  emit: (event: string, ...payload: any[]) => void;
1366
1411
  on: (event: string, handler: Function) => void;
@@ -1373,10 +1418,10 @@ export interface DevtoolsHook {
1373
1418
  */
1374
1419
  cleanupBuffer?: (matchArg: unknown) => boolean;
1375
1420
  }
1376
- declare let devtools: DevtoolsHook;
1377
- declare function setDevtoolsHook(hook: DevtoolsHook, target: any): void;
1421
+ export declare let devtools: DevtoolsHook;
1422
+ export declare function setDevtoolsHook(hook: DevtoolsHook, target: any): void;
1378
1423
 
1379
- export type HMRComponent = ComponentOptions | ClassComponent;
1424
+ type HMRComponent = ComponentOptions | ClassComponent;
1380
1425
  export interface HMRRuntime {
1381
1426
  createRecord: typeof createRecord;
1382
1427
  rerender: typeof rerender;
@@ -1401,60 +1446,60 @@ declare function setCurrentRenderingInstance(instance: ComponentInternalInstance
1401
1446
  * Set scope id when creating hoisted vnodes.
1402
1447
  * @private compiler helper
1403
1448
  */
1404
- declare function pushScopeId(id: string | null): void;
1449
+ export declare function pushScopeId(id: string | null): void;
1405
1450
  /**
1406
1451
  * Technically we no longer need this after 3.0.8 but we need to keep the same
1407
1452
  * API for backwards compat w/ code generated by compilers.
1408
1453
  * @private
1409
1454
  */
1410
- declare function popScopeId(): void;
1455
+ export declare function popScopeId(): void;
1411
1456
  /**
1412
1457
  * Only for backwards compat
1413
1458
  * @private
1414
1459
  */
1415
- declare const withScopeId: (_id: string) => typeof withCtx;
1460
+ export declare const withScopeId: (_id: string) => typeof withCtx;
1416
1461
  /**
1417
1462
  * Wrap a slot function to memoize current rendering instance
1418
1463
  * @private compiler helper
1419
1464
  */
1420
- declare function withCtx(fn: Function, ctx?: ComponentInternalInstance | null, isNonScopedSlot?: boolean): Function;
1465
+ export declare function withCtx(fn: Function, ctx?: ComponentInternalInstance | null, isNonScopedSlot?: boolean): Function;
1421
1466
 
1422
1467
  /**
1423
1468
  * v-for string
1424
1469
  * @private
1425
1470
  */
1426
- declare function renderList(source: string, renderItem: (value: string, index: number) => VNodeChild): VNodeChild[];
1471
+ export declare function renderList(source: string, renderItem: (value: string, index: number) => VNodeChild): VNodeChild[];
1427
1472
  /**
1428
1473
  * v-for number
1429
1474
  */
1430
- declare function renderList(source: number, renderItem: (value: number, index: number) => VNodeChild): VNodeChild[];
1475
+ export declare function renderList(source: number, renderItem: (value: number, index: number) => VNodeChild): VNodeChild[];
1431
1476
  /**
1432
1477
  * v-for array
1433
1478
  */
1434
- declare function renderList<T>(source: T[], renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
1479
+ export declare function renderList<T>(source: T[], renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
1435
1480
  /**
1436
1481
  * v-for iterable
1437
1482
  */
1438
- declare function renderList<T>(source: Iterable<T>, renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
1483
+ export declare function renderList<T>(source: Iterable<T>, renderItem: (value: T, index: number) => VNodeChild): VNodeChild[];
1439
1484
  /**
1440
1485
  * v-for object
1441
1486
  */
1442
- declare function renderList<T>(source: T, renderItem: <K extends keyof T>(value: T[K], key: K, index: number) => VNodeChild): VNodeChild[];
1487
+ export declare function renderList<T>(source: T, renderItem: <K extends keyof T>(value: T[K], key: K, index: number) => VNodeChild): VNodeChild[];
1443
1488
 
1444
1489
  /**
1445
1490
  * For prefixing keys in v-on="obj" with "on"
1446
1491
  * @private
1447
1492
  */
1448
- declare function toHandlers(obj: Record<string, any>, preserveCaseIfNecessary?: boolean): Record<string, any>;
1493
+ export declare function toHandlers(obj: Record<string, any>, preserveCaseIfNecessary?: boolean): Record<string, any>;
1449
1494
 
1450
1495
  /**
1451
1496
  * Compiler runtime helper for rendering `<slot/>`
1452
1497
  * @private
1453
1498
  */
1454
- declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode;
1499
+ export declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode;
1455
1500
 
1456
- export type SSRSlot = (...args: any[]) => VNode[] | undefined;
1457
- export interface CompiledSlotDescriptor {
1501
+ type SSRSlot = (...args: any[]) => VNode[] | undefined;
1502
+ interface CompiledSlotDescriptor {
1458
1503
  name: string;
1459
1504
  fn: SSRSlot;
1460
1505
  key?: string;
@@ -1463,12 +1508,12 @@ export interface CompiledSlotDescriptor {
1463
1508
  * Compiler runtime helper for creating dynamic slots object
1464
1509
  * @private
1465
1510
  */
1466
- declare function createSlots(slots: Record<string, SSRSlot>, dynamicSlots: (CompiledSlotDescriptor | CompiledSlotDescriptor[] | undefined)[]): Record<string, SSRSlot>;
1511
+ export declare function createSlots(slots: Record<string, SSRSlot>, dynamicSlots: (CompiledSlotDescriptor | CompiledSlotDescriptor[] | undefined)[]): Record<string, SSRSlot>;
1467
1512
 
1468
- declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any, {
1513
+ export declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any, {
1469
1514
  [key: string]: any;
1470
1515
  }>;
1471
- declare function isMemoSame(cached: VNode, memo: any[]): boolean;
1516
+ export declare function isMemoSame(cached: VNode, memo: any[]): boolean;
1472
1517
 
1473
1518
  declare function renderComponentRoot(instance: ComponentInternalInstance): VNode;
1474
1519
 
@@ -1499,8 +1544,8 @@ export type LegacyConfig = {
1499
1544
  productionTip?: boolean;
1500
1545
  };
1501
1546
 
1502
- export type LegacyPublicInstance = ComponentPublicInstance & LegacyPublicProperties;
1503
- export interface LegacyPublicProperties {
1547
+ type LegacyPublicInstance = ComponentPublicInstance & LegacyPublicProperties;
1548
+ interface LegacyPublicProperties {
1504
1549
  $set(target: object, key: string, value: any): void;
1505
1550
  $delete(target: object, key: string): void;
1506
1551
  $mount(el?: string | Element): this;
@@ -1558,7 +1603,7 @@ export type CompatVue = Pick<App, 'version' | 'component' | 'directive'> & {
1558
1603
  };
1559
1604
  declare function createCompatVue(createApp: CreateAppFunction<Element>, createSingletonApp: CreateAppFunction<Element>): CompatVue;
1560
1605
 
1561
- declare const version: string;
1606
+ export declare const version: string;
1562
1607
 
1563
1608
  declare module '@vue/reactivity' {
1564
1609
  interface RefUnwrapBailTypes {
@@ -1573,17 +1618,21 @@ declare module '@vue/reactivity' {
1573
1618
 
1574
1619
 
1575
1620
 
1576
- 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 };
1621
+ export { createBaseVNode as createElementVNode, };
1577
1622
  // Note: this file is auto concatenated to the end of the bundled d.ts during
1578
1623
  // build.
1579
1624
  type _defineProps = typeof defineProps
1580
1625
  type _defineEmits = typeof defineEmits
1581
1626
  type _defineExpose = typeof defineExpose
1627
+ type _defineOptions = typeof defineOptions
1628
+ type _defineSlots = typeof defineSlots
1582
1629
  type _withDefaults = typeof withDefaults
1583
1630
 
1584
1631
  declare global {
1585
1632
  const defineProps: _defineProps
1586
1633
  const defineEmits: _defineEmits
1587
1634
  const defineExpose: _defineExpose
1635
+ const defineOptions: _defineOptions
1636
+ const defineSlots: _defineSlots
1588
1637
  const withDefaults: _withDefaults
1589
1638
  }