@vue/compat 3.6.0-beta.4 → 3.6.0-beta.6

package/dist/vue-compat.d.ts

@@ -1,5 +1,2024 @@
-import { CompatVue } from '@vue/runtime-dom';
-
+//#region packages/shared/src/slotFlags.d.ts
+declare enum SlotFlags {
+  /**
+  * Stable slots that only reference slot props or context state. The slot
+  * can fully capture its own dependencies so when passed down the parent won't
+  * need to force the child to update.
+  */
+  STABLE = 1,
+  /**
+  * Slots that reference scope variables (v-for or an outer slot prop), or
+  * has conditional structure (v-if, v-for). The parent will need to force
+  * the child to update because the slot does not fully capture its dependencies.
+  */
+  DYNAMIC = 2,
+  /**
+  * `<slot/>` being forwarded into a child component. Whether the parent needs
+  * to update the child is dependent on what kind of slots the parent itself
+  * received. This has to be refined at runtime, when the child's vnode
+  * is being created (in `normalizeChildren`)
+  */
+  FORWARDED = 3
+}
+//#endregion
+//#region packages/shared/src/typeUtils.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+//#endregion
+//#region packages/reactivity/src/constants.d.ts
+declare enum TrackOpTypes {
+  GET = "get",
+  HAS = "has",
+  ITERATE = "iterate"
+}
+declare enum TriggerOpTypes {
+  SET = "set",
+  ADD = "add",
+  DELETE = "delete",
+  CLEAR = "clear"
+}
+declare enum ReactiveFlags$1 {
+  SKIP = "__v_skip",
+  IS_REACTIVE = "__v_isReactive",
+  IS_READONLY = "__v_isReadonly",
+  IS_SHALLOW = "__v_isShallow",
+  RAW = "__v_raw",
+  IS_REF = "__v_isRef"
+}
+//#endregion
+//#region packages/reactivity/src/effectScope.d.ts
+declare class EffectScope implements ReactiveNode {
+  deps: Link | undefined;
+  depsTail: Link | undefined;
+  subs: Link | undefined;
+  subsTail: Link | undefined;
+  flags: number;
+  /**
+  * @internal
+  */
+  cleanups: (() => void)[];
+  /**
+  * @internal
+  */
+  cleanupsLength: number;
+  constructor(detached?: boolean);
+  get active(): boolean;
+  pause(): void;
+  /**
+  * Resumes the effect scope, including all child scopes and effects.
+  */
+  resume(): void;
+  run<T>(fn: () => T): T | undefined;
+  stop(): void;
+  /**
+  * @internal
+  */
+  reset(): void;
+}
+//#endregion
+//#region packages/reactivity/src/system.d.ts
+interface ReactiveNode {
+  deps?: Link;
+  depsTail?: Link;
+  subs?: Link;
+  subsTail?: Link;
+  flags: ReactiveFlags;
+}
+interface Link {
+  version: number;
+  dep: ReactiveNode | ComputedRefImpl | ReactiveEffect | EffectScope;
+  sub: ReactiveNode | ComputedRefImpl | ReactiveEffect | EffectScope;
+  prevSub: Link | undefined;
+  nextSub: Link | undefined;
+  prevDep: Link | undefined;
+  nextDep: Link | undefined;
+}
+declare const enum ReactiveFlags {
+  None = 0,
+  Mutable = 1,
+  Watching = 2,
+  RecursedCheck = 4,
+  Recursed = 8,
+  Dirty = 16,
+  Pending = 32
+}
+//#endregion
+//#region packages/reactivity/src/effect.d.ts
+type EffectScheduler = (...args: any[]) => any;
+type DebuggerEvent = {
+  effect: ReactiveNode;
+} & DebuggerEventExtraInfo;
+type DebuggerEventExtraInfo = {
+  target: object;
+  type: TrackOpTypes | TriggerOpTypes;
+  key: any;
+  newValue?: any;
+  oldValue?: any;
+  oldTarget?: Map<any, any> | Set<any>;
+};
+interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+}
+interface ReactiveEffectOptions extends DebuggerOptions {
+  scheduler?: EffectScheduler;
+  onStop?: () => void;
+}
+declare class ReactiveEffect<T = any> implements ReactiveEffectOptions, ReactiveNode {
+  deps: Link | undefined;
+  depsTail: Link | undefined;
+  subs: Link | undefined;
+  subsTail: Link | undefined;
+  flags: number;
+  /**
+  * @internal
+  */
+  cleanups: (() => void)[];
+  /**
+  * @internal
+  */
+  cleanupsLength: number;
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+  fn(): T;
+  constructor(fn?: () => T);
+  get active(): boolean;
+  pause(): void;
+  resume(): void;
+  notify(): void;
+  run(): T;
+  stop(): void;
+  get dirty(): boolean;
+}
+//#endregion
+//#region packages/reactivity/src/computed.d.ts
+type ComputedGetter<T> = (oldValue?: T) => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T, S = T> {
+  get: ComputedGetter<T>;
+  set: ComputedSetter<S>;
+}
+/**
+* @private exported by @vue/reactivity for Vue core use, but not exported from
+* the main vue package
+*/
+declare class ComputedRefImpl<T = any> implements ReactiveNode {
+  fn: ComputedGetter<T>;
+  private readonly setter;
+  /**
+  * @internal
+  */
+  _value: T | undefined;
+  subs: Link | undefined;
+  subsTail: Link | undefined;
+  deps: Link | undefined;
+  depsTail: Link | undefined;
+  flags: ReactiveFlags;
+  /**
+  * @internal
+  */
+  readonly __v_isRef: true;
+  /**
+  * @internal
+  */
+  readonly __v_isReadonly: boolean;
+  get effect(): this;
+  get dep(): ReactiveNode;
+  /**
+  * @internal
+  * for backwards compat
+  */
+  get _dirty(): boolean;
+  /**
+  * @internal
+  * for backwards compat
+  */
+  set _dirty(v: boolean);
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+  constructor(fn: ComputedGetter<T>, setter: ComputedSetter<T> | undefined);
+  get value(): T;
+  set value(newValue: T);
+  update(): boolean;
+}
+//#endregion
+//#region packages/reactivity/src/reactive.d.ts
+type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+declare const ReactiveMarkerSymbol: unique symbol;
+interface ReactiveMarker {
+  [ReactiveMarkerSymbol]?: void;
+}
+type Reactive<T> = UnwrapNestedRefs<T> & (T extends readonly any[] ? ReactiveMarker : {});
+/**
+* Returns a reactive proxy of the object.
+*
+* The reactive conversion is "deep": it affects all nested properties. A
+* reactive object also deeply unwraps any properties that are refs while
+* maintaining reactivity.
+*
+* @example
+* ```js
+* const obj = reactive({ count: 0 })
+* ```
+*
+* @param target - The source object.
+* @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
+*/
+declare function reactive<T extends object>(target: T): Reactive<T>;
+declare const ShallowReactiveMarker: unique symbol;
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type Builtin = Primitive | Function | Date | Error | RegExp;
+//#endregion
+//#region packages/reactivity/src/ref.d.ts
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+interface Ref<T = any, S = T> {
+  get value(): T;
+  set value(_: S);
+  /**
+  * Type differentiator only.
+  * We need this to be in public d.ts but don't want it to show up in IDE
+  * autocomplete, so we use a private Symbol instead.
+  */
+  [RefSymbol]: true;
+}
+declare const ShallowRefMarker: unique symbol;
+type ShallowRef<T = any, S = T> = Ref<T, S> & {
+  [ShallowRefMarker]?: true;
+};
+/**
+* This is a special exported interface for other packages to declare
+* additional types that should bail out for ref unwrapping. For example
+* \@vue/runtime-dom can declare it like so in its d.ts:
+*
+* ``` ts
+* declare module '@vue/reactivity' {
+*   export interface RefUnwrapBailTypes {
+*     runtimeDOMBailTypes: Node | Window
+*   }
+* }
+* ```
+*/
+interface RefUnwrapBailTypes {}
+type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
+type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
+type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+  [RawSymbol]?: true;
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
+  [ShallowReactiveMarker]?: never;
+} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
+//#endregion
+//#region packages/reactivity/src/watch.d.ts
+type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
+type OnCleanup = (cleanupFn: () => void) => void;
+type WatchStopHandle = () => void;
+//#endregion
+//#region packages/runtime-core/src/componentSlots.d.ts
+type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
+type InternalSlots = {
+  [name: string]: Slot | undefined;
+};
+type Slots = Readonly<InternalSlots>;
+declare const SlotSymbol: unique symbol;
+type SlotsType<T extends Record<string, any> = Record<string, any>> = {
+  [SlotSymbol]?: 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;
+  /**
+  * for tracking slot owner instance. This is attached during
+  * normalizeChildren when the component vnode is created.
+  * @internal
+  */
+  _ctx?: ComponentInternalInstance | null;
+  /**
+  * indicates compiler generated slots
+  * we use a reserved property instead of a vnode patchFlag because the slots
+  * object may be directly passed down to a child component in a manual
+  * render function, and the optimization hint need to be on the slot object
+  * itself to be preserved.
+  * @internal
+  */
+  _?: SlotFlags;
+};
+//#endregion
+//#region packages/runtime-core/src/scheduler.d.ts
+declare enum SchedulerJobFlags {
+  QUEUED = 1,
+  /**
+  * 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).
+  */
+  ALLOW_RECURSE = 2,
+  DISPOSED = 4
+}
+interface SchedulerJob extends Function {
+  order?: number;
+  /**
+  * flags can technically be undefined, but it can still be used in bitwise
+  * operations just like 0.
+  */
+  flags?: SchedulerJobFlags;
+  /**
+  * Attached by renderer.ts when setting up a component's render effect
+  * Used to obtain component information when reporting max recursive updates.
+  */
+  i?: GenericComponentInstance;
+}
+declare function nextTick(): Promise<void>;
+declare function nextTick<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promise<R>;
+//#endregion
+//#region packages/runtime-core/src/componentProps.d.ts
+type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
+type ComponentObjectPropsOptions<P = Data> = { [K in keyof P]: Prop<P[K]> | null };
+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, props: Data): boolean;
+  /**
+  * @internal
+  */
+  skipCheck?: boolean;
+  /**
+  * @internal
+  */
+  skipFactory?: boolean;
+}
+type PropType<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
+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, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [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, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : 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}.
+*/
+type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
+  default: any;
+} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
+declare enum BooleanFlags {
+  shouldCast = 0,
+  shouldCastTrue = 1
+}
+type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> } : {};
+type NormalizedProp = PropOptions & {
+  [BooleanFlags.shouldCast]?: boolean;
+  [BooleanFlags.shouldCastTrue]?: boolean;
+};
+/**
+* normalized value is a tuple of the actual normalized options
+* and an array of prop keys that need value casting (booleans and defaults)
+*/
+type NormalizedProps = Record<string, NormalizedProp>;
+type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
+//#endregion
+//#region packages/runtime-core/src/apiSetupHelpers.d.ts
+type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
+//#endregion
+//#region packages/runtime-core/src/componentEmits.d.ts
+type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
+type EmitsOptions = ObjectEmitsOptions | string[];
+type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any } : {};
+type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any } : E;
+type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void }[Event]>;
+//#endregion
+//#region packages/runtime-core/src/directives.d.ts
+interface DirectiveBinding<Value = any, Modifiers extends string = string, Arg = any> {
+  instance: ComponentPublicInstance | Record<string, any> | null;
+  value: Value;
+  oldValue: Value | null;
+  arg?: Arg;
+  modifiers: DirectiveModifiers<Modifiers>;
+  dir: ObjectDirective<any, Value, Modifiers, Arg>;
+}
+type DirectiveHook<HostElement = any, Prev = VNode<any, HostElement> | null, Value = any, Modifiers extends string = string, Arg = any> = (el: HostElement, binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode<any, HostElement>, prevVNode: Prev) => void;
+type SSRDirectiveHook<Value = any, Modifiers extends string = string, Arg = any> = (binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode) => Data | undefined;
+interface ObjectDirective<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> {
+  /**
+  * @internal without this, ts-expect-error in directives.test-d.ts somehow
+  * fails when running tsc, but passes in IDE and when testing against built
+  * dts. Could be a TS bug.
+  */
+  __mod?: Modifiers;
+  created?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  beforeMount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  mounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  beforeUpdate?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
+  updated?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
+  beforeUnmount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  unmounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  getSSRProps?: SSRDirectiveHook<Value, Modifiers, Arg>;
+  deep?: boolean;
+}
+type FunctionDirective<HostElement = any, V = any, Modifiers extends string = string, Arg = any> = DirectiveHook<HostElement, any, V, Modifiers, Arg>;
+type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
+type DirectiveModifiers<K extends string = string> = Partial<Record<K, boolean>>;
+//#endregion
+//#region packages/runtime-core/src/componentPublicInstance.d.ts
+/**
+* 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' {
+*   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('/')
+* ```
+*/
+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, any, 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;
+};
+/**
+* This is the same as `CreateComponentPublicInstance` but adds local components,
+* global directives, exposed, and provide inference.
+* It changes the arguments order so that we don't need to repeat mixin
+* inference everywhere internally, but it has to be a new type to avoid
+* breaking types that relies on previous arguments order (#10842)
+*/
+type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, "P"> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, "B"> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, "D"> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, "C"> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, "M"> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, "Defaults"> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
+type ExposedKeys<T, Exposed extends string & keyof T> = "" extends Exposed ? T : Pick<T, Exposed>;
+type ComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = "", TypeRefs extends Data = {}, TypeEl extends Element = any> = {
+  $: ComponentInternalInstance;
+  $data: D;
+  $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
+  $attrs: Data;
+  $refs: Data & TypeRefs;
+  $slots: UnwrapSlotsType<S>;
+  $root: ComponentPublicInstance | null;
+  $parent: ComponentPublicInstance | null;
+  $host: Element | null;
+  $emit: EmitFn<E>;
+  $el: TypeEl;
+  $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, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & ExposedKeys<IfAny<P, P, Readonly<Defaults> & Omit<P, keyof ShallowUnwrapRef<B> | keyof Defaults>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>, Exposed>;
+//#endregion
+//#region packages/runtime-core/src/enums.d.ts
+declare 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"
+}
+//#endregion
+//#region packages/runtime-core/src/components/Suspense.d.ts
+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, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
+  hydrate: typeof hydrateSuspense;
+  normalize: typeof normalizeSuspenseChildren;
+};
+declare const Suspense: {
+  __isSuspense: true;
+  new (): {
+    $props: VNodeProps & SuspenseProps;
+    $slots: {
+      default(): VNode[];
+      fallback(): VNode[];
+    };
+  };
+};
+interface SuspenseBoundary {
+  vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
+  parent: SuspenseBoundary | null;
+  parentComponent: ComponentInternalInstance | null;
+  namespace: ElementNamespace;
+  container: RendererElement;
+  hiddenContainer: RendererElement;
+  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: GenericComponentInstance, onResolve: (setupResult: unknown) => void): void;
+  unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
+}
+declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function normalizeSuspenseChildren(vnode: VNode): void;
+//#endregion
+//#region packages/runtime-core/src/components/BaseTransition.d.ts
+type Hook<T = () => void> = T | T[];
+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>;
+}
+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;
+}
+//#endregion
+//#region packages/runtime-core/src/renderer.d.ts
+type ElementNamespace = "svg" | "mathml" | undefined;
+interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
+  patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, parentComponent?: ComponentInternalInstance | null): void;
+  insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
+  remove(el: HostNode): void;
+  createElement(type: string, namespace?: ElementNamespace, 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, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
+}
+interface RendererNode {
+  [key: string | symbol]: any;
+}
+interface RendererElement extends RendererNode {}
+interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
+  p: PatchFn;
+  um: UnmountFn;
+  r: RemoveFn;
+  m: MoveFn;
+  mt: MountComponentFn;
+  umt: UnmountComponentFn;
+  mc: MountChildrenFn;
+  pc: PatchChildrenFn;
+  pbc: PatchBlockChildrenFn;
+  n: NextFn;
+  o: RendererOptions<HostNode, HostElement>;
+}
+type PatchFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
+type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
+type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
+type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
+type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentComponent: ComponentInternalInstance | null, 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 MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+type UnmountComponentFn = (instance: ComponentInternalInstance, parentSuspense: SuspenseBoundary | null, doRemove?: boolean) => void;
+declare enum MoveType {
+  ENTER = 0,
+  LEAVE = 1,
+  REORDER = 2
+}
+//#endregion
+//#region packages/runtime-core/src/components/KeepAlive.d.ts
+type MatchPattern = string | RegExp | (string | RegExp)[];
+interface KeepAliveProps {
+  include?: MatchPattern;
+  exclude?: MatchPattern;
+  max?: number | string;
+}
+//#endregion
+//#region packages/runtime-core/src/apiLifecycle.d.ts
+type DebuggerHook = (e: DebuggerEvent) => void;
+type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
+//#endregion
+//#region packages/runtime-core/src/compat/compatConfig.d.ts
+declare 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"
+}
+type CompatConfig = Partial<Record<DeprecationTypes, boolean | "suppress-warning">> & {
+  MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
+};
+declare function configureCompat(config: CompatConfig): void;
+//#endregion
+//#region packages/runtime-core/src/componentOptions.d.ts
+/**
+* Interface for declaring custom options.
+*
+* @example
+* ```ts
+* declare module 'vue' {
+*   interface ComponentCustomOptions {
+*     beforeRouteUpdate?(
+*       to: Route,
+*       from: Route,
+*       next: () => void
+*     ): void
+*   }
+* }
+* ```
+*/
+interface ComponentCustomOptions {}
+type RenderFunction = () => VNodeChild;
+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 = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II, Provide>, ComponentInternalOptions, AsyncComponentInternalOptions, 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?: LC & Record<string, Component>;
+  directives?: Directives & Record<string, Directive>;
+  inheritAttrs?: boolean;
+  emits?: (E | EE[]) & ThisType<void>;
+  slots?: S;
+  expose?: Exposed[];
+  serverPrefetch?(): void | Promise<any>;
+  compilerOptions?: RuntimeCompilerOptions;
+  /**
+  * SSR only. This is produced by compiler-ssr and attached in compiler-sfc
+  * not user facing, so the typing is lax and for test only.
+  * @internal
+  */
+  ssrRender?: (ctx: any, push: (item: any) => void, parentInstance: ComponentInternalInstance, attrs: Data | undefined, $props: ComponentInternalInstance["props"], $setup: ComponentInternalInstance["setupState"], $data: ComponentInternalInstance["data"], $options: ComponentInternalInstance["ctx"]) => void;
+  /**
+  * Only generated by compiler-sfc to mark a ssr render function inlined and
+  * returned from setup()
+  * @internal
+  */
+  __ssrInlineRender?: boolean;
+  call?: (this: unknown, ...args: unknown[]) => never;
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  __defaults?: Defaults;
+}
+/**
+* Subset of compiler options that makes sense for the runtime.
+*/
+interface RuntimeCompilerOptions {
+  isCustomElement?: (tag: string) => boolean;
+  whitespace?: "preserve" | "condense";
+  comments?: boolean;
+  delimiters?: [string, string];
+}
+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, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II, S, LC, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>, Defaults, false, I, S, LC, Directives>>;
+type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
+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>;
+type ComponentProvideOptions = ObjectProvideOptions | Function;
+type ObjectProvideOptions = Record<string | symbol, unknown>;
+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, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
+  compatConfig?: CompatConfig;
+  [key: string]: any;
+  data?: (this: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
+  computed?: C;
+  methods?: M;
+  watch?: ComponentWatchOptions;
+  provide?: Provide;
+  inject?: I | II[];
+  filters?: Record<string, Function>;
+  mixins?: Mixin[];
+  extends?: Extends;
+  beforeCreate?(): any;
+  created?(): any;
+  beforeMount?(): any;
+  mounted?(): any;
+  beforeUpdate?(): any;
+  updated?(): any;
+  activated?(): any;
+  deactivated?(): any;
+  /** @deprecated use `beforeUnmount` instead */
+  beforeDestroy?(): any;
+  beforeUnmount?(): any;
+  /** @deprecated use `unmounted` instead */
+  destroyed?(): any;
+  unmounted?(): any;
+  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;
+};
+//#endregion
+//#region packages/runtime-core/src/apiInject.d.ts
+interface InjectionConstraint<T> {}
+type InjectionKey<T> = symbol & InjectionConstraint<T>;
+//#endregion
+//#region packages/runtime-core/src/apiDefineComponent.d.ts
+type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
+type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+//#endregion
+//#region packages/runtime-core/src/apiCreateApp.d.ts
+interface App<HostElement = any> {
+  vapor?: boolean;
+  version: string;
+  config: AppConfig;
+  use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: NoInfer<Options>): this;
+  use<Options>(plugin: Plugin<Options>, options: NoInfer<Options>): this;
+  mixin(mixin: ComponentOptions): this;
+  component(name: string): Component | undefined;
+  component<T extends Component | DefineComponent>(name: string, component: T): this;
+  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string): Directive<HostElement, Value, Modifiers, Arg> | undefined;
+  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string, directive: Directive<HostElement, Value, Modifiers, Arg>): this;
+  mount(rootContainer: HostElement | string, isHydrate?: boolean, namespace?: boolean | ElementNamespace, vnode?: VNode): ComponentPublicInstance;
+  unmount(): void;
+  onUnmount(cb: () => void): void;
+  provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): this;
+  /**
+  * 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: GenericComponent;
+  _props: Data | null;
+  _container: HostElement | null;
+  _context: AppContext;
+  _instance: GenericComponentInstance | null;
+  /**
+  * @internal custom element vnode
+  */
+  _ceVNode?: VNode;
+  /**
+  * @internal vapor custom element instance
+  */
+  _ceComponent?: GenericComponentInstance | null;
+  /**
+  * v2 compat only
+  */
+  filter?(name: string): Function | undefined;
+  filter?(name: string, filter: Function): this;
+  /**
+  * @internal v3 compat only
+  */
+  _createRoot?(options: ComponentOptions): ComponentPublicInstance;
+}
+type OptionMergeFunction = (to: unknown, from: unknown) => any;
+/**
+* Shared app config between vdom and vapor
+*/
+interface GenericAppConfig {
+  performance?: boolean;
+  errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
+  warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
+  /**
+  * Whether to throw unhandled errors in production.
+  * Default is `false` to avoid crashing on any error (and only logs it)
+  * But in some cases, e.g. SSR, throwing might be more desirable.
+  */
+  throwUnhandledErrorInProduction?: boolean;
+  /**
+  * Prefix for all useId() calls within this app
+  */
+  idPrefix?: string;
+}
+interface AppConfig extends GenericAppConfig {
+  readonly isNativeTag: (tag: string) => boolean;
+  optionMergeStrategies: Record<string, OptionMergeFunction>;
+  globalProperties: ComponentCustomProperties & Record<string, any>;
+  /**
+  * Options to pass to `@vue/compiler-dom`.
+  * Only supported in runtime compiler build.
+  */
+  compilerOptions: RuntimeCompilerOptions;
+  /**
+  * @deprecated use config.compilerOptions.isCustomElement
+  */
+  isCustomElement?: (tag: string) => boolean;
+}
+/**
+* The vapor in vdom implementation is in runtime-vapor/src/vdomInterop.ts
+*/
+interface VaporInteropInterface {
+  mount(vnode: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, onBeforeMount?: () => void): GenericComponentInstance;
+  update(n1: VNode, n2: VNode, shouldUpdate: boolean, onBeforeUpdate?: () => void): void;
+  unmount(vnode: VNode, doRemove?: boolean): void;
+  move(vnode: VNode, container: any, anchor: any, moveType: MoveType): void;
+  slot(n1: VNode | null, n2: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance | null): void;
+  hydrate(vnode: VNode, node: any, container: any, anchor: any, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null): Node;
+  hydrateSlot(vnode: VNode, node: any): Node;
+  activate(vnode: VNode, container: any, anchor: any, parentComponent: ComponentInternalInstance): void;
+  deactivate(vnode: VNode, container: any): void;
+  setTransitionHooks(component: ComponentInternalInstance, transition: TransitionHooks): void;
+  vdomMount: (component: ConcreteComponent, parentComponent: any, props?: any, slots?: any, isSingleRoot?: boolean) => any;
+  vdomUnmount: UnmountComponentFn;
+  vdomSlot: (slots: any, name: string | (() => string), props: Record<string, any>, parentComponent: any, fallback?: any) => any;
+  vdomMountVNode: (vnode: VNode, parentComponent: any) => any;
+}
+/**
+* Minimal app context shared between vdom and vapor
+*/
+interface GenericAppContext {
+  app: App;
+  config: GenericAppConfig;
+  provides: Record<string | symbol, any>;
+  components?: Record<string, Component>;
+  directives?: Record<string, Directive>;
+  /**
+  * HMR only
+  * @internal
+  */
+  reload?: () => void;
+  /**
+  * @internal vapor interop only
+  */
+  vapor?: VaporInteropInterface;
+}
+interface AppContext extends GenericAppContext {
+  config: AppConfig;
+  components: Record<string, Component>;
+  directives: Record<string, Directive>;
+  mixins: ComponentOptions[];
+  /**
+  * Cache for merged/normalized component options
+  * Each app instance has its own cache because app-level global mixins and
+  * optionMergeStrategies can affect merge behavior.
+  * @internal
+  */
+  optionsCache: WeakMap<ComponentOptions, MergedComponentOptions>;
+  /**
+  * Cache for normalized props options
+  * @internal
+  */
+  propsCache: WeakMap<ConcreteComponent, NormalizedPropsOptions>;
+  /**
+  * Cache for normalized emits options
+  * @internal
+  */
+  emitsCache: WeakMap<ConcreteComponent, ObjectEmitsOptions | null>;
+  /**
+  * v2 compat only
+  * @internal
+  */
+  filters?: Record<string, Function>;
+}
+type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
+type ObjectPlugin<Options = any[]> = {
+  install: PluginInstallFunction<Options>;
+};
+type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
+type Plugin<Options = any[], P extends unknown[] = (Options extends unknown[] ? Options : [Options])> = FunctionPlugin<P> | ObjectPlugin<P>;
+//#endregion
+//#region packages/runtime-core/src/components/Teleport.d.ts
+type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
+interface TeleportProps {
+  to: string | RendererElement | null | undefined;
+  disabled?: boolean;
+  defer?: boolean;
+}
+declare const TeleportImpl: {
+  name: string;
+  __isTeleport: boolean;
+  process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
+  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, {
+    um: unmount,
+    o: {
+      remove: hostRemove
+    }
+  }: RendererInternals, doRemove: boolean): void;
+  move: typeof moveTeleport;
+  hydrate: typeof hydrateTeleport;
+};
+declare enum TeleportMoveTypes {
+  TARGET_CHANGE = 0,
+  TOGGLE = 1,
+  REORDER = 2
+}
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, {
+  o: {
+    insert
+  },
+  m: move
+}: RendererInternals, parentComponent: ComponentInternalInstance | null, moveType?: TeleportMoveTypes): void;
+declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, {
+  o: {
+    nextSibling,
+    parentNode,
+    querySelector,
+    insert,
+    createText
+  }
+}: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare const Teleport: {
+  __isTeleport: true;
+  new (): {
+    $props: VNodeProps & TeleportProps;
+    $slots: {
+      default(): VNode[];
+    };
+  };
+};
+//#endregion
+//#region packages/runtime-core/src/vnode.d.ts
+declare const Fragment: {
+  __isFragment: true;
+  new (): {
+    $props: VNodeProps;
+  };
+};
+declare const Text: unique symbol;
+declare const Comment: unique symbol;
+declare const Static: unique symbol;
+declare const VaporSlot: unique symbol;
+type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl | typeof VaporSlot;
+type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
+type VNodeNormalizedRefAtom = {
+  /**
+  * component instance
+  */
+  i: ComponentInternalInstance;
+  /**
+  * Actual ref
+  */
+  r: VNodeRef;
+  /**
+  * setup ref key
+  */
+  k?: string;
+  /**
+  * refInFor marker
+  */
+  f?: boolean;
+};
+type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
+type VNodeMountHook = (vnode: VNode) => void;
+type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
+type VNodeProps = {
+  key?: PropertyKey;
+  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;
+type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
+type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
+type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
+interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
+  [key: string]: any;
+}> {
+  /**
+  * @internal
+  */
+  __v_isVNode: true;
+  /**
+  * @internal
+  */
+  [ReactiveFlags$1.SKIP]: true;
+  type: VNodeTypes;
+  props: (VNodeProps & ExtraProps) | null;
+  key: PropertyKey | null;
+  ref: VNodeNormalizedRef | null;
+  /**
+  * SFC only. This is assigned on vnode creation using currentScopeId
+  * which is set alongside currentRenderingInstance.
+  */
+  scopeId: string | null;
+  /**
+  * SFC only. This is assigned to:
+  * - Slot fragment vnodes with :slotted SFC styles.
+  * - Component vnodes (during patch/hydration) so that its root node can
+  *   inherit the component's slotScopeIds
+  * @internal
+  */
+  slotScopeIds: string[] | null;
+  children: VNodeNormalizedChildren;
+  component: ComponentInternalInstance | null;
+  dirs: DirectiveBinding[] | null;
+  transition: TransitionHooks<HostElement> | null;
+  el: HostNode | null;
+  placeholder: HostNode | null;
+  anchor: HostNode | null;
+  target: HostElement | null;
+  targetStart: HostNode | null;
+  targetAnchor: HostNode | null;
+  /**
+  * number of elements contained in a static vnode
+  * @internal
+  */
+  staticCount: number;
+  suspense: SuspenseBoundary | null;
+  /**
+  * @internal
+  */
+  ssContent: VNode | null;
+  /**
+  * @internal
+  */
+  ssFallback: VNode | null;
+  shapeFlag: number;
+  patchFlag: number;
+  /**
+  * @internal
+  */
+  dynamicProps: string[] | null;
+  /**
+  * @internal
+  */
+  dynamicChildren: (VNode[] & {
+    hasOnce?: boolean;
+  }) | null;
+  appContext: AppContext | null;
+  /**
+  * @internal lexical scope owner instance
+  */
+  ctx: ComponentInternalInstance | null;
+  /**
+  * @internal attached by v-memo
+  */
+  memo?: any[];
+  /**
+  * @internal index for cleaning v-memo cache
+  */
+  cacheIndex?: number;
+  /**
+  * @internal __COMPAT__ only
+  */
+  isCompatRoot?: true;
+  /**
+  * @internal custom element interception hook
+  */
+  ce?: (instance: ComponentInternalInstance) => void;
+  /**
+  * @internal VDOM in Vapor interop hook
+  */
+  vi?: (instance: ComponentInternalInstance) => void;
+  /**
+  * @internal Vapor slot in VDOM metadata
+  */
+  vs?: {
+    slot: (props: any) => any;
+    fallback: (() => VNodeArrayChildren) | undefined;
+    ref?: ShallowRef<any>;
+  };
+  /**
+  * @internal Vapor slot Block
+  */
+  vb?: any;
+}
+//#endregion
+//#region packages/runtime-core/src/component.d.ts
+type Data = Record<string, unknown>;
+/**
+* For extending allowed non-declared props on components in TSX
+*/
+interface ComponentCustomProps {}
+/**
+* For globally defined Directives
+* Here is an example of adding a directive `VTooltip` as global directive:
+*
+* @example
+* ```ts
+* import VTooltip from 'v-tooltip'
+*
+* declare module '@vue/runtime-core' {
+*   interface GlobalDirectives {
+*     VTooltip
+*   }
+* }
+* ```
+*/
+interface GlobalDirectives {}
+/**
+* For globally defined Components
+* Here is an example of adding a component `RouterView` as global component:
+*
+* @example
+* ```ts
+* import { RouterView } from 'vue-router'
+*
+* declare module '@vue/runtime-core' {
+*   interface GlobalComponents {
+*     RouterView
+*   }
+* }
+* ```
+*/
+interface GlobalComponents {
+  Teleport: DefineComponent<TeleportProps>;
+  Suspense: DefineComponent<SuspenseProps>;
+  KeepAlive: DefineComponent<KeepAliveProps>;
+  BaseTransition: DefineComponent<BaseTransitionProps>;
+}
+/**
+* Default allowed non-declared props on component in TSX
+*/
+interface AllowedComponentProps {
+  class?: unknown;
+  style?: unknown;
+}
+interface ComponentInternalOptions {
+  /**
+  * indicates vapor component
+  */
+  __vapor?: boolean;
+  /**
+  * indicates keep-alive component
+  */
+  __isKeepAlive?: boolean;
+  /**
+  * @internal
+  */
+  __scopeId?: string;
+  /**
+  * @internal
+  */
+  __cssModules?: Data;
+  /**
+  * @internal
+  */
+  __hmrId?: string;
+  /**
+  * 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;
+}
+interface AsyncComponentInternalOptions<R = ConcreteComponent, I = ComponentInternalInstance> {
+  /**
+  * marker for AsyncComponentWrapper
+  * @internal
+  */
+  __asyncLoader?: () => Promise<R>;
+  /**
+  * the inner component resolved by the AsyncComponentWrapper
+  * @internal
+  */
+  __asyncResolved?: R;
+  /**
+  * Exposed for lazy hydration
+  * @internal
+  */
+  __asyncHydrate?: (el: Element, instance: I, hydrate: () => void) => void;
+}
+interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
+  (props: P & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, "expose">): any;
+  props?: ComponentPropsOptions<P>;
+  emits?: EE | (keyof EE)[];
+  slots?: IfAny<S, Slots, SlotsType<S>>;
+  inheritAttrs?: boolean;
+  displayName?: string;
+  compatConfig?: CompatConfig;
+}
+/**
+* Type used where a function accepts both vdom and vapor components.
+*/
+type GenericComponent = ({
+  name?: string;
+} | ((() => any) & {
+  displayName?: string;
+})) & ComponentInternalOptions;
+/**
+* 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.
+*/
+type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
+/**
+* A type used in public APIs where a component type is expected.
+* The constructor type is an artificial type returned by defineComponent().
+*/
+type Component<PropsOrInstance = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
+type LifecycleHook<TFn = Function> = (TFn & SchedulerJob)[] | null;
+type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
+  attrs: Data;
+  slots: UnwrapSlotsType<S>;
+  emit: EmitFn<E>;
+  expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+} : never;
+/**
+* @internal
+*/
+type InternalRenderFunction = {
+  (ctx: ComponentPublicInstance, cache: ComponentInternalInstance["renderCache"], $props: ComponentInternalInstance["props"], $setup: ComponentInternalInstance["setupState"], $data: ComponentInternalInstance["data"], $options: ComponentInternalInstance["ctx"]): VNodeChild;
+  _rc?: boolean;
+  _compatChecked?: boolean;
+  _compatWrapped?: boolean;
+};
+/**
+* Base component instance interface that is shared between vdom mode and vapor
+* mode, so that we can have a mixed instance tree and reuse core logic that
+* operate on both.
+*/
+interface GenericComponentInstance {
+  vapor?: boolean;
+  uid: number;
+  type: GenericComponent;
+  root: GenericComponentInstance | null;
+  parent: GenericComponentInstance | null;
+  appContext: GenericAppContext;
+  /**
+  * Object containing values this component provides for its descendants
+  * @internal
+  */
+  provides: Data;
+  /**
+  * Tracking reactive effects (e.g. watchers) associated with this component
+  * so that they can be automatically stopped on component unmount
+  * @internal
+  */
+  scope: EffectScope;
+  /**
+  * render function will have different types between vdom and vapor
+  */
+  render?: Function | null;
+  /**
+  * SSR render function
+  * (they are the same between vdom and vapor components.)
+  * @internal
+  */
+  ssrRender?: Function | null;
+  props: Data;
+  attrs: Data;
+  refs: Data;
+  emit: EmitFn;
+  /**
+  * used for keeping track of .once event handlers on components
+  * @internal
+  */
+  emitted: Record<string, boolean> | null;
+  /**
+  * used for caching the value returned from props default factory functions to
+  * avoid unnecessary watcher trigger
+  * @internal
+  */
+  propsDefaults: Data | null;
+  /**
+  * used for getting the keys of a component's raw props, vapor only
+  * @internal
+  */
+  rawKeys?: () => string[];
+  exposed: Record<string, any> | null;
+  exposeProxy: Record<string, any> | null;
+  /**
+  * setup related
+  * @internal
+  */
+  setupState?: Data;
+  /**
+  * devtools access to additional info
+  * @internal
+  */
+  devtoolsRawSetupState?: any;
+  isMounted: boolean;
+  isUnmounted: boolean;
+  isDeactivated: boolean;
+  /**
+  * for tracking useId()
+  * first element is the current boundary prefix
+  * second number is the index of the useId call within that boundary
+  * @internal
+  */
+  ids: [string, number, number];
+  /**
+  * resolved props options
+  * @internal
+  */
+  propsOptions?: NormalizedPropsOptions;
+  /**
+  * resolved emits options
+  * @internal
+  */
+  emitsOptions?: ObjectEmitsOptions | null;
+  /**
+  * Public instance proxy, vdom only
+  */
+  proxy?: any;
+  /**
+  * suspense related
+  * @internal
+  */
+  suspense: SuspenseBoundary | null;
+  /**
+  * suspense pending batch id
+  * @internal
+  */
+  suspenseId: number;
+  /**
+  * @internal
+  */
+  asyncDep: Promise<any> | null;
+  /**
+  * @internal
+  */
+  asyncResolved: boolean;
+  /**
+  * `updateTeleportCssVars`
+  * For updating css vars on contained teleports
+  * @internal
+  */
+  ut?: (vars?: Record<string, string>) => void;
+  /**
+  * dev only. For style v-bind hydration mismatch checks
+  * @internal
+  */
+  getCssVars?: () => Record<string, string>;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.BEFORE_CREATE]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.CREATED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.BEFORE_MOUNT]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.MOUNTED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.BEFORE_UPDATE]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.UPDATED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.BEFORE_UNMOUNT]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.UNMOUNTED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.RENDER_TRACKED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.RENDER_TRIGGERED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.ACTIVATED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.DEACTIVATED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.ERROR_CAPTURED]?: LifecycleHook;
+  /**
+  * @internal
+  */
+  [LifecycleHooks.SERVER_PREFETCH]?: LifecycleHook<() => Promise<unknown>>;
+  /**
+  * @internal vapor only
+  */
+  hmrRerender?: () => void;
+  /**
+  * @internal vapor only
+  */
+  hmrReload?: (newComp: any) => void;
+  vnode?: VNode;
+  subTree?: VNode;
+  /**
+  * Custom Element instance (if component is created by defineCustomElement)
+  * @internal
+  */
+  ce?: ComponentCustomElementInterface;
+  /**
+  * is custom element? (kept only for compatibility)
+  * @internal
+  */
+  isCE?: boolean;
+  /**
+  * custom element specific HMR method
+  * @internal
+  */
+  ceReload?: (newStyles?: string[]) => void;
+}
+/**
+* We expose a subset of properties on the internal instance as they are
+* useful for advanced external libraries and tools.
+*/
+interface ComponentInternalInstance extends GenericComponentInstance {
+  vapor?: never;
+  uid: number;
+  type: ConcreteComponent;
+  parent: GenericComponentInstance | null;
+  root: GenericComponentInstance;
+  appContext: AppContext;
+  /**
+  * Vnode representing this component in its parent's vdom tree
+  */
+  vnode: VNode;
+  /**
+  * The pending new vnode from parent updates
+  * @internal
+  */
+  next: VNode | null;
+  /**
+  * Root vnode of this component's own vdom tree
+  */
+  subTree: VNode;
+  /**
+  * Render effect instance
+  */
+  effect: ReactiveEffect;
+  /**
+  * Force update render effect
+  */
+  update: () => void;
+  /**
+  * Render effect job to be passed to scheduler (checks if dirty)
+  */
+  job: SchedulerJob;
+  /**
+  * The render function that returns vdom tree.
+  * @internal
+  */
+  render: InternalRenderFunction | null;
+  /**
+  * cache for proxy access type to avoid hasOwnProperty calls
+  * @internal
+  */
+  accessCache: Data | null;
+  /**
+  * cache for render function values that rely on _ctx but won't need updates
+  * after initialized (e.g. inline handlers)
+  * @internal
+  */
+  renderCache: (Function | VNode | undefined)[];
+  /**
+  * Resolved component registry, only for components with mixins or extends
+  * @internal
+  */
+  components: Record<string, ConcreteComponent> | null;
+  /**
+  * Resolved directive registry, only for components with mixins or extends
+  * @internal
+  */
+  directives: Record<string, Directive> | null;
+  /**
+  * Resolved filters registry, v2 compat only
+  * @internal
+  */
+  filters?: Record<string, Function>;
+  /**
+  * resolved props options
+  * @internal
+  */
+  propsOptions: NormalizedPropsOptions;
+  /**
+  * resolved emits options
+  * @internal
+  */
+  emitsOptions: ObjectEmitsOptions | null;
+  /**
+  * resolved inheritAttrs options
+  * @internal
+  */
+  inheritAttrs?: boolean;
+  /**
+  * setup related
+  * @internal
+  */
+  setupState: Data;
+  /**
+  * @internal
+  */
+  setupContext?: SetupContext | null;
+  proxy: ComponentPublicInstance | null;
+  data: Data;
+  emit: EmitFn;
+  slots: InternalSlots;
+  exposeProxy: Record<string, any> | null;
+  /**
+  * alternative proxy used only for runtime-compiled render functions using
+  * `with` block
+  * @internal
+  */
+  withProxy: ComponentPublicInstance | null;
+  /**
+  * This is the target for the public instance proxy. It also holds properties
+  * injected by user options (computed, methods etc.) and user-attached
+  * custom properties (via `this.x = ...`)
+  * @internal
+  */
+  ctx: Data;
+  /**
+  * suspense pending batch id
+  * @internal
+  */
+  suspenseId: number;
+  /**
+  * @internal
+  */
+  asyncDep: Promise<any> | null;
+  /**
+  * @internal
+  */
+  asyncResolved: boolean;
+  /**
+  * For caching bound $forceUpdate on public proxy access
+  * @internal
+  */
+  f?: () => void;
+  /**
+  * For caching bound $nextTick on public proxy access
+  * @internal
+  */
+  n?: () => Promise<void>;
+  /**
+  * v2 compat only, for caching mutated $options
+  * @internal
+  */
+  resolvedOptions?: MergedComponentOptions;
+}
+interface ComponentCustomElementInterface {
+  /**
+  * @internal
+  */
+  _isVueCE: boolean;
+  /**
+  * @internal
+  */
+  _injectChildStyle(type: ConcreteComponent): void;
+  /**
+  * @internal
+  */
+  _removeChildStyle(type: ConcreteComponent): void;
+  /**
+  * @internal
+  */
+  _setProp(key: string, val: any, shouldReflect?: boolean, shouldUpdate?: boolean): void;
+  /**
+  * @internal
+  */
+  _beginPatch(): void;
+  /**
+  * @internal
+  */
+  _endPatch(): void;
+  /**
+  * @internal attached by the nested Teleport when shadowRoot is false.
+  */
+  _teleportTargets?: Set<RendererElement>;
+  /**
+  * @internal check if shadow root is enabled
+  */
+  _hasShadowRoot(): boolean;
+}
+//#endregion
+//#region packages/runtime-core/src/apiWatch.d.ts
+interface WatchEffectOptions extends DebuggerOptions {
+  flush?: "pre" | "post" | "sync";
+}
+interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
+  immediate?: Immediate;
+  deep?: boolean | number;
+  once?: boolean;
+}
+//#endregion
+//#region packages/runtime-core/src/compat/globalConfig.d.ts
+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;
+};
+//#endregion
+//#region packages/runtime-core/src/compat/instance.d.ts
+type LegacyPublicInstance = ComponentPublicInstance & LegacyPublicProperties;
+interface LegacyPublicProperties {
+  $set<T extends Record<keyof any, any>, K extends keyof T>(target: T, key: K, value: T[K]): void;
+  $delete<T extends Record<keyof any, any>, K extends keyof T>(target: T, key: K): 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[]>;
+}
+//#endregion
+//#region packages/runtime-core/src/compat/global.d.ts
+/**
+* @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'`.
+*/
+type CompatVue = Pick<App, "version" | "component" | "directive"> & {
+  configureCompat: typeof configureCompat;
+  new (options?: ComponentOptions): LegacyPublicInstance;
+  version: string;
+  config: AppConfig & LegacyConfig;
+  nextTick: typeof nextTick;
+  use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: Options): CompatVue;
+  use<Options>(plugin: Plugin<Options>, options: Options): CompatVue;
+  mixin(mixin: ComponentOptions): CompatVue;
+  component(name: string): Component | undefined;
+  component(name: string, component: Component): CompatVue;
+  directive<T = any, V = any>(name: string): Directive<T, V> | undefined;
+  directive<T = any, V = any>(name: string, directive: Directive<T, V>): CompatVue;
+  compile(template: string): RenderFunction;
+  /**
+  * @deprecated Vue 3 no longer supports extending constructors.
+  */
+  extend: (options?: ComponentOptions) => CompatVue;
+  /**
+  * @deprecated Vue 3 no longer needs set() for adding new properties.
+  */
+  set(target: any, key: PropertyKey, value: any): void;
+  /**
+  * @deprecated Vue 3 no longer needs delete() for property deletions.
+  */
+  delete(target: any, key: PropertyKey): void;
+  /**
+  * @deprecated use `reactive` instead.
+  */
+  observable: typeof reactive;
+  /**
+  * @deprecated filters have been removed from Vue 3.
+  */
+  filter(name: string, arg?: any): null;
+  /**
+  * @internal
+  */
+  cid: number;
+  /**
+  * @internal
+  */
+  options: ComponentOptions;
+  /**
+  * @internal
+  */
+  util: any;
+  /**
+  * @internal
+  */
+  super: CompatVue;
+};
+//#endregion
+//#region packages/runtime-core/src/index.d.ts
+declare module "@vue/reactivity" {
+  interface RefUnwrapBailTypes {
+    runtimeCoreBailTypes: VNode | {
+      $: ComponentInternalInstance;
+    };
+  }
+}
+//#endregion
+//#region packages/runtime-dom/src/components/Transition.d.ts
+declare const TRANSITION = "transition";
+declare const ANIMATION = "animation";
+type AnimationTypes = typeof TRANSITION | typeof ANIMATION;
+interface TransitionProps extends BaseTransitionProps<Element> {
+  name?: string;
+  type?: AnimationTypes;
+  css?: boolean;
+  duration?: number | {
+    enter: number;
+    leave: number;
+  };
+  enterFromClass?: string;
+  enterActiveClass?: string;
+  enterToClass?: string;
+  appearFromClass?: string;
+  appearActiveClass?: string;
+  appearToClass?: string;
+  leaveFromClass?: string;
+  leaveActiveClass?: string;
+  leaveToClass?: string;
+}
+//#endregion
+//#region packages/runtime-dom/src/components/TransitionGroup.d.ts
+type TransitionGroupProps = Omit<TransitionProps, "mode"> & {
+  tag?: string;
+  moveClass?: string;
+};
+//#endregion
+//#region packages/runtime-dom/src/directives/vShow.d.ts
+declare const vShowOriginalDisplay: unique symbol;
+declare const vShowHidden: unique symbol;
+interface VShowElement extends HTMLElement {
+  [vShowOriginalDisplay]?: string;
+  [vShowHidden]?: boolean;
+}
+declare const vShow: ObjectDirective<VShowElement> & {
+  name: "show";
+};
+//#endregion
+//#region packages/runtime-dom/src/directives/vOn.d.ts
+declare const systemModifiers: readonly ["ctrl", "shift", "alt", "meta"];
+type SystemModifiers = (typeof systemModifiers)[number];
+type CompatModifiers = keyof typeof keyNames;
+type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
+type ModifierGuards = "shift" | "ctrl" | "alt" | "meta" | "left" | "right" | "stop" | "prevent" | "self" | "middle" | "exact";
+/**
+* @private
+*/
+declare const keyNames: Record<"esc" | "space" | "up" | "left" | "right" | "down" | "delete", string>;
+/**
+* @private
+*/
+type VOnDirective = Directive<any, any, VOnModifiers>;
+//#endregion
+//#region packages/runtime-dom/src/directives/vModel.d.ts
+type AssignerFn = (value: any) => void;
+declare const assignKey: unique symbol;
+type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<T & {
+  [assignKey]: AssignerFn;
+  _assigning?: boolean;
+}, any, Modifiers>;
+declare const vModelText: ModelDirective<HTMLInputElement | HTMLTextAreaElement, "trim" | "number" | "lazy">;
+declare const vModelCheckbox: ModelDirective<HTMLInputElement>;
+declare const vModelRadio: ModelDirective<HTMLInputElement>;
+declare const vModelSelect: ModelDirective<HTMLSelectElement, "number">;
+declare const vModelDynamic: ObjectDirective<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+type VModelDirective = typeof vModelText | typeof vModelCheckbox | typeof vModelSelect | typeof vModelRadio | typeof vModelDynamic;
+//#endregion
+//#region packages/runtime-dom/src/index.d.ts
+/**
+* This is a stub implementation to prevent the need to use dom types.
+*
+* To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
+*/
+type DomType<T> = typeof globalThis extends {
+  window: unknown;
+} ? T : never;
+declare module "@vue/reactivity" {
+  interface RefUnwrapBailTypes {
+    runtimeDOMBailTypes: DomType<Node | Window>;
+  }
+}
+declare module "@vue/runtime-core" {
+  interface GlobalComponents {
+    Transition: DefineComponent<TransitionProps>;
+    TransitionGroup: DefineComponent<TransitionGroupProps>;
+  }
+  interface GlobalDirectives {
+    vShow: typeof vShow;
+    vOn: VOnDirective;
+    vBind: VModelDirective;
+    vIf: Directive<any, boolean>;
+    vOnce: Directive;
+    vSlot: Directive;
+  }
+}
+//#endregion
+//#region temp/packages/vue-compat/src/index.d.ts
 export declare const Vue: CompatVue;
-
-export { Vue as default };
+//#endregion
+export { Vue as default };