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, 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'; export declare const computed: typeof computed$1; 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>; declare const SlotSymbol: unique symbol; export type SlotsType<T extends Record<string, any> = Record<string, any>> = { [SlotSymbol]?: T; }; type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T>; type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? T[K] : Slot<T[K]>; }>>; type RawSlots = { [name: string]: unknown; $stable?: boolean; /* removed internal: _ctx */ /* removed internal: _ */ }; interface SchedulerJob extends Function { id?: number; pre?: boolean; active?: boolean; computed?: boolean; /** * Indicates whether the effect is allowed to recursively trigger itself * when managed by the scheduler. * * By default, a job cannot trigger itself because some built-in method calls, * e.g. Array.prototype.push actually performs reads as well (#1740) which * can lead to confusing infinite loops. * The allowed cases are component update functions and watch callbacks. * Component update functions may update child component props, which in turn * trigger flush: "pre" watch callbacks that mutates state that the parent * relies on (#1801). Watch callbacks doesn't track its dependencies so if it * triggers itself again, it's likely intentional and it is the user's * responsibility to perform recursive state mutation that eventually * stabilizes (#1727). */ allowRecurse?: boolean; /** * Attached by renderer.ts when setting up a component's render effect * Used to obtain component information when reporting max recursive updates. * dev only. */ ownerInstance?: ComponentInternalInstance; } 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[]; 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; } : {}; 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]>; /** * Custom properties added to component instances in any way and can be accessed through `this` * * @example * Here is an example of adding a property `$router` to every component instance: * ```ts * import { createApp } from 'vue' * import { Router, createRouter } from 'vue-router' * * declare module '@vue/runtime-core' { * interface ComponentCustomProperties { * $router: Router * } * } * * // effectively adding the router to every component instance * const app = createApp({}) * const router = createRouter() * app.config.globalProperties.$router = router * * const vm = app.mount('#app') * // we can access the router from the instance * vm.$router.push('/') * ``` */ export interface ComponentCustomProperties { } 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]; 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 = {}, 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 = {}, S extends SlotsType = {}> = { $: ComponentInternalInstance; $data: D; $props: Prettify<MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults> : P & PublicProps>; $attrs: Data; $refs: Data; $slots: UnwrapSlotsType<S>; $root: ComponentPublicInstance | null; $parent: ComponentPublicInstance | null; $emit: EmitFn<E>; $el: any; $options: Options & MergedComponentOptionsOverride; $forceUpdate: () => void; $nextTick: typeof nextTick; $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R]) => any : (...args: any) => any, options?: WatchOptions): WatchStopHandle; } & P & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>; declare const enum LifecycleHooks { BEFORE_CREATE = "bc", CREATED = "c", BEFORE_MOUNT = "bm", MOUNTED = "m", BEFORE_UPDATE = "bu", UPDATED = "u", BEFORE_UNMOUNT = "bum", UNMOUNTED = "um", DEACTIVATED = "da", ACTIVATED = "a", RENDER_TRIGGERED = "rtg", RENDER_TRACKED = "rtc", ERROR_CAPTURED = "ec", SERVER_PREFETCH = "sp" } export interface SuspenseProps { onResolve?: () => void; onPending?: () => void; onFallback?: () => void; timeout?: string | number; /** * Allow suspense to be captured by parent suspense * * @default false */ suspensible?: boolean; } declare const SuspenseImpl: { name: string; __isSuspense: boolean; process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void; hydrate: typeof hydrateSuspense; create: typeof createSuspenseBoundary; normalize: typeof normalizeSuspenseChildren; }; export declare const Suspense: { new (): { $props: VNodeProps & SuspenseProps; $slots: { default(): VNode[]; fallback(): VNode[]; }; }; __isSuspense: true; }; export interface SuspenseBoundary { vnode: VNode<RendererNode, RendererElement, SuspenseProps>; parent: SuspenseBoundary | null; parentComponent: ComponentInternalInstance | null; isSVG: boolean; container: RendererElement; hiddenContainer: RendererElement; anchor: RendererNode | null; activeBranch: VNode | null; pendingBranch: VNode | null; deps: number; pendingId: number; timeout: number; isInFallback: boolean; isHydrating: boolean; isUnmounted: boolean; effects: Function[]; resolve(force?: boolean, sync?: boolean): void; fallback(fallbackVNode: VNode): void; move(container: RendererElement, anchor: RendererNode | null, type: MoveType): void; next(): RendererNode | null; registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn): void; unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void; } declare function createSuspenseBoundary(vnode: VNode, parentSuspense: SuspenseBoundary | null, parentComponent: ComponentInternalInstance | null, container: RendererElement, hiddenContainer: RendererElement, anchor: RendererNode | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, isHydrating?: boolean): SuspenseBoundary; declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null; declare function normalizeSuspenseChildren(vnode: VNode): void; export type RootHydrateFunction = (vnode: VNode<Node, Element>, container: (Element | ShadowRoot) & { _vnode?: VNode; }) => void; export interface Renderer<HostElement = RendererElement> { render: RootRenderFunction<HostElement>; createApp: CreateAppFunction<HostElement>; } export interface HydrationRenderer extends Renderer<Element | ShadowRoot> { hydrate: RootHydrateFunction; } export type RootRenderFunction<HostElement = RendererElement> = (vnode: VNode | null, container: HostElement, isSVG?: boolean) => void; export interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> { patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, isSVG?: boolean, prevChildren?: VNode<HostNode, HostElement>[], parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, unmountChildren?: UnmountChildrenFn): void; insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void; remove(el: HostNode): void; createElement(type: string, isSVG?: boolean, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & { [key: string]: any; }) | null): HostElement; createText(text: string): HostNode; createComment(text: string): HostNode; setText(node: HostNode, text: string): void; setElementText(node: HostElement, text: string): void; parentNode(node: HostNode): HostElement | null; nextSibling(node: HostNode): HostNode | null; querySelector?(selector: string): HostElement | null; setScopeId?(el: HostElement, id: string): void; cloneNode?(node: HostNode): HostNode; insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, isSVG: boolean, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode]; } export interface RendererNode { [key: string]: any; } export interface RendererElement extends RendererNode { } interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> { p: PatchFn; um: UnmountFn; r: RemoveFn; m: MoveFn; mt: MountComponentFn; mc: MountChildrenFn; pc: PatchChildrenFn; pbc: PatchBlockChildrenFn; n: NextFn; o: RendererOptions<HostNode, HostElement>; } type PatchFn = (n1: VNode | null, // null means this is a mount n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, isSVG?: boolean, slotScopeIds?: string[] | null, optimized?: boolean) => void; type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void; type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean) => void; type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null) => void; 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, REORDER = 2 } /** * The createRenderer function accepts two generic arguments: * HostNode and HostElement, corresponding to Node and Element types in the * host environment. For example, for runtime-dom, HostNode would be the DOM * `Node` interface and HostElement would be the DOM `Element` interface. * * Custom renderers can pass in the platform specific types like this: * * ``` js * const { render, createApp } = createRenderer<Node, Element>({ * patchProp, * ...nodeOps * }) * ``` */ export declare function createRenderer<HostNode = RendererNode, HostElement = RendererElement>(options: RendererOptions<HostNode, HostElement>): Renderer<HostElement>; export declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer; type MatchPattern = string | RegExp | (string | RegExp)[]; export interface KeepAliveProps { include?: MatchPattern; exclude?: MatchPattern; max?: number | string; } export declare const KeepAlive: { new (): { $props: VNodeProps & KeepAliveProps; $slots: { default(): VNode[]; }; }; __isKeepAlive: true; }; export declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void; export declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void; export declare const onBeforeMount: (hook: () => any, target?: ComponentInternalInstance | null) => 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>; 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>[]; type PropConstructor<T = any> = { new (...args: any[]): T & {}; } | { (): T; } | PropMethod<T>; type PropMethod<T, TConstructor = any> = [T] extends [ ((...args: any) => any) | undefined ] ? { new (): TConstructor; (): T; readonly prototype: TConstructor; } : never; type RequiredKeys<T> = { [K in keyof T]: T[K] extends { required: true; } | { default: any; } | BooleanConstructor | { type: BooleanConstructor; } ? T[K] extends { default: undefined | (() => undefined); } ? never : K : never; }[keyof T]; type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>; type DefaultKeys<T> = { [K in keyof T]: T[K] extends { default: any; } | BooleanConstructor | { type: BooleanConstructor; } ? T[K] extends { type: BooleanConstructor; required: true; } ? never : K : never; }[keyof T]; type InferPropType<T> = [T] extends [null] ? any : [T] extends [{ type: null | true; }] ? any : [T] extends [ObjectConstructor | { type: ObjectConstructor; }] ? Record<string, any> : [T] extends [BooleanConstructor | { type: BooleanConstructor; }] ? boolean : [T] extends [DateConstructor | { type: DateConstructor; }] ? Date : [T] extends [(infer U)[] | { type: (infer U)[]; }] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T; /** * Extract prop types from a runtime props options object. * The extracted types are **internal** - i.e. the resolved props received by * the component. * - Boolean props are always present * - Props with default values are always present * * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}. */ export type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]>; } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>; }; type PublicRequiredKeys<T> = { [K in keyof T]: T[K] extends { required: true; } ? K : never; }[keyof T]; type PublicOptionalKeys<T> = Exclude<keyof T, PublicRequiredKeys<T>>; /** * Extract prop types from a runtime props options object. * The extracted types are **public** - i.e. the expected props that can be * passed to component. */ export type ExtractPublicPropTypes<O> = { [K in keyof Pick<O, PublicRequiredKeys<O>>]: InferPropType<O[K]>; } & { [K in keyof Pick<O, PublicOptionalKeys<O>>]?: InferPropType<O[K]>; }; declare const enum BooleanFlags { shouldCast = 0, shouldCastTrue = 1 } export type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>; } : {}; type NormalizedProp = null | (PropOptions & { [BooleanFlags.shouldCast]?: boolean; [BooleanFlags.shouldCastTrue]?: boolean; }); type NormalizedProps = Record<string, NormalizedProp>; type NormalizedPropsOptions = [NormalizedProps, string[]] | []; /** Runtime helper for applying directives to a vnode. Example usage: const comp = resolveComponent('comp') const foo = resolveDirective('foo') const bar = resolveDirective('bar') return withDirectives(h(comp), [ [foo, this.x], [bar, this.y] ]) */ export interface DirectiveBinding<V = any> { instance: ComponentPublicInstance | null; value: V; oldValue: V | null; arg?: string; modifiers: DirectiveModifiers; 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; 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>; mounted?: DirectiveHook<T, null, V>; beforeUpdate?: DirectiveHook<T, VNode<any, T>, V>; updated?: DirectiveHook<T, VNode<any, T>, V>; beforeUnmount?: DirectiveHook<T, null, V>; unmounted?: DirectiveHook<T, null, V>; getSSRProps?: SSRDirectiveHook; deep?: boolean; } export type FunctionDirective<T = any, V = any> = DirectiveHook<T, any, V>; export type Directive<T = any, V = any> = ObjectDirective<T, V> | FunctionDirective<T, V>; 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. */ export declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T; export declare const enum DeprecationTypes { GLOBAL_MOUNT = "GLOBAL_MOUNT", GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER", GLOBAL_EXTEND = "GLOBAL_EXTEND", GLOBAL_PROTOTYPE = "GLOBAL_PROTOTYPE", GLOBAL_SET = "GLOBAL_SET", GLOBAL_DELETE = "GLOBAL_DELETE", GLOBAL_OBSERVABLE = "GLOBAL_OBSERVABLE", GLOBAL_PRIVATE_UTIL = "GLOBAL_PRIVATE_UTIL", CONFIG_SILENT = "CONFIG_SILENT", CONFIG_DEVTOOLS = "CONFIG_DEVTOOLS", CONFIG_KEY_CODES = "CONFIG_KEY_CODES", CONFIG_PRODUCTION_TIP = "CONFIG_PRODUCTION_TIP", CONFIG_IGNORED_ELEMENTS = "CONFIG_IGNORED_ELEMENTS", CONFIG_WHITESPACE = "CONFIG_WHITESPACE", CONFIG_OPTION_MERGE_STRATS = "CONFIG_OPTION_MERGE_STRATS", INSTANCE_SET = "INSTANCE_SET", INSTANCE_DELETE = "INSTANCE_DELETE", INSTANCE_DESTROY = "INSTANCE_DESTROY", INSTANCE_EVENT_EMITTER = "INSTANCE_EVENT_EMITTER", INSTANCE_EVENT_HOOKS = "INSTANCE_EVENT_HOOKS", INSTANCE_CHILDREN = "INSTANCE_CHILDREN", INSTANCE_LISTENERS = "INSTANCE_LISTENERS", INSTANCE_SCOPED_SLOTS = "INSTANCE_SCOPED_SLOTS", INSTANCE_ATTRS_CLASS_STYLE = "INSTANCE_ATTRS_CLASS_STYLE", OPTIONS_DATA_FN = "OPTIONS_DATA_FN", OPTIONS_DATA_MERGE = "OPTIONS_DATA_MERGE", OPTIONS_BEFORE_DESTROY = "OPTIONS_BEFORE_DESTROY", OPTIONS_DESTROYED = "OPTIONS_DESTROYED", WATCH_ARRAY = "WATCH_ARRAY", PROPS_DEFAULT_THIS = "PROPS_DEFAULT_THIS", V_ON_KEYCODE_MODIFIER = "V_ON_KEYCODE_MODIFIER", CUSTOM_DIR = "CUSTOM_DIR", ATTR_FALSE_VALUE = "ATTR_FALSE_VALUE", ATTR_ENUMERATED_COERCION = "ATTR_ENUMERATED_COERCION", TRANSITION_CLASSES = "TRANSITION_CLASSES", TRANSITION_GROUP_ROOT = "TRANSITION_GROUP_ROOT", COMPONENT_ASYNC = "COMPONENT_ASYNC", COMPONENT_FUNCTIONAL = "COMPONENT_FUNCTIONAL", COMPONENT_V_MODEL = "COMPONENT_V_MODEL", RENDER_FUNCTION = "RENDER_FUNCTION", FILTERS = "FILTERS", PRIVATE_APIS = "PRIVATE_APIS" } declare function warnDeprecation(key: DeprecationTypes, instance: ComponentInternalInstance | null, ...args: any[]): void; type CompatConfig = Partial<Record<DeprecationTypes, boolean | 'suppress-warning'>> & { MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3); }; declare function configureCompat(config: CompatConfig): void; declare function isCompatEnabled(key: DeprecationTypes, instance: ComponentInternalInstance | null, enableForBuiltIn?: boolean): boolean; /** * Use this for features where legacy usage is still possible, but will likely * lead to runtime error if compat is disabled. (warn in all cases) */ declare function softAssertCompatEnabled(key: DeprecationTypes, instance: ComponentInternalInstance | null, ...args: any[]): boolean; /** * Use this for features with the same syntax but with mutually exclusive * behavior in 2 vs 3. Only warn if compat is enabled. * e.g. render function */ declare function checkCompatEnabled(key: DeprecationTypes, instance: ComponentInternalInstance | null, ...args: any[]): boolean; /** * Interface for declaring custom options. * * @example * ```ts * declare module '@vue/runtime-core' { * interface ComponentCustomOptions { * beforeRouteUpdate?( * to: Route, * from: Route, * next: () => void * ): void * } * } * ``` */ export interface ComponentCustomOptions { } export type RenderFunction = () => VNodeChild; 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; components?: Record<string, Component>; directives?: Record<string, Directive>; inheritAttrs?: boolean; emits?: (E | EE[]) & ThisType<void>; slots?: S; expose?: string[]; serverPrefetch?(): void | Promise<any>; compilerOptions?: RuntimeCompilerOptions; /* removed internal: ssrRender */ /* removed internal: __ssrInlineRender */ /* removed internal: __asyncLoader */ /* removed internal: __asyncResolved */ call?: (this: unknown, ...args: unknown[]) => never; __isFragment?: never; __isTeleport?: never; __isSuspense?: never; __defaults?: Defaults; } /** * Subset of compiler options that makes sense for the runtime. */ export interface RuntimeCompilerOptions { isCustomElement?: (tag: string) => boolean; whitespace?: 'preserve' | 'condense'; 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, 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, 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, S> & { props: PropNames[]; } & 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, 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; } 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; }; type ObjectWatchOptionItem = { handler: WatchCallback | string; } & WatchOptions; type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem; type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[]; type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>; export type ComponentProvideOptions = ObjectProvideOptions | Function; type ObjectProvideOptions = Record<string | symbol, unknown>; export type ComponentInjectOptions = string[] | ObjectInjectOptions; type ObjectInjectOptions = Record<string | symbol, string | symbol | { from?: string | symbol; default?: unknown; }>; type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown; } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown; } : never; 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; computed?: C; methods?: M; watch?: ComponentWatchOptions; provide?: ComponentProvideOptions; inject?: I | II[]; filters?: Record<string, Function>; mixins?: Mixin[]; extends?: Extends; beforeCreate?(): void; created?(): void; beforeMount?(): void; mounted?(): void; beforeUpdate?(): void; updated?(): void; activated?(): void; deactivated?(): void; /** @deprecated use `beforeUnmount` instead */ beforeDestroy?(): void; beforeUnmount?(): void; /** @deprecated use `unmounted` instead */ destroyed?(): void; unmounted?(): void; renderTracked?: DebuggerHook; renderTriggered?: DebuggerHook; errorCaptured?: ErrorCapturedHook; /** * runtime compile only * @deprecated use `compilerOptions.delimiters` instead. */ delimiters?: [string, string]; /** * #3468 * * type-only, used to assist Mixin's type inference, * typescript will try to simplify the inferred `Mixin` type, * with the `__differentiator`, typescript won't be able to combine different mixins, * because the `__differentiator` will be different */ __differentiator?: keyof D | keyof C | keyof M; } type MergedHook<T = () => void> = T | T[]; type MergedComponentOptions = ComponentOptions & MergedComponentOptionsOverride; type MergedComponentOptionsOverride = { beforeCreate?: MergedHook; created?: MergedHook; beforeMount?: MergedHook; mounted?: MergedHook; beforeUpdate?: MergedHook; updated?: MergedHook; activated?: MergedHook; deactivated?: MergedHook; /** @deprecated use `beforeUnmount` instead */ beforeDestroy?: MergedHook; beforeUnmount?: MergedHook; /** @deprecated use `unmounted` instead */ destroyed?: MergedHook; unmounted?: MergedHook; renderTracked?: MergedHook<DebuggerHook>; renderTriggered?: MergedHook<DebuggerHook>; errorCaptured?: MergedHook<ErrorCapturedHook>; }; 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; C: C; M: M; Defaults: Defaults; }; export interface InjectionKey<T> extends Symbol { } export declare function provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): void; export declare function inject<T>(key: InjectionKey<T> | string): T | undefined; export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T, treatDefaultAsFactory?: false): T; export declare function inject<T>(key: InjectionKey<T> | string, defaultValue: T | (() => T), treatDefaultAsFactory: true): T; /** * Returns true if `inject()` can be used without warning about being called in the wrong place (e.g. outside of * setup()). This is used by libraries that want to use `inject()` internally without triggering a warning to the end * user. One example is `useRoute()` in `vue-router`. */ export declare function hasInjectionContext(): boolean; export interface App<HostElement = any> { version: string; config: AppConfig; use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: Options): this; use<Options>(plugin: Plugin<Options>, options: Options): this; mixin(mixin: ComponentOptions): this; component(name: string): Component | undefined; component(name: string, component: Component): this; directive(name: string): Directive | undefined; directive(name: string, directive: Directive): this; 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; _container: HostElement | null; _context: AppContext; _instance: ComponentInternalInstance | null; /** * v2 compat only */ filter?(name: string): Function | undefined; filter?(name: string, filter: Function): this; /* removed internal: _createRoot */ } export type OptionMergeFunction = (to: unknown, from: unknown) => any; export interface AppConfig { readonly isNativeTag?: (tag: string) => boolean; performance: boolean; optionMergeStrategies: Record<string, OptionMergeFunction>; globalProperties: ComponentCustomProperties & Record<string, any>; errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void; warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void; /** * Options to pass to `@vue/compiler-dom`. * Only supported in runtime compiler build. */ compilerOptions: RuntimeCompilerOptions; /** * @deprecated use config.compilerOptions.isCustomElement */ isCustomElement?: (tag: string) => boolean; /** * Temporary config for opt-in to unwrap injected refs. * @deprecated this no longer has effect. 3.3 always unwraps injected refs. */ unwrapInjectedRef?: boolean; } export interface AppContext { app: App; config: AppConfig; mixins: ComponentOptions[]; components: Record<string, Component>; directives: Record<string, Directive>; provides: Record<string | symbol, any>; /* removed internal: optionsCache */ /* removed internal: propsCache */ /* removed internal: emitsCache */ /* removed internal: reload */ /* removed internal: filters */ } 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>; }) | { install: PluginInstallFunction<Options>; }; export type CreateAppFunction<HostElement> = (rootComponent: Component, rootProps?: Data | null) => App<HostElement>; type Hook<T = () => void> = T | T[]; export interface BaseTransitionProps<HostElement = RendererElement> { mode?: 'in-out' | 'out-in' | 'default'; appear?: boolean; persisted?: boolean; onBeforeEnter?: Hook<(el: HostElement) => void>; onEnter?: Hook<(el: HostElement, done: () => void) => void>; onAfterEnter?: Hook<(el: HostElement) => void>; onEnterCancelled?: Hook<(el: HostElement) => void>; onBeforeLeave?: Hook<(el: HostElement) => void>; onLeave?: Hook<(el: HostElement, done: () => void) => void>; onAfterLeave?: Hook<(el: HostElement) => void>; onLeaveCancelled?: Hook<(el: HostElement) => void>; onBeforeAppear?: Hook<(el: HostElement) => void>; onAppear?: Hook<(el: HostElement, done: () => void) => void>; onAfterAppear?: Hook<(el: HostElement) => void>; onAppearCancelled?: Hook<(el: HostElement) => void>; } export interface TransitionHooks<HostElement = RendererElement> { mode: BaseTransitionProps['mode']; persisted: boolean; beforeEnter(el: HostElement): void; enter(el: HostElement): void; leave(el: HostElement, remove: () => void): void; clone(vnode: VNode): TransitionHooks<HostElement>; afterLeave?(): void; delayLeave?(el: HostElement, earlyRemove: () => void, delayedLeave: () => void): void; delayedLeave?(): void; } export interface TransitionState { isMounted: boolean; isLeaving: boolean; isUnmounting: boolean; leavingVNodes: Map<any, Record<string, VNode>>; } export declare function useTransitionState(): TransitionState; export declare const BaseTransitionPropsValidators: { mode: StringConstructor; appear: BooleanConstructor; persisted: BooleanConstructor; onBeforeEnter: (ArrayConstructor | FunctionConstructor)[]; onEnter: (ArrayConstructor | FunctionConstructor)[]; onAfterEnter: (ArrayConstructor | FunctionConstructor)[]; onEnterCancelled: (ArrayConstructor | FunctionConstructor)[]; onBeforeLeave: (ArrayConstructor | FunctionConstructor)[]; onLeave: (ArrayConstructor | FunctionConstructor)[]; onAfterLeave: (ArrayConstructor | FunctionConstructor)[]; onLeaveCancelled: (ArrayConstructor | FunctionConstructor)[]; onBeforeAppear: (ArrayConstructor | FunctionConstructor)[]; onAppear: (ArrayConstructor | FunctionConstructor)[]; onAfterAppear: (ArrayConstructor | FunctionConstructor)[]; onAppearCancelled: (ArrayConstructor | FunctionConstructor)[]; }; export declare const BaseTransition: new () => { $props: BaseTransitionProps<any>; $slots: { default(): VNode[]; }; }; export declare 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[]; type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>; export interface TeleportProps { to: string | RendererElement | null | undefined; disabled?: boolean; } declare const TeleportImpl: { __isTeleport: boolean; process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void; remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, optimized: boolean, { um: unmount, o: { remove: hostRemove } }: RendererInternals, doRemove: Boolean): void; move: typeof moveTeleport; hydrate: typeof hydrateTeleport; }; declare const enum TeleportMoveTypes { TARGET_CHANGE = 0, TOGGLE = 1, REORDER = 2 } 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; export declare const Teleport: { new (): { $props: VNodeProps & TeleportProps; $slots: { default(): VNode[]; }; }; __isTeleport: true; }; /** * @private */ export declare function resolveComponent(name: string, maybeSelfReference?: boolean): ConcreteComponent | string; declare const NULL_DYNAMIC_COMPONENT: unique symbol; /** * @private */ export declare function resolveDynamicComponent(component: unknown): VNodeTypes; /** * @private */ export declare function resolveDirective(name: string): Directive | undefined; /* removed internal: resolveFilter$1 */ export declare const Fragment: { new (): { $props: VNodeProps; }; __isFragment: true; }; 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); type VNodeNormalizedRefAtom = { i: ComponentInternalInstance; r: VNodeRef; k?: string; f?: boolean; }; 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; ref_for?: boolean; ref_key?: string; onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[]; onVnodeMounted?: VNodeMountHook | VNodeMountHook[]; onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[]; onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[]; onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[]; onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[]; }; 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; export interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = { [key: string]: any; }> { /* removed internal: __v_isVNode */ type: VNodeTypes; props: (VNodeProps & ExtraProps) | null; key: string | number | symbol | null; ref: VNodeNormalizedRef | null; /** * SFC only. This is assigned on vnode creation using currentScopeId * which is set alongside currentRenderingInstance. */ scopeId: string | null; /* removed internal: slotScopeIds */ children: VNodeNormalizedChildren; component: ComponentInternalInstance | null; dirs: DirectiveBinding[] | null; transition: TransitionHooks<HostElement> | null; el: HostNode | null; anchor: HostNode | null; target: HostElement | null; targetAnchor: HostNode | null; /* removed internal: staticCount */ suspense: SuspenseBoundary | null; /* removed internal: ssContent */ /* removed internal: ssFallback */ shapeFlag: number; patchFlag: number; /* removed internal: dynamicProps */ /* removed internal: dynamicChildren */ appContext: AppContext | null; /* removed internal: ctx */ /* removed internal: memo */ /* removed internal: isCompatRoot */ /* removed internal: ce */ } /** * Open a block. * This must be called before `createBlock`. It cannot be part of `createBlock` * because the children of the block are evaluated before `createBlock` itself * is called. The generated code typically looks like this: * * ```js * function render() { * return (openBlock(),createBlock('div', null, [...])) * } * ``` * disableTracking is true when creating a v-for fragment block, since a v-for * fragment always diffs its children. * * @private */ 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 * code like this: * * ``` js * _cache[1] || ( * setBlockTracking(-1), * _cache[1] = createVNode(...), * setBlockTracking(1), * _cache[1] * ) * ``` * * @private */ export declare function setBlockTracking(value: number): void; /** * @private */ export declare function createElementBlock(type: string | typeof Fragment, props?: Record<string, any> | null, children?: any, patchFlag?: number, dynamicProps?: string[], shapeFlag?: number): VNode<RendererNode, RendererElement, { [key: string]: any; }>; /** * Create a block root vnode. Takes the same exact arguments as `createVNode`. * A block root keeps track of dynamic nodes within the block in the * `dynamicChildren` array. * * @private */ 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 * used for creating stubs in the test-utils * It is *internal* but needs to be exposed for test-utils to pick up proper * typings */ export declare function transformVNodeArgs(transformer?: typeof vnodeArgsTransformer): void; export declare function createBaseVNode(type: VNodeTypes | ClassComponent | typeof NULL_DYNAMIC_COMPONENT, props?: (Data & VNodeProps) | null, children?: unknown, patchFlag?: number, dynamicProps?: string[] | null, shapeFlag?: number, isBlockNode?: boolean, needFullChildrenNormalization?: boolean): VNode<RendererNode, RendererElement, { [key: string]: any; }>; export declare 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; 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 */ export declare function createTextVNode(text?: string, flag?: number): VNode; /** * @private */ export declare function createStaticVNode(content: string, numberOfNodes: number): VNode; /** * @private */ export declare function createCommentVNode(text?: string, asBlock?: boolean): VNode; declare function normalizeVNode(child: VNodeChild): VNode; export declare function mergeProps(...args: (Data & VNodeProps)[]): Data; type Data = Record<string, unknown>; /** * For extending allowed non-declared props on components in TSX */ export interface ComponentCustomProps { } /** * Default allowed non-declared props on component in TSX */ export interface AllowedComponentProps { class?: unknown; style?: unknown; } interface ComponentInternalOptions { /* removed internal: __scopeId */ /* removed internal: __cssModules */ /* removed internal: __hmrId */ /** * Compat build only, for bailing out of certain compatibility behavior */ __isBuiltIn?: boolean; /** * This one should be exposed so that devtools can make use of it */ __file?: string; /** * name inferred from filename */ __name?: string; } export interface FunctionalComponent<P = {}, E extends EmitsOptions = {}, S extends Record<string, any> = any> extends ComponentInternalOptions { (props: P, ctx: Omit<SetupContext<E, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any; props?: ComponentPropsOptions<P>; emits?: E | (keyof E)[]; slots?: IfAny<S, Slots, SlotsType<S>>; inheritAttrs?: boolean; displayName?: string; compatConfig?: CompatConfig; } interface ClassComponent { new (...args: any[]): ComponentPublicInstance<any, any, any, any, any>; __vccOpts: ComponentOptions; } /** * Concrete component type matches its actual value: it's either an options * object, or a function. Use this where the code expects to work with actual * 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, 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>; type LifecycleHook<TFn = Function> = TFn[] | null; export type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? { attrs: Data; slots: UnwrapSlotsType<S>; emit: EmitFn<E>; expose: (exposed?: Record<string, any>) => void; } : never; /* removed internal: InternalRenderFunction */ /** * We expose a subset of properties on the internal instance as they are * useful for advanced external libraries and tools. */ export interface ComponentInternalInstance { uid: number; type: ConcreteComponent; parent: ComponentInternalInstance | null; root: ComponentInternalInstance; appContext: AppContext; /** * Vnode representing this component in its parent's vdom tree */ vnode: VNode; /* removed internal: next */ /** * Root vnode of this component's own vdom tree */ subTree: VNode; /** * Render effect instance */ effect: ReactiveEffect; /** * Bound effect runner to be passed to schedulers */ update: SchedulerJob; /* removed internal: render */ /* removed internal: ssrRender */ /* removed internal: provides */ /* removed internal: scope */ /* removed internal: accessCache */ /* removed internal: renderCache */ /* removed internal: components */ /* removed internal: directives */ /* removed internal: filters */ /* removed internal: propsOptions */ /* removed internal: emitsOptions */ /* removed internal: inheritAttrs */ /* removed internal: isCE */ /* removed internal: ceReload */ proxy: ComponentPublicInstance | null; exposed: Record<string, any> | null; exposeProxy: Record<string, any> | null; /* removed internal: withProxy */ /* removed internal: ctx */ data: Data; props: Data; attrs: Data; slots: InternalSlots; refs: Data; emit: EmitFn; attrsProxy: Data | null; slotsProxy: Slots | null; /* removed internal: emitted */ /* removed internal: propsDefaults */ /* removed internal: setupState */ /* removed internal: devtoolsRawSetupState */ /* removed internal: setupContext */ /* removed internal: suspense */ /* removed internal: suspenseId */ /* removed internal: asyncDep */ /* removed internal: asyncResolved */ isMounted: boolean; isUnmounted: boolean; isDeactivated: boolean; /* removed internal: f */ /* removed internal: n */ /* removed internal: ut */ } declare function createComponentInstance(vnode: VNode, parent: ComponentInternalInstance | null, suspense: SuspenseBoundary | null): ComponentInternalInstance; 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. */ 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; 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; }; type OnCleanup = (cleanupFn: () => void) => void; export interface WatchOptionsBase extends DebuggerOptions { flush?: 'pre' | 'post' | 'sync'; } export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase { immediate?: Immediate; deep?: boolean; } export type WatchStopHandle = () => void; 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; 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; }>>(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>; type AsyncComponentResolveResult<T = Component> = T | { default: T; }; export type AsyncComponentLoader<T = any> = () => Promise<AsyncComponentResolveResult<T>>; export interface AsyncComponentOptions<T = any> { loader: AsyncComponentLoader<T>; loadingComponent?: Component; errorComponent?: Component; delay?: number; timeout?: number; suspensible?: boolean; onError?: (error: Error, retry: () => void, fail: () => void, attempts: number) => any; } export declare function defineAsyncComponent<T extends Component = { new (): ComponentPublicInstance; }>(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>): T; /** * Vue `<script setup>` compiler macro for declaring component props. The * expected argument is the same as the component `props` option. * * Example runtime declaration: * ```js * // using Array syntax * const props = defineProps(['foo', 'bar']) * // using Object syntax * const props = defineProps({ * foo: String, * bar: { * type: Number, * required: true * } * }) * ``` * * Equivalent type-based declaration: * ```ts * // will be compiled into equivalent runtime declarations * const props = defineProps<{ * 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. */ export declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{ [key in PropNames]?: any; }>>; export declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>; export declare function defineProps<TypeProps>(): DefineProps<TypeProps, BooleanKey<TypeProps>>; type DefineProps<T, BKeys extends keyof T> = Readonly<T> & { readonly [K in BKeys]-?: boolean; }; type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never; /** * Vue `<script setup>` compiler macro for declaring a component's emitted * events. The expected argument is the same as the component `emits` option. * * Example runtime declaration: * ```js * const emit = defineEmits(['change', 'update']) * ``` * * Example type-based declaration: * ```ts * const emit = defineEmits<{ * (event: 'change'): void * (event: 'update', id: number): void * }>() * * emit('change') * emit('update', 1) * ``` * * 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} */ 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 * refs. * * `<script setup>` components are closed by default - i.e. variables inside * the `<script setup>` scope is not exposed to parent unless explicitly exposed * via `defineExpose`. * * 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} */ 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. `inheritAttrs`. * * @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>>(): StrictUnwrapSlotsType<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, T[K]>; }; type NativeType = null | number | string | boolean | symbol | Function; type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never); type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = Omit<T, keyof Defaults> & { [K in keyof Defaults]-?: K extends keyof T ? Defaults[K] extends undefined ? T[K] : NotUndefined<T[K]> : never; } & { readonly [K in BKeys]-?: boolean; }; /** * Vue `<script setup>` compiler macro for providing props default values when * using type-based `defineProps` declaration. * * Example usage: * ```ts * withDefaults(defineProps<{ * size?: number * labels?: string[] * }>(), { * size: 3, * labels: () => ['default label'] * }) * ``` * * 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} */ export declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>; export declare function useSlots(): SetupContext['slots']; export declare function useAttrs(): SetupContext['attrs']; export declare function useModel<T extends Record<string, any>, K extends keyof T>(props: T, name: K, options?: { local?: boolean; }): Ref<T[K]>; /* removed internal: mergeDefaults */ /* removed internal: mergeModels */ /* removed internal: createPropsRestProxy */ /* removed internal: withAsyncContext */ type RawProps = VNodeProps & { __v_isVNode?: never; [Symbol.iterator]?: never; } & Record<string, any>; type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any); interface Constructor<P = any> { __isFragment?: never; __isTeleport?: never; __isSuspense?: never; new (...args: any[]): { $props: P; }; } 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; export declare const ssrContextKey: unique symbol; export declare const useSSRContext: <T = Record<string, any>>() => T | undefined; export declare function warn(msg: string, ...args: any[]): void; /* removed internal: assertNumber */ export declare const enum ErrorCodes { SETUP_FUNCTION = 0, RENDER_FUNCTION = 1, WATCH_GETTER = 2, WATCH_CALLBACK = 3, WATCH_CLEANUP = 4, NATIVE_EVENT_HANDLER = 5, COMPONENT_EVENT_HANDLER = 6, VNODE_HOOK = 7, DIRECTIVE_HOOK = 8, TRANSITION_HOOK = 9, APP_ERROR_HANDLER = 10, APP_WARN_HANDLER = 11, FUNCTION_REF = 12, ASYNC_COMPONENT_LOADER = 13, SCHEDULER = 14 } 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; export declare function initCustomFormatter(): void; interface AppRecord { id: number; app: App; version: string; types: Record<string, string | Symbol>; } interface DevtoolsHook { enabled?: boolean; emit: (event: string, ...payload: any[]) => void; on: (event: string, handler: Function) => void; once: (event: string, handler: Function) => void; off: (event: string, handler: Function) => void; appRecords: AppRecord[]; /** * Added at https://github.com/vuejs/devtools/commit/f2ad51eea789006ab66942e5a27c0f0986a257f9 * Returns wether the arg was buffered or not */ cleanupBuffer?: (matchArg: unknown) => boolean; } export declare let devtools: DevtoolsHook; export declare function setDevtoolsHook(hook: DevtoolsHook, target: any): void; type HMRComponent = ComponentOptions | ClassComponent; export interface HMRRuntime { createRecord: typeof createRecord; rerender: typeof rerender; reload: typeof reload; } declare function createRecord(id: string, initialDef: HMRComponent): boolean; declare function rerender(id: string, newRender?: Function): void; declare function reload(id: string, newComp: HMRComponent): void; /** * Note: rendering calls maybe nested. The function returns the parent rendering * instance if present, which should be restored after the render is done: * * ```js * const prev = setCurrentRenderingInstance(i) * // ...render * setCurrentRenderingInstance(prev) * ``` */ declare function setCurrentRenderingInstance(instance: ComponentInternalInstance | null): ComponentInternalInstance | null; /** * Set scope id when creating hoisted vnodes. * @private compiler helper */ 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 */ export declare function popScopeId(): void; /** * Only for backwards compat * @private */ export declare const withScopeId: (_id: string) => typeof withCtx; /** * Wrap a slot function to memoize current rendering instance * @private compiler helper */ export declare function withCtx(fn: Function, ctx?: ComponentInternalInstance | null, isNonScopedSlot?: boolean): Function; /** * v-for string * @private */ export declare function renderList(source: string, renderItem: (value: string, index: number) => VNodeChild): VNodeChild[]; /** * v-for number */ export declare function renderList(source: number, renderItem: (value: number, index: number) => VNodeChild): VNodeChild[]; /** * v-for array */ export declare function renderList<T>(source: T[], renderItem: (value: T, index: number) => VNodeChild): VNodeChild[]; /** * v-for iterable */ export declare function renderList<T>(source: Iterable<T>, renderItem: (value: T, index: number) => VNodeChild): VNodeChild[]; /** * v-for object */ 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 */ export declare function toHandlers(obj: Record<string, any>, preserveCaseIfNecessary?: boolean): Record<string, any>; /** * Compiler runtime helper for rendering `<slot/>` * @private */ export declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode; type SSRSlot = (...args: any[]) => VNode[] | undefined; interface CompiledSlotDescriptor { name: string; fn: SSRSlot; key?: string; } /** * Compiler runtime helper for creating dynamic slots object * @private */ export declare function createSlots(slots: Record<string, SSRSlot>, dynamicSlots: (CompiledSlotDescriptor | CompiledSlotDescriptor[] | undefined)[]): Record<string, SSRSlot>; export declare function withMemo(memo: any[], render: () => VNode<any, any>, cache: any[], index: number): VNode<any, any, { [key: string]: any; }>; export declare function isMemoSame(cached: VNode, memo: any[]): boolean; declare function renderComponentRoot(instance: ComponentInternalInstance): VNode; export type LegacyConfig = { /** * @deprecated `config.silent` option has been removed */ silent?: boolean; /** * @deprecated use __VUE_PROD_DEVTOOLS__ compile-time feature flag instead * https://github.com/vuejs/core/tree/main/packages/vue#bundler-build-feature-flags */ devtools?: boolean; /** * @deprecated use `config.isCustomElement` instead * https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-ignoredelements-is-now-config-iscustomelement */ ignoredElements?: (string | RegExp)[]; /** * @deprecated * https://v3-migration.vuejs.org/breaking-changes/keycode-modifiers.html */ keyCodes?: Record<string, number | number[]>; /** * @deprecated * https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-productiontip-removed */ productionTip?: boolean; }; 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; $destroy(): void; $scopedSlots: Slots; $on(event: string | string[], fn: Function): this; $once(event: string, fn: Function): this; $off(event?: string | string[], fn?: Function): this; $children: LegacyPublicProperties[]; $listeners: Record<string, Function | Function[]>; } /** * @deprecated the default `Vue` export has been removed in Vue 3. The type for * the default export is provided only for migration purposes. Please use * named imports instead - e.g. `import { createApp } from 'vue'`. */ export type CompatVue = Pick<App, 'version' | 'component' | 'directive'> & { configureCompat: typeof configureCompat; new (options?: ComponentOptions): LegacyPublicInstance; version: string; config: AppConfig & LegacyConfig; nextTick: typeof nextTick; use(plugin: Plugin, ...options: any[]): CompatVue; mixin(mixin: ComponentOptions): CompatVue; component(name: string): Component | undefined; component(name: string, component: Component): CompatVue; directive(name: string): Directive | undefined; directive(name: string, directive: Directive): CompatVue; compile(template: string): RenderFunction; /** * @deprecated Vue 3 no longer supports extending constructors. */ extend: (options?: ComponentOptions) => CompatVue; /** * @deprecated Vue 3 no longer needs set() for adding new properties. */ set(target: any, key: string | number | symbol, value: any): void; /** * @deprecated Vue 3 no longer needs delete() for property deletions. */ delete(target: any, key: string | number | symbol): void; /** * @deprecated use `reactive` instead. */ observable: typeof reactive; /** * @deprecated filters have been removed from Vue 3. */ filter(name: string, arg?: any): null; /* removed internal: cid */ /* removed internal: options */ /* removed internal: util */ /* removed internal: super */ }; declare function createCompatVue(createApp: CreateAppFunction<Element>, createSingletonApp: CreateAppFunction<Element>): CompatVue; export declare const version: string; declare module '@vue/reactivity' { interface RefUnwrapBailTypes { runtimeCoreBailTypes: VNode | { $: ComponentInternalInstance; }; } } 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 }