diff --git a/package.json b/package.json
index 540ba574e..db304f1dc 100644
--- a/package.json
+++ b/package.json
@@ -119,6 +119,9 @@
         "react",
         "react-dom"
       ]
+    },
+    "patchedDependencies": {
+      "@vue/runtime-core@3.3.8": "patches/@vue__runtime-core@3.3.8.patch"
     }
   }
 }
diff --git a/patches/@vue__runtime-core@3.3.8.patch b/patches/@vue__runtime-core@3.3.8.patch
new file mode 100644
index 000000000..a9628558d
--- /dev/null
+++ b/patches/@vue__runtime-core@3.3.8.patch
@@ -0,0 +1,417 @@
+diff --git a/dist/runtime-core.d.ts b/dist/runtime-core.d.ts
+index 5d4c1fb2c6859f7982ea7bb55f65a5c613d91038..d8c6502f88b63d58dd9844f460c39d519754f396 100644
+--- a/dist/runtime-core.d.ts
++++ b/dist/runtime-core.d.ts
+@@ -1,7 +1,7 @@
+ import { computed as computed$1, ShallowUnwrapRef, UnwrapNestedRefs, DebuggerEvent, ComputedGetter, WritableComputedOptions, Ref, ReactiveEffect, 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, Awaited, UnionToIntersection, LooseRequired } from '@vue/shared';
+-export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
++export { LooseRequired, camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
+ 
+ export declare const computed: typeof computed$1;
+ 
+@@ -62,7 +62,7 @@ type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
+ } : 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<{
++type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: any, ...args: any[]) => any | ((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]>;
+ 
+@@ -101,20 +101,39 @@ type ExtractMixin<T> = {
+ 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> = {
++/**
++ *
++  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 = {}
++ */
++type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M, E, PublicProps, Defaults, MakeDefaultsOptional, Options, I, S> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = 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 = {}> = {
+     __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 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 = {}, Options = ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S>, 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, Options, I, S>;
++/**
++ * Resolves props
++ */
++type ComponentPropsWithDefault<P, Defaults, PublicProps, MakeDefaultsOptional extends boolean = false> = MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
+ 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 = {}> = {
++C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = any, I extends ComponentInjectOptions = {}, S extends SlotsType = {}> = {
+     $: ComponentInternalInstance;
+     $data: D;
+-    $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
++    $props: ComponentPropsWithDefault<P, Defaults, PublicProps, MakeDefaultsOptional>;
+     $attrs: Data;
+     $refs: Data;
+     $slots: UnwrapSlotsType<S>;
+@@ -126,7 +145,7 @@ C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOpt
+     $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>;
++} & IfAny<P, P, Omit<P, keyof ShallowUnwrapRef<B>>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>;
+ 
+ declare const enum LifecycleHooks {
+     BEFORE_CREATE = "bc",
+@@ -383,6 +402,7 @@ export type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | s
+ 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> {
+@@ -467,7 +487,7 @@ export type ExtractPublicPropTypes<O> = {
+ } & {
+     [K in keyof Pick<O, PublicOptionalKeys<O>>]?: InferPropType<O[K]>;
+ };
+-export type ExtractDefaultPropTypes<O> = O extends object ? {
++export type ExtractDefaultPropTypes<O> = [O] extends [object] ? {
+     [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>;
+ } : {};
+ 
+@@ -514,6 +534,15 @@ export type DirectiveArguments = Array<[Directive | undefined] | [Directive | un
+  */
+ export declare function withDirectives<T extends VNode>(vnode: T, directives: DirectiveArguments): T;
+ 
++interface ComponentOptionsCompat extends ComponentOptions {
++    model?: any;
++    el?: any;
++    _base?: any;
++    options?: any;
++    propsData?: any;
++    parent?: any;
++    __isBuildIn?: boolean;
++}
+ export declare const enum DeprecationTypes {
+     GLOBAL_MOUNT = "GLOBAL_MOUNT",
+     GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
+@@ -610,19 +639,19 @@ export interface RuntimeCompilerOptions {
+     comments?: boolean;
+     delimiters?: [string, string];
+ }
+-export type ComponentOptionsWithoutProps<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, PE = Props & EmitsToProps<E>> = ComponentOptionsBase<PE, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II, S> & {
++export type ComponentOptionsWithoutProps<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, 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<{
++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 = {}, 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> & {
++} & EmitsToProps<E>>>> = Omit<ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II, S>, 'props'> & {
+     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>;
++export type ComponentOptionsWithObjectProps<PropsOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Props = {} extends PropsOptions ? Prettify<EmitsToProps<E>> : 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<PropsOptions>;
+ } & 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 ComponentOptions<Props = Record<string, any>, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = {}, I extends ComponentInjectOptions = {}, S extends SlotsType = any> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, string, {}, I, string, S> & ThisType<CreateComponentPublicInstance<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>, {}, false, I, S>>;
++export type ComponentOptionsMixin = ComponentOptionsBase<any, any, 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;
+@@ -652,7 +681,7 @@ type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
+ } : 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;
++    props?: ComponentPropsOptions | Readonly<ComponentPropsOptions>;
+     data?: (this: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstance<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
+     computed?: C;
+     methods?: M;
+@@ -814,6 +843,7 @@ export interface TeleportProps {
+     disabled?: 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, 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;
+@@ -883,7 +913,7 @@ export type VNodeProps = {
+     onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
+     onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
+ };
+-type VNodeChildAtom = VNode | typeof NULL_DYNAMIC_COMPONENT | string | number | boolean | null | undefined | void;
++type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+ export type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
+ export type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
+ export type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
+@@ -1037,7 +1067,7 @@ interface ClassComponent {
+  * values, e.g. checking if its a function or not. This is mostly for internal
+  * implementation code.
+  */
+-export type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, any>;
++export type ConcreteComponent<Props = Record<string, any>, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions = any, I extends ComponentInjectOptions = any, S extends SlotsType = any> = (ComponentOptions<Props, RawBindings, D, C, M, any, any, E, I, S> & Record<string, any>) | 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().
+@@ -1123,9 +1153,24 @@ export declare function watch<T extends Readonly<MultiWatchSources>, Immediate e
+ 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;
++type PublicProps$1 = VNodeProps & AllowedComponentProps & ComponentCustomProps;
++type ResolveProps<Props, E extends EmitsOptions> = Readonly<([Props] extends [string] ? {
++    [key in Props]?: any;
++} : [Props] extends [ComponentObjectPropsOptions] ? ExtractPropTypes<Props> : Props extends never[] ? {} : Props) & ({} extends E ? {} : EmitsToProps<E>)>;
++declare const RawOptionsSymbol: '__rawOptions';
++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$1, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Options = {}> = ComponentPublicInstanceConstructor<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, PP & Props, Defaults, true, I, S, Options>> & Omit<ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II, S>, 'props'> & {
++    props: PropsOrPropOptions;
++} & Omit<Options, 'props'> & {
++    [RawOptionsSymbol]: Options;
++} & PP;
++export type DefineComponentOptions<Props = never, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Options = {}> = (Options & {
++    props?: [Props] extends [never] ? string[] : [Props] extends [string] ? Array<Props> : Props;
++} & ([Props] extends [string] ? ComponentOptionsWithArrayProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S> : [Props] extends [undefined] ? {
++    props?: undefined;
++} & ComponentOptionsWithoutProps<{}, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S> : Props extends ComponentObjectPropsOptions ? ComponentOptionsWithObjectProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S> : ComponentOptions<Readonly<Record<string, any> & EmitsToProps<E>>, RawBindings, D, C, M, Mixin, Extends, E, I, S>)) | (((props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>) & Options);
++export type DefineComponentFromOptions<Props = never, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Options = {}> = DefineComponent<[
++    Props
++] extends [string] ? Props[] : undefined extends Props ? {} : Props extends never[] ? string[] : Props, RawBindings, D, C, M, Mixin, Extends, E, EE, PublicProps$1, ResolveProps<Props, E>, ExtractDefaultPropTypes<Props>, I, II, S, Options>;
+ 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[];
+@@ -1136,11 +1181,9 @@ export declare function defineComponent<Props extends Record<string, any>, E ext
+     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>;
++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, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Options = {}>(options: 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$1, ResolveProps<Props, E>, ExtractDefaultPropTypes<Props>, I, II, S, Options>;
++export declare function defineComponent<Props = undefined, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Options = {}, DefineOptions = {}>(options: DefineComponentOptions<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S, Options>): DefineComponentFromOptions<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S, Options>;
++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, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, Options = {}>(options: Options & ComponentOptionsWithObjectProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S>): DefineComponent<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, PublicProps$1, ResolveProps<Props, E>, ExtractDefaultPropTypes<Props>, I, II, S, Options>;
+ 
+ type AsyncComponentResolveResult<T = Component> = T | {
+     default: T;
+@@ -1196,7 +1239,7 @@ export declare function defineProps<PropNames extends string = string>(props: Pr
+     [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>>;
++export declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
+ type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
+     readonly [K in BKeys]-?: boolean;
+ };
+@@ -1319,8 +1362,8 @@ type InferDefaults<T> = {
+ };
+ 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;
++type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = Readonly<Omit<T, keyof Defaults>> & {
++    readonly [K in keyof Defaults]-?: K extends keyof T ? Defaults[K] extends undefined ? T[K] : NotUndefined<T[K]> : never;
+ } & {
+     readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean;
+ };
+@@ -1374,7 +1417,6 @@ export declare function h(type: typeof Teleport, props: RawProps & TeleportProps
+ 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;
+@@ -1383,8 +1425,10 @@ 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 function h(type: string | Component, children?: RawChildren): VNode;
+-export declare function h<P>(type: string | Component<P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
++export declare function h(type: VNode, children?: RawChildren): VNode;
++export declare function h<P>(type: VNode<any, any, P>, props?: (RawProps & P) | ({} extends P ? null : never), children?: RawChildren | RawSlots): VNode;
++export declare function h(type: VNode | string | Constructor, children?: RawChildren): VNode;
++export declare function h<P>(type: VNode | string | Component<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;
+@@ -1437,6 +1481,138 @@ interface DevtoolsHook {
+ export declare let devtools: DevtoolsHook;
+ export declare function setDevtoolsHook(hook: DevtoolsHook, target: any): void;
+ 
++/**
++ * Extracts the component original options
++ */
++export type ExtractComponentOptions<T> = T extends {
++    [RawOptionsSymbol]: infer Options;
++} ? Options : T extends ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, any> ? T : T extends {
++    props?: any;
++    emits?: any;
++    slots?: any;
++} ? T : T;
++export type ExtractComponentProp<T> = T extends {
++    props: infer P;
++} ? P : T extends (props: infer P) => any ? P : T extends {
++    new (): {
++        $props: infer P;
++    };
++} ? P : {};
++/**
++ * Extracts the component slots as the component was created
++ */
++export type ExtractComponentSlots<T> = T extends ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, infer S> ? S : T extends {
++    slots: infer S;
++} ? S : T extends {
++    slots: infer S extends Slots;
++} ? S : T extends (props: any, opts: infer Ctx extends {
++    slots: any;
++}) => any ? Ctx['slots'] : T extends (props: any, opts: SetupContext<unknown, infer S>) => any ? S : T extends {
++    new (): {
++        $slots: infer S extends Slots;
++    };
++} ? S : {};
++/**
++ * Extracts the component emits as the component was created
++ */
++export type ExtractComponentEmits<T> = T extends ComponentOptionsBase<any, any, any, any, any, any, any, infer E> ? E : T extends {
++    emits: infer E;
++} ? E : T extends {
++    emits: infer E extends EmitsOptions;
++} ? E : T extends (props: any, opts: {
++    emits: infer E extends EmitsOptions;
++}) => any ? E : T extends {
++    $options: infer Options;
++} ? Options extends {
++    emits: infer E;
++} ? E : {} : {};
++type ResolveMixin<T> = [T] extends [
++    Readonly<ComponentOptionsBase<any, any, any, any, any, infer M, infer E, any, any, any, any, any, any>>
++] ? IntersectionMixin<M> & IntersectionMixin<E> : {};
++export type ObjectToComponentProps<T> = T extends Record<string, any> ? {
++    [K in keyof T]: {
++        type: PropType<T[K]>;
++        required: T[K] extends undefined ? false : true;
++    };
++} : {};
++/**
++ * Extracts Original props from options
++ */
++export type ResolvePropsFromOptions<T> = T extends {
++    props: infer P;
++} ? [P] extends [Array<infer PA>] ? [PA] extends [string] ? ObjectToComponentProps<Record<PA, any>> : never : P : T extends (props: infer P, ctx?: any) => any ? ObjectToComponentProps<P> : T extends {
++    new (): {
++        $props: infer P;
++    };
++} ? ObjectToComponentProps<P> : T;
++/**
++ * Get the Component props making the default optional
++ * Used mainly on the render component
++ */
++export type ComponentPropsWithDefaultOptional<T> = (ResolvePropsFromOptions<T> extends infer Props ? ExtractDefaultPropTypes<Props> extends infer Defaults ? Partial<Defaults> & Omit<ExtractPropTypes<Props>, keyof Defaults> : {} : {}) & (T extends {
++    props: any;
++} ? ResolveMixinProps<Omit<T, 'props'>> : T extends ((...args: any) => any) | (abstract new (...args: any) => any) ? {} : ResolveMixinProps<T>);
++type FixMixinResolve<T> = [T] extends [never] ? {} : T;
++type ResolveMixinProps<T> = UnwrapMixinsType<ResolveMixin<T>, 'P'>;
++type ResolveMixinData<T> = FixMixinResolve<UnwrapMixinsType<ResolveMixin<T>, 'D'>>;
++/**
++ * Returns the emits as props
++ */
++export type ComponentEmitsProps<T> = ExtractComponentEmits<T> extends infer E ? E extends EmitsOptions ? EmitsToProps<E> : unknown : unknown;
++/**
++ * Returns runtime props definition for a component
++ *
++ *  @see Include emits {@linkcode ComponentEmitsProps}
++ *  @see Get the render props {@linkcode ComponentPropsWithDefaultOptional}
++ *
++ * @example
++ * ```ts
++ * import { Comp } from './Comp.vue'
++ *
++ * function useProps(): ComponentProps<typeof Comp> {
++ *  // ...
++ * }
++ * ```
++ */
++export type ComponentProps<T> = T extends {
++    $props: infer P;
++} ? P : (ExtractComponentProp<T> extends infer P ? P extends Readonly<Array<infer V>> ? [V] extends [string] ? Readonly<{
++    [key in V]?: any;
++}> : {} : P extends ComponentPropsOptions ? ExtractPropTypes<P> : P : {}) & ResolveMixinProps<T>;
++export type RetrieveSlotArgument<T extends any[] = any[]> = ((...args: T) => any) | undefined;
++/**
++ * Returns runtime type for `slots`
++ */
++export type ComponentSlots<T> = ExtractComponentSlots<T> extends infer S ? S extends SlotsType<infer SS> ? Record<string, any> extends SS ? {
++    [K in keyof S & string]: S[K] extends RetrieveSlotArgument<infer A> ? (...arg: A) => VNode[] : (arg: S[K]) => VNode[];
++} : UnwrapSlotsType<S> : S extends Record<string, any> ? {
++    [K in keyof S & string]: S[K] extends RetrieveSlotArgument<infer A> ? (...arg: A) => VNode[] : (arg: S[K]) => VNode[];
++} : {} : {};
++export type ComponentEmits<T> = ExtractComponentEmits<T> extends infer E ? {} extends E ? () => void : EmitFn<E> : () => void;
++export type ComponentData<T> = (T extends {
++    data: () => infer D;
++} ? D : T extends {
++    setup(...args: any[]): infer S;
++} ? S extends Record<string, any> ? S : {} : T extends new () => {
++    data: () => infer D;
++} ? D : {}) & ResolveMixinData<T>;
++/**
++ * Retrieves the component public instance
++ *
++ * @example
++ * ```ts
++ * const Comp = defineComponent({ props: { a: String }, emits: ['test'] })
++ *
++ * const instance = ref<ComponentInstance<typeof Comp>>()
++ * instance.$props.a // string | undefined
++ * ```
++ */
++export type ComponentInstance<T> = T extends {
++    new (): ComponentPublicInstance;
++} ? InstanceType<T> : T extends FunctionalComponent<infer Props, infer Emits> ? ComponentPublicInstance<Props, {}, {}, {}, {}, Emits> : T extends ComponentPublicInstanceConstructor ? InstanceType<T> : T extends DefineComponentOptions<infer Props, infer RawBindings, infer D, infer C, infer M, infer Mixin, infer Extends, infer E, infer EE, infer I, infer II, infer S, infer Options> ? InstanceType<ReturnType<typeof defineComponent<Options extends {
++    props: infer P;
++} ? P extends Array<infer PA> ? PA : P : Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, S, Options>>> : T extends Component<infer Props, infer RawBindings, infer D, infer C, infer M> ? ComponentPublicInstance<unknown extends Props ? {} : Props, unknown extends RawBindings ? {} : RawBindings, unknown extends D ? {} : D, C, M> : never;
++
+ type HMRComponent = ComponentOptions | ClassComponent;
+ export interface HMRRuntime {
+     createRecord: typeof createRecord;
+@@ -1568,12 +1744,12 @@ interface LegacyPublicProperties {
+  */
+ export type CompatVue = Pick<App, 'version' | 'component' | 'directive'> & {
+     configureCompat: typeof configureCompat;
+-    new (options?: ComponentOptions): LegacyPublicInstance;
++    new (options?: ComponentOptionsCompat): LegacyPublicInstance;
+     version: string;
+     config: AppConfig & LegacyConfig;
+     nextTick: typeof nextTick;
+     use(plugin: Plugin, ...options: any[]): CompatVue;
+-    mixin(mixin: ComponentOptions): CompatVue;
++    mixin(mixin: ComponentOptionsCompat): CompatVue;
+     component(name: string): Component | undefined;
+     component(name: string, component: Component): CompatVue;
+     directive(name: string): Directive | undefined;
+@@ -1582,7 +1758,7 @@ export type CompatVue = Pick<App, 'version' | 'component' | 'directive'> & {
+     /**
+      * @deprecated Vue 3 no longer supports extending constructors.
+      */
+-    extend: (options?: ComponentOptions) => CompatVue;
++    extend: (options?: ComponentOptionsCompat) => CompatVue;
+     /**
+      * @deprecated Vue 3 no longer needs set() for adding new properties.
+      */
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a166b7dbc..06047af33 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,6 +4,11 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
+patchedDependencies:
+  '@vue/runtime-core@3.3.8':
+    hash: vlyf6crnsg7mzuzbrcghr6xpce
+    path: patches/@vue__runtime-core@3.3.8.patch
+
 dependencies:
   js-beautify:
     specifier: ^1.14.9
@@ -1643,17 +1648,18 @@ packages:
       '@vue/shared': 3.3.8
     dev: true
 
-  /@vue/runtime-core@3.3.8:
+  /@vue/runtime-core@3.3.8(patch_hash=vlyf6crnsg7mzuzbrcghr6xpce):
     resolution: {integrity: sha512-qurzOlb6q26KWQ/8IShHkMDOuJkQnQcTIp1sdP4I9MbCf9FJeGVRXJFr2mF+6bXh/3Zjr9TDgURXrsCr9bfjUw==}
     dependencies:
       '@vue/reactivity': 3.3.8
       '@vue/shared': 3.3.8
     dev: true
+    patched: true
 
   /@vue/runtime-dom@3.3.8:
     resolution: {integrity: sha512-Noy5yM5UIf9UeFoowBVgghyGGPIDPy1Qlqt0yVsUdAVbqI8eeMSsTqBtauaEoT2UFXUk5S64aWVNJN4MJ2vRdA==}
     dependencies:
-      '@vue/runtime-core': 3.3.8
+      '@vue/runtime-core': 3.3.8(patch_hash=vlyf6crnsg7mzuzbrcghr6xpce)
       '@vue/shared': 3.3.8
       csstype: 3.1.2
     dev: true
diff --git a/src/baseWrapper.ts b/src/baseWrapper.ts
index 71f074bf5..a1eb9ace0 100644
--- a/src/baseWrapper.ts
+++ b/src/baseWrapper.ts
@@ -1,13 +1,20 @@
 import { textContent } from './utils'
 import type { TriggerOptions } from './createDomEvent'
 import {
+  DefineComponentOptions,
+  DefineComponentFromOptions,
+  ComponentInjectOptions,
+  ComponentInstance,
   ComponentInternalInstance,
   ComponentOptions,
+  ComponentOptionsMixin,
   ComponentPublicInstance,
   ComputedOptions,
   CreateComponentPublicInstance,
+  EmitsOptions,
   FunctionalComponent,
   MethodOptions,
+  SlotsType,
   nextTick
 } from 'vue'
 import { createDOMEvent } from './createDomEvent'
@@ -19,6 +26,7 @@ import {
   FindComponentSelector,
   NameSelector,
   RefSelector,
+  UnknownRenderedVue,
   VueNode
 } from './types'
 import WrapperLike from './interfaces/wrapperLike'
@@ -108,16 +116,57 @@ export default abstract class BaseWrapper<ElementType extends Node>
 
   // searching by string without specifying component results in WrapperLike object
   findComponent<T extends never>(selector: string): WrapperLike
+
   // Find Component Options aka plain object
   findComponent<
-    Props,
-    RawBindings = any,
-    D = any,
-    C extends ComputedOptions = ComputedOptions,
-    M extends MethodOptions = MethodOptions
+    Props = {},
+    RawBindings = {},
+    D = {},
+    C extends ComputedOptions = {},
+    M extends MethodOptions = {},
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+    E extends EmitsOptions = {},
+    EE extends string = string,
+    I extends ComponentInjectOptions = {},
+    II extends string = string,
+    S extends SlotsType = {},
+    Options = {}
   >(
-    selector: ComponentOptions<Props, RawBindings, D, C, M>
-  ): VueWrapper<CreateComponentPublicInstance<Props, RawBindings, D, C, M>>
+    selector: DefineComponentOptions<
+      Props,
+      RawBindings,
+      D,
+      C,
+      M,
+      Mixin,
+      Extends,
+      E,
+      EE,
+      I,
+      II,
+      S,
+      Options
+    >
+  ): VueWrapper<
+    Props extends DefinedComponent
+      ? ComponentInstance<Props>
+      : DefineComponentFromOptions<
+          Props,
+          RawBindings,
+          D,
+          C,
+          M,
+          Mixin,
+          Extends,
+          E,
+          EE,
+          I,
+          II,
+          S,
+          Options
+        >
+  >
   findComponent<T extends ComponentOptions>(
     selector: string
   ): VueWrapper<
@@ -129,21 +178,23 @@ export default abstract class BaseWrapper<ElementType extends Node>
       infer M
     >
       ? CreateComponentPublicInstance<Props, RawBindings, D, C, M>
-      : VueWrapper<CreateComponentPublicInstance>
+      : CreateComponentPublicInstance
   >
-  // searching for component created via defineComponent results in VueWrapper of proper type
-  findComponent<T extends DefinedComponent>(
-    selector: T | Exclude<FindComponentSelector, FunctionalComponent>
-  ): VueWrapper<InstanceType<T>>
   // searching for functional component results in DOMWrapper
   findComponent<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>
   findComponent<T extends FunctionalComponent>(
     selector: string
   ): DOMWrapper<Element>
+
   // searching by name or ref always results in VueWrapper
   findComponent<T extends never>(
     selector: NameSelector | RefSelector
-  ): VueWrapper
+  ): VueWrapper<UnknownRenderedVue>
+  // searching for component created via defineComponent results in VueWrapper of proper type
+  findComponent<T extends DefinedComponent>(
+    selector: T | Exclude<FindComponentSelector, FunctionalComponent>
+  ): VueWrapper<ComponentInstance<T>>
+
   findComponent<T extends ComponentPublicInstance>(
     selector: T | FindComponentSelector
   ): VueWrapper<T>
@@ -185,7 +236,7 @@ export default abstract class BaseWrapper<ElementType extends Node>
   findAllComponents<T extends never>(selector: string): WrapperLike[]
   findAllComponents<T extends DefinedComponent>(
     selector: T | Exclude<FindAllComponentsSelector, FunctionalComponent>
-  ): VueWrapper<InstanceType<T>>[]
+  ): VueWrapper<ComponentInstance<T>>[]
   findAllComponents<T extends FunctionalComponent>(
     selector: T
   ): DOMWrapper<Node>[]
@@ -290,17 +341,17 @@ export default abstract class BaseWrapper<ElementType extends Node>
   }
 
   getComponent<T extends never>(selector: string): Omit<WrapperLike, 'exists'>
+  // searching by name or ref always results in VueWrapper
+  getComponent<T extends never>(
+    selector: NameSelector | RefSelector
+  ): Omit<VueWrapper<UnknownRenderedVue>, 'exists'>
   getComponent<T extends DefinedComponent>(
     selector: T | Exclude<FindComponentSelector, FunctionalComponent>
-  ): Omit<VueWrapper<InstanceType<T>>, 'exists'>
+  ): Omit<VueWrapper<ComponentInstance<T>>, 'exists'>
   // searching for functional component results in DOMWrapper
   getComponent<T extends FunctionalComponent>(
     selector: T | string
   ): Omit<DOMWrapper<Element>, 'exists'>
-  // searching by name or ref always results in VueWrapper
-  getComponent<T extends never>(
-    selector: NameSelector | RefSelector
-  ): Omit<VueWrapper, 'exists'>
   getComponent<T extends ComponentPublicInstance>(
     selector: T | FindComponentSelector
   ): Omit<VueWrapper<T>, 'exists'>
diff --git a/src/interfaces/wrapperLike.ts b/src/interfaces/wrapperLike.ts
index 50728db60..8d32d1b1b 100644
--- a/src/interfaces/wrapperLike.ts
+++ b/src/interfaces/wrapperLike.ts
@@ -8,7 +8,11 @@ import {
   RefSelector
 } from '../types'
 import { VueWrapper } from '../vueWrapper'
-import { ComponentPublicInstance, FunctionalComponent } from 'vue'
+import {
+  ComponentInstance,
+  ComponentPublicInstance,
+  FunctionalComponent
+} from 'vue'
 import type { DOMWrapper } from '../domWrapper'
 
 export default interface WrapperLike {
@@ -35,7 +39,7 @@ export default interface WrapperLike {
   findComponent<T extends never>(selector: string): WrapperLike
   findComponent<T extends DefinedComponent>(
     selector: T | Exclude<FindComponentSelector, FunctionalComponent>
-  ): VueWrapper<InstanceType<T>>
+  ): VueWrapper<ComponentInstance<T>>
   findComponent<T extends FunctionalComponent>(
     selector: T | string
   ): DOMWrapper<Element>
@@ -50,7 +54,7 @@ export default interface WrapperLike {
   findAllComponents<T extends never>(selector: string): WrapperLike[]
   findAllComponents<T extends DefinedComponent>(
     selector: T | Exclude<FindAllComponentsSelector, FunctionalComponent>
-  ): VueWrapper<InstanceType<T>>[]
+  ): VueWrapper<ComponentInstance<T>>[]
   findAllComponents<T extends FunctionalComponent>(
     selector: string
   ): DOMWrapper<Element>[]
@@ -79,7 +83,7 @@ export default interface WrapperLike {
   getComponent<T extends never>(selector: string): Omit<WrapperLike, 'exists'>
   getComponent<T extends DefinedComponent>(
     selector: T | Exclude<FindComponentSelector, FunctionalComponent>
-  ): Omit<VueWrapper<InstanceType<T>>, 'exists'>
+  ): Omit<VueWrapper<ComponentInstance<T>>, 'exists'>
   // searching for functional component results in DOMWrapper
   getComponent<T extends FunctionalComponent>(
     selector: T | string
diff --git a/src/mount.ts b/src/mount.ts
index 327ffd509..bd8f8a893 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -1,30 +1,28 @@
-import { ComponentPublicInstance, DefineComponent, VNode } from 'vue'
-import type {
-  ComponentExposed,
-  ComponentProps,
+import {
+  ComponentPublicInstance,
+  DefineComponent,
+  VNode,
+  ComponentInstance,
   ComponentSlots
-} from 'vue-component-type-helpers'
+} from 'vue'
 import { createInstance } from './createInstance'
 import { MountingOptions } from './types'
 import { trackInstance } from './utils/autoUnmount'
 import { VueWrapper } from './vueWrapper'
 import { createVueWrapper } from './wrapperFactory'
-
-type ShimSlotReturnType<T> = T extends (...args: infer P) => any
-  ? (...args: P) => any
-  : never
+import { ComponentPropsWithDefaultOptional } from 'vue'
 
 type WithArray<T> = T | T[]
 
 type ComponentData<T> = T extends { data?(...args: any): infer D } ? D : {}
 
-export type ComponentMountingOptions<
-  T,
-  P extends ComponentProps<T> = ComponentProps<T>
-> = Omit<MountingOptions<P, ComponentData<T>>, 'slots'> & {
+export type ComponentMountingOptions<T, P> = Omit<
+  MountingOptions<P, ComponentData<T>>,
+  'slots'
+> & {
   slots?: {
     [K in keyof ComponentSlots<T>]: WithArray<
-      | ShimSlotReturnType<ComponentSlots<T>[K]>
+      | ComponentSlots<T>[K]
       | string
       | VNode
       | (new () => any)
@@ -34,27 +32,11 @@ export type ComponentMountingOptions<
 } & Record<string, unknown>
 
 export function mount<
-  T,
-  C = T extends ((...args: any) => any) | (new (...args: any) => any)
-    ? T
-    : T extends { props?: infer Props }
-      ? DefineComponent<
-          Props extends Readonly<(infer PropNames)[]> | (infer PropNames)[]
-            ? { [key in PropNames extends string ? PropNames : string]?: any }
-            : Props
-        >
-      : DefineComponent,
-  P extends ComponentProps<C> = ComponentProps<C>
+  T extends DefineComponent<any, any, any, any, any, any, any, any, any, any>
 >(
   originalComponent: T,
-  options?: ComponentMountingOptions<C, P>
-): VueWrapper<
-  ComponentProps<C> & ComponentData<C> & ComponentExposed<C>,
-  ComponentPublicInstance<
-    ComponentProps<C>,
-    ComponentData<C> & ComponentExposed<C> & Omit<P, keyof ComponentProps<C>>
-  >
->
+  options?: ComponentMountingOptions<T, ComponentPropsWithDefaultOptional<T>>
+): VueWrapper<ComponentInstance<T>>
 
 // implementation
 export function mount(
diff --git a/src/renderToString.ts b/src/renderToString.ts
index bac8d1cd6..21860ae98 100644
--- a/src/renderToString.ts
+++ b/src/renderToString.ts
@@ -1,23 +1,44 @@
 import { renderToString as baseRenderToString } from '@vue/server-renderer'
-import { DefineComponent } from 'vue'
+import { ComponentProps, DefineComponent } from 'vue'
 import { createInstance } from './createInstance'
 import { ComponentMountingOptions } from './mount'
 import { RenderMountingOptions } from './types'
 
+// export function renderToString<
+//   T,
+//   C = T extends ((...args: any) => any) | (new (...args: any) => any)
+//     ? T
+//     : T extends { props?: infer Props }
+//     ? DefineComponent<
+//         Props extends Readonly<(infer PropNames)[]> | (infer PropNames)[]
+//           ? { [key in PropNames extends string ? PropNames : string]?: any }
+//           : Props
+//       >
+//     : DefineComponent
+// >(
+//   originalComponent: T,
+//   options?: ComponentMountingOptions<C> &
+//     Pick<RenderMountingOptions<any>, 'attachTo'>
+// ): Promise<string>
+
+// defineComponent
 export function renderToString<
-  T,
-  C = T extends ((...args: any) => any) | (new (...args: any) => any)
-    ? T
-    : T extends { props?: infer Props }
-      ? DefineComponent<
-          Props extends Readonly<(infer PropNames)[]> | (infer PropNames)[]
-            ? { [key in PropNames extends string ? PropNames : string]?: any }
-            : Props
-        >
-      : DefineComponent
+  T extends DefineComponent<
+    PropsOrOptions,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >,
+  PropsOrOptions
 >(
   originalComponent: T,
-  options?: ComponentMountingOptions<C> &
+  options?: ComponentMountingOptions<T, ComponentProps<T>> &
     Pick<RenderMountingOptions<any>, 'attachTo'>
 ): Promise<string>
 
diff --git a/src/types.ts b/src/types.ts
index 46677534b..a0e7f03d4 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -166,4 +166,9 @@ export type VueNode<T extends Node = Node> = T & {
 
 export type VueElement = VueNode<Element>
 
-export type DefinedComponent = new (...args: any[]) => any
+export type DefinedComponent = Component
+
+export type UnknownRenderedVue = {
+  $props: Record<string, any>
+  $data: Record<string, any>
+}
diff --git a/src/vnodeTransformers/stubComponentsTransformer.ts b/src/vnodeTransformers/stubComponentsTransformer.ts
index 7f1a110fd..f11f74663 100644
--- a/src/vnodeTransformers/stubComponentsTransformer.ts
+++ b/src/vnodeTransformers/stubComponentsTransformer.ts
@@ -17,7 +17,8 @@ import {
   ComponentPropsOptions,
   ComponentObjectPropsOptions,
   Component,
-  ComponentOptions
+  AsyncComponentOptions,
+  VNode
 } from 'vue'
 import { hyphenate } from '../utils/vueShared'
 import { matchName } from '../utils/matchName'
@@ -32,9 +33,9 @@ import { registerStub } from '../stubs'
 
 export type CustomCreateStub = (params: {
   name: string
-  component: ConcreteComponent
+  component: Component
   registerStub: (config: { source: Component; stub: Component }) => void
-}) => ConcreteComponent
+}) => ConcreteComponent | VNode
 
 interface StubOptions {
   name: string
@@ -123,11 +124,14 @@ export const createStub = ({
     }
   })
 
-  const { __asyncLoader: asyncLoader } = type as ComponentOptions
+  const { __asyncLoader: asyncLoader } = type as {
+    __asyncLoader?: AsyncComponentOptions['loader']
+  }
   if (asyncLoader) {
     asyncLoader().then(() => {
       registerStub({
-        source: (type as ComponentOptions).__asyncResolved,
+        source: (type as { __asyncResolved: ConcreteComponent | undefined })
+          .__asyncResolved!,
         stub
       })
     })
diff --git a/src/vueWrapper.ts b/src/vueWrapper.ts
index 0209dbb4d..8e839f266 100644
--- a/src/vueWrapper.ts
+++ b/src/vueWrapper.ts
@@ -1,4 +1,10 @@
-import { nextTick, App, ComponentPublicInstance, VNode } from 'vue'
+import {
+  nextTick,
+  App,
+  ComponentPublicInstance,
+  VNode,
+  ExtractComponentEmits
+} from 'vue'
 
 import { config } from './config'
 import domEvents from './constants/dom-events'
@@ -72,9 +78,29 @@ function createVMProxy<T extends ComponentPublicInstance>(
   })
 }
 
+type ResolveComponentEmitKeys<T> = keyof ResolveEmitRecord<T>
+
+type ResolveEmitRecord<T> = ExtractComponentEmits<T> extends infer E
+  ? [E] extends [Array<infer EE extends string>]
+    ? Record<EE, any[]>
+    : {
+        [K in keyof E]: (E[K] extends (...args: infer Args) => any
+          ? Args extends { length: 0 }
+            ? void
+            : Args extends { length: 1 }
+              ? Args[0]
+              : Args
+          : void)[]
+      }
+  : never
+
+type DeepPartial<T> = {
+  [P in keyof T]?: DeepPartial<T[P]>
+}
+
 export class VueWrapper<
   VM = unknown,
-  T extends ComponentPublicInstance = VM & ComponentPublicInstance
+  T extends ComponentPublicInstance = ComponentPublicInstance & VM
 > extends BaseWrapper<Node> {
   private readonly componentVM: T
   private readonly rootVM: ComponentPublicInstance | undefined | null
@@ -214,7 +240,6 @@ export class VueWrapper<
   get vm(): T {
     return this.componentVM
   }
-
   props(): T['$props']
   props<Selector extends keyof T['$props']>(
     selector: Selector
@@ -226,11 +251,16 @@ export class VueWrapper<
     return selector ? props[selector] : props
   }
 
-  emitted<T = unknown>(): Record<string, T[]>
-  emitted<T = unknown[]>(eventName: string): undefined | T[]
-  emitted<T = unknown>(
-    eventName?: string
-  ): undefined | T[] | Record<string, T[]> {
+  emitted(): ResolveEmitRecord<VM> extends infer E
+    ? {} extends E
+      ? Record<string, any[]>
+      : E
+    : never
+  emitted<E extends ResolveComponentEmitKeys<VM>>(
+    eventName: E
+  ): undefined | ResolveEmitRecord<VM>[E]
+  emitted(eventName: string): undefined | any[]
+  emitted(eventName?: string) {
     return emitted(this.vm, eventName)
   }
 
@@ -239,7 +269,7 @@ export class VueWrapper<
     return domWrapper.isVisible()
   }
 
-  setData(data: Record<string, unknown>): Promise<void> {
+  setData(data: DeepPartial<T['$data']>): Promise<void> {
     mergeDeep(this.componentVM.$data, data)
     return nextTick()
   }
@@ -253,7 +283,14 @@ export class VueWrapper<
     return nextTick()
   }
 
-  setValue(value: unknown, prop?: string): Promise<void> {
+  setValue<
+    V extends T['$props'] extends { modelValue?: infer MV } ? MV : never
+  >(value: V): Promise<void>
+  setValue<P extends keyof T['$props']>(
+    value: T['$props'][P],
+    prop: P
+  ): Promise<void>
+  setValue(value: unknown, prop?: unknown): Promise<void> {
     const propEvent = prop || 'modelValue'
     this.vm.$emit(`update:${propEvent}`, value)
     return this.vm.$nextTick()
diff --git a/src/wrapperFactory.ts b/src/wrapperFactory.ts
index 429773e30..6eea52caa 100644
--- a/src/wrapperFactory.ts
+++ b/src/wrapperFactory.ts
@@ -1,4 +1,4 @@
-import { ComponentPublicInstance, App } from 'vue'
+import { App, ComponentPublicInstance } from 'vue'
 import type { DOMWrapper as DOMWrapperType } from './domWrapper'
 import type { VueWrapper as VueWrapperType } from './vueWrapper'
 
diff --git a/test-dts/findComponent.d-test.ts b/test-dts/findComponent.d-test.ts
index deb64e1d1..e667876a4 100644
--- a/test-dts/findComponent.d-test.ts
+++ b/test-dts/findComponent.d-test.ts
@@ -1,5 +1,5 @@
 import { expectType } from './index'
-import { defineComponent } from 'vue'
+import { ComponentInstance, defineComponent } from 'vue'
 import { DOMWrapper, mount, VueWrapper } from '../src'
 import WrapperLike from '../src/interfaces/wrapperLike'
 
@@ -31,11 +31,13 @@ const wrapper = mount(AppWithDefine)
 
 // find by type - component definition
 const componentByType = wrapper.findComponent(ComponentToFind)
-expectType<VueWrapper<InstanceType<typeof ComponentToFind>>>(componentByType)
+expectType<VueWrapper<ComponentInstance<typeof ComponentToFind>>>(
+  componentByType
+)
 
 // find by type - component definition with emits
 const componentWithEmitsByType = wrapper.findComponent(ComponentWithEmits)
-expectType<VueWrapper<InstanceType<typeof ComponentWithEmits>>>(
+expectType<VueWrapper<ComponentInstance<typeof ComponentWithEmits>>>(
   componentWithEmitsByType
 )
 
@@ -50,7 +52,7 @@ expectType<WrapperLike>(componentByString)
 // findi by string with specifying component
 const componentByStringWithParam =
   wrapper.findComponent<typeof ComponentToFind>('.foo')
-expectType<VueWrapper<InstanceType<typeof ComponentToFind>>>(
+expectType<VueWrapper<ComponentInstance<typeof ComponentToFind>>>(
   componentByStringWithParam
 )
 
@@ -66,7 +68,7 @@ expectType<VueWrapper>(componentByRef)
 const componentByRefWithType = wrapper.findComponent<typeof ComponentToFind>({
   ref: 'foo'
 })
-expectType<VueWrapper<InstanceType<typeof ComponentToFind>>>(
+expectType<VueWrapper<ComponentInstance<typeof ComponentToFind>>>(
   componentByRefWithType
 )
 
@@ -78,6 +80,12 @@ expectType<VueWrapper>(componentByName)
 const componentByNameWithType = wrapper.findComponent<typeof ComponentToFind>({
   name: 'foo'
 })
-expectType<VueWrapper<InstanceType<typeof ComponentToFind>>>(
+
+
+declare const aaa : ComponentInstance<typeof ComponentToFind>
+aaa.$props
+componentByNameWithType.vm.$props
+
+expectType<VueWrapper<ComponentInstance<typeof ComponentToFind>>>(
   componentByNameWithType
 )
diff --git a/test-dts/mount.d-test.ts b/test-dts/mount.d-test.ts
index 5072a97cf..cfa1c5170 100644
--- a/test-dts/mount.d-test.ts
+++ b/test-dts/mount.d-test.ts
@@ -91,9 +91,9 @@ expectError(
 )
 
 const AppWithArrayProps = {
-  props: ['a'],
+  props: ['a'] as ['a'],
   template: ''
-} as const
+}
 
 // accept props - vm is properly typed
 expectType<string>(
@@ -168,7 +168,6 @@ mount(ShimComponent, {
   }
 })
 
-// TODO it should work
 mount(ShimComponent, {
   data() {
     return {
diff --git a/test-dts/shallowMount.d-test.ts b/test-dts/shallowMount.d-test.ts
index af9c5fa5c..eb769cced 100644
--- a/test-dts/shallowMount.d-test.ts
+++ b/test-dts/shallowMount.d-test.ts
@@ -65,9 +65,9 @@ expectError(
 )
 
 const AppWithArrayProps = {
-  props: ['a'],
+  props: ['a'] as ['a'],
   template: ''
-} as const
+}
 
 // accept props
 // vm is properly typed
diff --git a/test-dts/tsconfig.tsd.json b/test-dts/tsconfig.tsd.json
index f10ca8eb3..10a780a5c 100644
--- a/test-dts/tsconfig.tsd.json
+++ b/test-dts/tsconfig.tsd.json
@@ -3,14 +3,9 @@
   "compilerOptions": {
     "noEmit": false,
     "skipLibCheck": true,
-    "experimentalDecorators": true,
-    "strictNullChecks": false
+    "experimentalDecorators": true
+    // "strictNullChecks": false
   },
-  "exclude": [
-    "../src",
-  ],
-  "include": [
-    "../dist",
-    "../test-dts"
-  ]
+  "exclude": ["../src"],
+  "include": ["../dist", "../test-dts"]
 }
diff --git a/test-dts/wrapper.d-test.ts b/test-dts/wrapper.d-test.ts
index 1582f3d95..4d441d615 100644
--- a/test-dts/wrapper.d-test.ts
+++ b/test-dts/wrapper.d-test.ts
@@ -1,8 +1,11 @@
 import { expectType } from './index'
-import { defineComponent } from 'vue'
+import { SlotsType, defineComponent } from 'vue'
 import { mount } from '../src'
 
 const AppWithDefine = defineComponent({
+  emits: {
+    increment: (arg: { count: number }) => true
+  },
   template: ''
 })
 
@@ -65,10 +68,10 @@ expectType<Element | undefined>(byClassArray[0].element)
 
 // event name without specific type
 let incrementEventWithoutType = wrapper.emitted('increment')
-expectType<unknown[][] | undefined>(incrementEventWithoutType)
+expectType<{ count: number }[] | undefined>(incrementEventWithoutType)
 
 // event name
-let incrementEvent = wrapper.emitted<{ count: number }>('increment')
+let incrementEvent = wrapper.emitted('increment')
 expectType<{ count: number }[] | undefined>(incrementEvent)
 expectType<{ count: number }>(incrementEvent![0])
 
@@ -143,20 +146,18 @@ expectType<number | undefined>(propsWrapper.props('bar'))
 // @ts-expect-error :: unknown prop
 propsWrapper.props('badProp')
 
-const requiredPropsWrapper = mount(
-  defineComponent({
-    props: {
-      foo: { type: String, required: true },
-      bar: { type: Number, required: true }
-    }
-  }),
-  {
-    props: {
-      foo: 'abc',
-      bar: 123
-    }
+const c = defineComponent({
+  props: {
+    foo: { type: String, required: true },
+    bar: { type: Number, required: true }
   }
-)
+})
+const requiredPropsWrapper = mount(c, {
+  props: {
+    foo: 'abc',
+    bar: 123
+  }
+})
 
 requiredPropsWrapper.setProps({
   foo: 'abc'
@@ -166,3 +167,52 @@ requiredPropsWrapper.setProps({
   // @ts-expect-error wrong type
   foo: 1
 })
+
+// slots
+mount(
+  defineComponent({
+    slots: {} as SlotsType<{
+      default: (test: { foo: string }) => void
+    }>
+  }),
+  {
+    slots: {
+      default: 'test'
+    }
+  }
+)
+
+// slot type
+
+mount(
+  defineComponent({
+    slots: {} as SlotsType<{
+      default: (test: { foo: string }) => void
+    }>
+  }),
+  {
+    slots: {
+      // @ts-expect-error wrong type
+      nonExistent: 'test',
+
+      default: (test) => {
+        expectType<{ foo: string }>(test)
+        // @ts-expect-error not any
+        expectType<{ bar: any }>(test)
+      }
+    }
+  }
+)
+
+// required slots
+mount(
+  defineComponent({
+    slots: {} as SlotsType<{
+      default: (test: { foo: string }) => void
+    }>
+  }),
+  {
+    // @ts-expect-error missing required slot
+    slots: {}
+  }
+)
diff --git a/tests/emit.spec.ts b/tests/emit.spec.ts
index ffc4c6b4a..06eaab250 100644
--- a/tests/emit.spec.ts
+++ b/tests/emit.spec.ts
@@ -158,6 +158,7 @@ describe('emitted', () => {
 
     // Parent should emit custom event 'hello' but not 'hi'
     expect(wrapper.emitted().hello[0]).toEqual(['foo', 'bar'])
+    // @ts-expect-error `hi` is not a valid event
     expect(wrapper.emitted().hi).toEqual(undefined)
     // Child should emit custom event 'hi'
     expect(childWrapper.emitted().hi[0]).toEqual(['foo', 'bar'])
@@ -165,6 +166,7 @@ describe('emitted', () => {
     // Additional events should accumulate in the same format
     wrapper.find('button').trigger('click')
     expect(wrapper.emitted().hello[1]).toEqual(['foo', 'bar'])
+    // @ts-expect-error `hi` is not a valid event
     expect(wrapper.emitted().hi).toEqual(undefined)
     expect(childWrapper.emitted().hi[1]).toEqual(['foo', 'bar'])
   })
@@ -340,6 +342,7 @@ describe('emitted', () => {
     const wrapper = mount(EmitsEventSFC)
     await wrapper.trigger('click')
 
+    // @ts-expect-error `click` is not defined
     expect(wrapper.emitted().click).toHaveLength(1)
     expect(wrapper.emitted().bar).toHaveLength(2)
     expect(wrapper.emitted().bar[0]).toEqual(['mounted'])
@@ -350,6 +353,7 @@ describe('emitted', () => {
     const wrapper = mount(EmitsEventScriptSetup)
     await wrapper.trigger('click')
 
+    // @ts-expect-error `click` is not a valid event
     expect(wrapper.emitted().click).toHaveLength(1)
     expect(wrapper.emitted().bar).toHaveLength(2)
     expect(wrapper.emitted().bar[0]).toEqual(['mounted'])
diff --git a/tests/features/teleport.spec.ts b/tests/features/teleport.spec.ts
index 651495b32..6c71783bf 100644
--- a/tests/features/teleport.spec.ts
+++ b/tests/features/teleport.spec.ts
@@ -142,6 +142,8 @@ describe('teleport', () => {
     const withProps = wrapper.getComponent(EmitsEvent)
     withProps.trigger('click')
 
+    withProps.vm.$emit('greet')
+
     expect(withProps.emitted().greet[0]).toEqual(['Hey!'])
   })
 
diff --git a/tests/setData.spec.ts b/tests/setData.spec.ts
index 6e0edb35b..93955bf07 100644
--- a/tests/setData.spec.ts
+++ b/tests/setData.spec.ts
@@ -189,20 +189,18 @@ describe('setData', () => {
   })
 
   it('should keep Date object on setData', async () => {
-    const wrapper = mount(
-      defineComponent({
-        template: '<div/>',
-        props: { modelValue: Date },
-        data() {
-          return { value: this.modelValue }
-        }
-      }),
-      {
-        props: {
-          modelValue: new Date('2022-08-10T12:15:54Z')
-        }
+    const comp = defineComponent({
+      template: '<div/>',
+      props: { modelValue: Date },
+      data() {
+        return { value: this.modelValue }
       }
-    )
+    })
+    const wrapper = mount(comp, {
+      props: {
+        modelValue: new Date('2022-08-10T12:15:54Z')
+      }
+    })
 
     expect(wrapper.vm.value).toBeInstanceOf(Date)
     expect(wrapper.vm.value!.toISOString()).toBe('2022-08-10T12:15:54.000Z')
diff --git a/tests/setProps.spec.ts b/tests/setProps.spec.ts
index d58a7c7d7..bc287950a 100644
--- a/tests/setProps.spec.ts
+++ b/tests/setProps.spec.ts
@@ -23,7 +23,7 @@ describe('setProps', () => {
 
   it('updates a function prop', async () => {
     const Foo = {
-      props: ['obj'],
+      props: ['obj'] as ['obj'],
       template: `
         <div>
           <div v-if="obj.foo()">foo</div>
@@ -37,15 +37,15 @@ describe('setProps', () => {
         }
       }
     })
-    expect(wrapper.html()).toContain('foo')
 
+    expect(wrapper.html()).toContain('foo')
     await wrapper.setProps({ obj: { foo: () => false } })
     expect(wrapper.html()).not.toContain('foo')
   })
 
   it('sets component props, and updates DOM when props were not initially passed', async () => {
     const Foo = {
-      props: ['foo'],
+      props: ['foo'] as ['foo'],
       template: `
         <div>{{ foo }}</div>`
     }
@@ -126,11 +126,11 @@ describe('setProps', () => {
   it('allows using only on mounted component', async () => {
     const Foo = {
       name: 'Foo',
-      props: ['foo'],
+      props: ['foo'] as ['foo'],
       template: '<div>{{ foo }}</div>'
     }
     const Baz = {
-      props: ['baz'],
+      props: ['baz'] as ['baz'],
       template: '<div><Foo :foo="baz"/></div>',
       components: { Foo }
     }
@@ -141,6 +141,7 @@ describe('setProps', () => {
       }
     })
     const FooResult = wrapper.findComponent({ name: 'Foo' })
+
     expect(() => FooResult.setProps({ baz: 'bin' })).toThrowError(
       'You can only use setProps on your mounted component'
     )
diff --git a/tests/trigger.spec.ts b/tests/trigger.spec.ts
index 8293a3ca8..6b4173e1a 100644
--- a/tests/trigger.spec.ts
+++ b/tests/trigger.spec.ts
@@ -349,6 +349,7 @@ describe('trigger', () => {
 
   it('dispatches event', async () => {
     const Comp = defineComponent({
+      emits: ['enter'],
       template: `
         <input
           @keyup.enter="$emit('enter')"