diff --git a/src/mount.ts b/src/mount.ts
index 9d20d703c..2d83869b9 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -13,6 +13,10 @@ import {
   ComponentOptionsWithoutProps,
   ExtractPropTypes,
   Component,
+  WritableComputedOptions,
+  SetupContext,
+  RenderFunction,
+  ComponentPropsOptions,
   AppConfig,
   VNodeProps
 } from 'vue'
@@ -37,8 +41,8 @@ type SlotDictionary = {
   [key: string]: Slot
 }
 
-interface MountingOptions<Props> {
-  data?: () => Record<string, unknown>
+interface MountingOptions<Props, Data = {}> {
+  data?: () => Data extends object ? Partial<Data> : never
   props?: Props
   attrs?: Record<string, unknown>
   slots?: SlotDictionary & {
@@ -49,40 +53,116 @@ interface MountingOptions<Props> {
   shallow?: boolean
 }
 
-// TODO improve the typings of the overloads
-
-type ExtractComponent<T> = T extends { new (): infer PublicInstance }
-  ? PublicInstance
-  : any
+export type ComputedOptions = Record<
+  string,
+  ((ctx?: any) => any) | WritableComputedOptions<any>
+>
+export type ObjectEmitsOptions = Record<
+  string,
+  ((...args: any[]) => any) | null
+>
+export type EmitsOptions = ObjectEmitsOptions | string[]
 
 // Functional component
-export function mount<TestedComponent extends FunctionalComponent>(
+export function mount<
+  TestedComponent extends FunctionalComponent<Props>,
+  Props
+>(
   originalComponent: TestedComponent,
-  options?: MountingOptions<any>
-): VueWrapper<ComponentPublicInstance>
+  options?: MountingOptions<Props>
+): VueWrapper<ComponentPublicInstance<Props>>
+
 // Component declared with defineComponent
 export function mount<TestedComponent extends ComponentPublicInstance>(
   originalComponent: { new (): TestedComponent } & Component,
-  options?: MountingOptions<TestedComponent['$props']>
+  options?: MountingOptions<TestedComponent['$props'], TestedComponent['$data']>
 ): VueWrapper<TestedComponent>
-// Component declared with { props: { ... } }
-export function mount<TestedComponent extends ComponentOptionsWithObjectProps>(
-  originalComponent: TestedComponent,
-  options?: MountingOptions<ExtractPropTypes<TestedComponent['props'], false>>
-): VueWrapper<ExtractComponent<TestedComponent>>
-// Component declared with { props: [] }
-export function mount<TestedComponent extends ComponentOptionsWithArrayProps>(
-  originalComponent: TestedComponent,
-  options?: MountingOptions<Record<string, any>>
-): VueWrapper<ExtractComponent<TestedComponent>>
+
 // Component declared with no props
 export function mount<
-  TestedComponent extends ComponentOptionsWithoutProps,
-  ComponentT extends ComponentOptionsWithoutProps & {}
+  Props = {},
+  RawBindings = {},
+  D = {},
+  C extends ComputedOptions = {},
+  M extends Record<string, Function> = {},
+  E extends EmitsOptions = Record<string, any>,
+  EE extends string = string
+>(
+  componentOptions: ComponentOptionsWithoutProps<
+    Props,
+    RawBindings,
+    D,
+    C,
+    M,
+    E,
+    EE
+  >,
+  options?: MountingOptions<never, D>
+): VueWrapper<
+  ComponentPublicInstance<Props, RawBindings, D, C, M, E, VNodeProps & Props>
+>
+
+// Component declared with { props: [] }
+export function mount<
+  PropNames extends string,
+  RawBindings,
+  D,
+  C extends ComputedOptions = {},
+  M extends Record<string, Function> = {},
+  E extends EmitsOptions = Record<string, any>,
+  EE extends string = string,
+  Props extends Readonly<{ [key in PropNames]?: any }> = Readonly<
+    { [key in PropNames]?: any }
+  >
+>(
+  componentOptions: ComponentOptionsWithArrayProps<
+    PropNames,
+    RawBindings,
+    D,
+    C,
+    M,
+    E,
+    EE,
+    Props
+  >,
+  options?: MountingOptions<Props, D>
+): VueWrapper<ComponentPublicInstance<Props, RawBindings, D, C, M, E>>
+
+// Component declared with { props: { ... } }
+export function mount<
+  // the Readonly constraint allows TS to treat the type of { required: true }
+  // as constant instead of boolean.
+  PropsOptions extends Readonly<ComponentPropsOptions>,
+  RawBindings,
+  D,
+  C extends ComputedOptions = {},
+  M extends Record<string, Function> = {},
+  E extends EmitsOptions = Record<string, any>,
+  EE extends string = string
 >(
-  originalComponent: ComponentT extends { new (): any } ? never : ComponentT,
-  options?: MountingOptions<never>
-): VueWrapper<ExtractComponent<TestedComponent>>
+  componentOptions: ComponentOptionsWithObjectProps<
+    PropsOptions,
+    RawBindings,
+    D,
+    C,
+    M,
+    E,
+    EE
+  >,
+  options?: MountingOptions<ExtractPropTypes<PropsOptions>, D>
+): VueWrapper<
+  ComponentPublicInstance<
+    ExtractPropTypes<PropsOptions>,
+    RawBindings,
+    D,
+    C,
+    M,
+    E,
+    VNodeProps & ExtractPropTypes<PropsOptions, false>
+  >
+>
+
+// implementation
 export function mount(
   originalComponent: any,
   options?: MountingOptions<any>
diff --git a/test-dts/mount.d-test.ts b/test-dts/mount.d-test.ts
index eda62aace..d8274e10d 100644
--- a/test-dts/mount.d-test.ts
+++ b/test-dts/mount.d-test.ts
@@ -13,12 +13,23 @@ const AppWithDefine = defineComponent({
   template: ''
 })
 
-// accept props
-let wrapper = mount(AppWithDefine, {
-  props: { a: 'Hello', b: 2 }
-})
-// vm is properly typed
-expectType<string>(wrapper.vm.a)
+// accept props- vm is properly typed
+expectType<string>(
+  mount(AppWithDefine, {
+    props: { a: 'Hello', b: 2 }
+  }).vm.a
+)
+
+// no data provided
+expectError(
+  mount(AppWithDefine, {
+    data() {
+      return {
+        myVal: 1
+      }
+    }
+  })
+)
 
 // can receive extra props
 // ideally, it should not
@@ -45,12 +56,12 @@ const AppWithProps = {
   template: ''
 }
 
-// accept props
-wrapper = mount(AppWithProps, {
-  props: { a: 'Hello' }
-})
-// vm is properly typed
-expectType<string>(wrapper.vm.a)
+// accept props - vm is properly typed
+expectType<string>(
+  mount(AppWithProps, {
+    props: { a: 'Hello' }
+  }).vm.a
+)
 
 // can't receive extra props
 expectError(
@@ -71,18 +82,35 @@ const AppWithArrayProps = {
   template: ''
 }
 
-// accept props
-wrapper = mount(AppWithArrayProps, {
-  props: { a: 'Hello' }
-})
-// vm is properly typed
-expectType<string>(wrapper.vm.a)
+// accept props - vm is properly typed
+expectType<string>(
+  mount(AppWithArrayProps, {
+    props: { a: 'Hello' }
+  }).vm.a
+)
 
 // can receive extra props
 // as they are declared as `string[]`
-mount(AppWithArrayProps, {
-  props: { a: 'Hello', b: 2 }
-})
+expectType<number>(
+  mount(AppWithArrayProps, {
+    props: { a: 'Hello', b: 2 }
+  }).vm.b
+)
+
+// cannot receive extra props
+// if they pass use object inside
+expectError(
+  mount(
+    {
+      props: ['a']
+    },
+    {
+      props: {
+        b: 2
+      }
+    }
+  )
+)
 
 const AppWithoutProps = {
   template: ''
@@ -90,12 +118,29 @@ const AppWithoutProps = {
 
 // can't receive extra props
 expectError(
-  (wrapper = mount(AppWithoutProps, {
+  mount(AppWithoutProps, {
     props: { b: 'Hello' }
-  }))
+  })
 )
 
 // except if explicitly cast
 mount(AppWithoutProps, {
   props: { b: 'Hello' } as never
 })
+
+// Functional tests
+
+// wrong props
+expectError((props: { a: 1 }) => {}, {
+  props: {
+    a: '222'
+  }
+})
+
+expectType<number>(
+  mount((props: { a: 1 }, ctx) => {}, {
+    props: {
+      a: 22
+    }
+  }).vm.a
+)
diff --git a/test-dts/shallowMount.d-test.ts b/test-dts/shallowMount.d-test.ts
index ade13dfdd..38326997f 100644
--- a/test-dts/shallowMount.d-test.ts
+++ b/test-dts/shallowMount.d-test.ts
@@ -46,11 +46,12 @@ const AppWithProps = {
 }
 
 // accept props
-wrapper = shallowMount(AppWithProps, {
-  props: { a: 'Hello' }
-})
 // vm is properly typed
-expectType<string>(wrapper.vm.a)
+expectType<string>(
+  shallowMount(AppWithProps, {
+    props: { a: 'Hello' }
+  }).vm.a
+)
 
 // can't receive extra props
 expectError(