diff --git a/packages-private/dts-test/defineComponent.test-d.tsx b/packages-private/dts-test/defineComponent.test-d.tsx
index 9dc5bf87135..99b746b4a67 100644
--- a/packages-private/dts-test/defineComponent.test-d.tsx
+++ b/packages-private/dts-test/defineComponent.test-d.tsx
@@ -350,11 +350,9 @@ describe('with object props', () => {
       myProp: {
         type: Number,
         validator(val: unknown): boolean {
-          // @ts-expect-error
           return val !== this.otherProp
         },
         default(): number {
-          // @ts-expect-error
           return this.otherProp + 1
         },
       },
@@ -1091,7 +1089,7 @@ describe('emits', () => {
   })
 
   // emit should be valid when ComponentPublicInstance is used.
-  const instance = {} as ComponentPublicInstance
+  const instance = {} as ComponentPublicInstance<{}, {}, {}, {}, {}, string[]>
   instance.$emit('test', 1)
   instance.$emit('test')
 
@@ -1290,7 +1288,7 @@ describe('should allow to assign props', () => {
 
   const Parent = defineComponent({
     props: {
-      ...Child.props,
+      ...Child.props!,
       foo: String,
     },
   })
@@ -1667,37 +1665,17 @@ describe('expose typing', () => {
 })
 
 import type {
-  AllowedComponentProps,
-  ComponentCustomProps,
   ComponentInstance,
-  ComponentOptionsMixin,
   DefineComponent,
   Directive,
-  EmitsOptions,
-  ExtractPropTypes,
   KeepAliveProps,
   TransitionProps,
-  VNodeProps,
   vShow,
 } from 'vue'
 
 // code generated by tsc / vue-tsc, make sure this continues to work
 // so we don't accidentally change the args order of DefineComponent
-declare const MyButton: DefineComponent<
-  {},
-  () => JSX.Element,
-  {},
-  {},
-  {},
-  ComponentOptionsMixin,
-  ComponentOptionsMixin,
-  EmitsOptions,
-  string,
-  VNodeProps & AllowedComponentProps & ComponentCustomProps,
-  Readonly<ExtractPropTypes<{}>>,
-  {},
-  {}
->
+declare const MyButton: DefineComponent<{}, () => JSX.Element>
 ;<MyButton class="x" />
 
 describe('__typeProps backdoor for union type for conditional props', () => {
@@ -1881,7 +1859,7 @@ interface ErrorMessageSlotProps {
  * relying on legacy CreateComponentPublicInstance signature
  */
 declare const ErrorMessage: {
-  new (...args: any[]): vue.CreateComponentPublicInstance<
+  new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<
     Readonly<
       vue.ExtractPropTypes<{
         as: {
@@ -1922,8 +1900,8 @@ declare const ErrorMessage: {
     unknown,
     {},
     {},
-    vue.ComponentOptionsMixin,
-    vue.ComponentOptionsMixin,
+    {},
+    {},
     {},
     vue.VNodeProps &
       vue.AllowedComponentProps &
@@ -1945,58 +1923,7 @@ declare const ErrorMessage: {
     },
     true,
     {},
-    {},
-    {
-      P: {}
-      B: {}
-      D: {}
-      C: {}
-      M: {}
-      Defaults: {}
-    },
-    Readonly<
-      vue.ExtractPropTypes<{
-        as: {
-          type: StringConstructor
-          default: any
-        }
-        name: {
-          type: StringConstructor
-          required: true
-        }
-      }>
-    >,
-    () =>
-      | VNode<
-          vue.RendererNode,
-          vue.RendererElement,
-          {
-            [key: string]: any
-          }
-        >
-      | vue.Slot<any>
-      | VNode<
-          vue.RendererNode,
-          vue.RendererElement,
-          {
-            [key: string]: any
-          }
-        >[]
-      | {
-          default: () => VNode<
-            vue.RendererNode,
-            vue.RendererElement,
-            {
-              [key: string]: any
-            }
-          >[]
-        },
-    {},
-    {},
-    {},
-    {
-      as: string
-    }
+    {}
   >
   __isFragment?: never
   __isTeleport?: never
@@ -2042,8 +1969,8 @@ declare const ErrorMessage: {
   unknown,
   {},
   {},
-  vue.ComponentOptionsMixin,
-  vue.ComponentOptionsMixin,
+  {},
+  {},
   {},
   string,
   {
diff --git a/packages-private/dts-test/functionalComponent.test-d.tsx b/packages-private/dts-test/functionalComponent.test-d.tsx
index 04eda68b50a..253f1d79a84 100644
--- a/packages-private/dts-test/functionalComponent.test-d.tsx
+++ b/packages-private/dts-test/functionalComponent.test-d.tsx
@@ -59,14 +59,14 @@ expectType<JSX.Element>(<Bar foo={1} onUpdate={() => {}} />)
 //  @ts-expect-error
 ;<Foo baz="bar" />
 
-const Baz: FunctionalComponent<{}, string[]> = (props, { emit }) => {
+const Baz: FunctionalComponent = (props, { emit }) => {
   expectType<{}>(props)
   expectType<(event: string) => void>(emit)
 }
 
 expectType<Component>(Baz)
 
-const Qux: FunctionalComponent<{}, ['foo', 'bar']> = (props, { emit }) => {
+const Qux: FunctionalComponent<{}, ('foo' | 'bar')[]> = (props, { emit }) => {
   emit('foo')
   emit('foo', 1, 2)
   emit('bar')
@@ -77,7 +77,7 @@ expectType<Component>(Qux)
 
 const Quux: FunctionalComponent<
   {},
-  {},
+  string[],
   {
     default: { foo: number }
     optional?: { foo: number }
diff --git a/packages/runtime-core/__tests__/apiOptions.spec.ts b/packages/runtime-core/__tests__/apiOptions.spec.ts
index 1d4e805efce..56746a61702 100644
--- a/packages/runtime-core/__tests__/apiOptions.spec.ts
+++ b/packages/runtime-core/__tests__/apiOptions.spec.ts
@@ -3,6 +3,7 @@
  */
 import type { Mock } from 'vitest'
 import {
+  type ComponentOptions,
   type TestElement,
   computed,
   createApp,
@@ -930,6 +931,18 @@ describe('api: options', () => {
     expect(calls).toEqual(['base', 'mixin', 'comp'])
   })
 
+  test('extends type props', () => {
+    const Base = defineComponent({
+      __typeProps: {} as { a: number },
+    })
+    defineComponent({
+      extends: Base,
+      render() {
+        return `${this.a}`
+      },
+    })
+  })
+
   test('beforeCreate/created in extends and mixins', () => {
     const calls: string[] = []
     const BaseA = {
@@ -1060,7 +1073,7 @@ describe('api: options', () => {
       },
       data() {
         return {
-          plusOne: (this as any).count + 1,
+          plusOne: this.count + 1,
         }
       },
       computed: {
@@ -1414,7 +1427,7 @@ describe('api: options', () => {
     })
 
     test('computed with setter and no getter', () => {
-      const Comp = {
+      const Comp: ComponentOptions = {
         computed: {
           foo: {
             set() {},
@@ -1430,7 +1443,7 @@ describe('api: options', () => {
 
     test('assigning to computed with no setter', () => {
       let instance: any
-      const Comp = {
+      const Comp: ComponentOptions = {
         computed: {
           foo: {
             get() {},
@@ -1482,7 +1495,7 @@ describe('api: options', () => {
     })
 
     test('methods property is not a function', () => {
-      const Comp = {
+      const Comp: ComponentOptions = {
         methods: {
           foo: 1,
         },
diff --git a/packages/runtime-core/__tests__/componentProps.spec.ts b/packages/runtime-core/__tests__/componentProps.spec.ts
index ffae1085cd8..7f9ba9574c4 100644
--- a/packages/runtime-core/__tests__/componentProps.spec.ts
+++ b/packages/runtime-core/__tests__/componentProps.spec.ts
@@ -152,8 +152,11 @@ describe('component props', () => {
     render(
       h(Comp, {
         // absent should cast to false
+        // @ts-expect-error
         bar: '', // empty string should cast to true
+        // @ts-expect-error
         baz: 'baz', // same string should cast to true
+        // @ts-expect-error
         qux: 'ok', // other values should be left in-tact (but raise warning)
       }),
       nodeOps.createElement('div'),
@@ -206,17 +209,42 @@ describe('component props', () => {
     expect(proxy.bar).toBe(prevBar)
     expect(defaultFn).toHaveBeenCalledTimes(1)
 
-    render(h(Comp, { bar: { b: 2 } }), root)
+    render(
+      h(Comp, {
+        bar: {
+          // @ts-expect-error
+          b: 2,
+        },
+      }),
+      root,
+    )
     expect(proxy.foo).toBe(1)
     expect(proxy.bar).toEqual({ b: 2 })
     expect(defaultFn).toHaveBeenCalledTimes(1)
 
-    render(h(Comp, { foo: 3, bar: { b: 3 } }), root)
+    render(
+      h(Comp, {
+        foo: 3,
+        bar: {
+          // @ts-expect-error
+          b: 3,
+        },
+      }),
+      root,
+    )
     expect(proxy.foo).toBe(3)
     expect(proxy.bar).toEqual({ b: 3 })
     expect(defaultFn).toHaveBeenCalledTimes(1)
 
-    render(h(Comp, { bar: { b: 4 } }), root)
+    render(
+      h(Comp, {
+        bar: {
+          // @ts-expect-error
+          b: 4,
+        },
+      }),
+      root,
+    )
     expect(proxy.foo).toBe(1)
     expect(proxy.bar).toEqual({ b: 4 })
     expect(defaultFn).toHaveBeenCalledTimes(1)
@@ -420,13 +448,19 @@ describe('component props', () => {
     }
     render(
       h(Comp, {
+        // @ts-expect-error
         bool: 'true',
+        // @ts-expect-error
         str: 100,
+        // @ts-expect-error
         num: '100',
+        // @ts-expect-error
         arr: {},
         obj: 'false',
         cls: {},
+        // @ts-expect-error
         fn: true,
+        // @ts-expect-error
         skipCheck: 'foo',
         empty: [1, 2, 3],
       }),
diff --git a/packages/runtime-core/src/apiDefineComponent.ts b/packages/runtime-core/src/apiDefineComponent.ts
index e83715f6a39..04715530305 100644
--- a/packages/runtime-core/src/apiDefineComponent.ts
+++ b/packages/runtime-core/src/apiDefineComponent.ts
@@ -1,3 +1,21 @@
+import { extend, isFunction } from '@vue/shared'
+import type { ComponentTypeEmits } from './apiSetupHelpers'
+import type {
+  AllowedComponentProps,
+  Component,
+  ComponentCustomProps,
+  Data,
+  GlobalComponents,
+  GlobalDirectives,
+  SetupContext,
+} from './component'
+import type {
+  EmitsOptions,
+  EmitsToProps,
+  ObjectEmitsOptions,
+  ShortEmitsToObject,
+  TypeEmitsToOptions,
+} from './componentEmits'
 import type {
   ComponentInjectOptions,
   ComponentOptions,
@@ -6,47 +24,45 @@ import type {
   ComponentProvideOptions,
   ComputedOptions,
   MethodOptions,
+  ObjectInjectOptions,
   RenderFunction,
 } from './componentOptions'
-import type {
-  AllowedComponentProps,
-  Component,
-  ComponentCustomProps,
-  GlobalComponents,
-  GlobalDirectives,
-  SetupContext,
-} from './component'
 import type {
   ComponentObjectPropsOptions,
   ComponentPropsOptions,
   ExtractDefaultPropTypes,
   ExtractPropTypes,
 } from './componentProps'
-import type {
-  EmitsOptions,
-  EmitsToProps,
-  TypeEmitsToOptions,
-} from './componentEmits'
-import { type IsKeyValues, extend, isFunction } from '@vue/shared'
-import type { VNodeProps } from './vnode'
-import type {
-  ComponentPublicInstanceConstructor,
-  CreateComponentPublicInstanceWithMixins,
-} from './componentPublicInstance'
+import type { CreateComponentPublicInstanceWithMixins } from './componentPublicInstance'
 import type { SlotsType } from './componentSlots'
 import type { Directive } from './directives'
-import type { ComponentTypeEmits } from './apiSetupHelpers'
+import type { VNodeProps } from './vnode'
 
 export type PublicProps = VNodeProps &
   AllowedComponentProps &
   ComponentCustomProps
 
-type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<
-  PropsOrPropOptions extends ComponentPropsOptions
-    ? ExtractPropTypes<PropsOrPropOptions>
-    : PropsOrPropOptions
-> &
-  ({} extends E ? {} : EmitsToProps<E>)
+export interface ComponentOptionsSchema {
+  setup(): unknown
+  data(): unknown
+  props: ComponentPropsOptions
+  computed: ComputedOptions
+  methods: MethodOptions
+  mixins: ComponentOptionsMixin[]
+  extends: ComponentOptionsMixin
+  emits: EmitsOptions
+  slots: SlotsType
+  inject: ComponentInjectOptions
+  components: Record<string, Component>
+  directives: Record<string, Directive>
+  provide: ComponentProvideOptions
+  expose: string
+  __defaults: unknown
+  __typeProps: unknown
+  __typeEmits: unknown
+  __typeRefs: Data
+  __typeEl: Element
+}
 
 export type DefineComponent<
   PropsOrPropOptions = {},
@@ -54,12 +70,12 @@ export type DefineComponent<
   D = {},
   C extends ComputedOptions = ComputedOptions,
   M extends MethodOptions = MethodOptions,
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
   E extends EmitsOptions = {},
-  EE extends string = string,
-  PP = PublicProps,
-  Props = ResolveProps<PropsOrPropOptions, E>,
+  EE = never,
+  PP = never,
+  Props = never,
   Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>,
   S extends SlotsType = {},
   LC extends Record<string, Component> = {},
@@ -69,52 +85,143 @@ export type DefineComponent<
   MakeDefaultsOptional extends boolean = true,
   TypeRefs extends Record<string, unknown> = {},
   TypeEl extends Element = any,
-> = ComponentPublicInstanceConstructor<
-  CreateComponentPublicInstanceWithMixins<
-    Props,
-    RawBindings,
-    D,
-    C,
-    M,
+> = InferComponent<
+  {
+    setup(): RawBindings
+    data(): unknown extends D ? {} : D
+    props: PropsOrPropOptions extends ComponentPropsOptions
+      ? PropsOrPropOptions
+      : {}
+    computed: C
+    methods: M
+    mixins: Mixin[]
+    extends: Extends
+    emits: Record<string, unknown> extends E ? {} : E
+    slots: S
+    inject: {}
+    components: LC
+    directives: Directives
+    provide: Provide
+    expose: Exposed
+    __defaults: Defaults
+    __typeProps: PropsOrPropOptions extends ComponentPropsOptions
+      ? unknown
+      : PropsOrPropOptions
+    __typeEmits: unknown
+    __typeRefs: TypeRefs
+    __typeEl: TypeEl
+  },
+  MakeDefaultsOptional,
+  false
+>
+
+export type DefineComponent2<T extends ComponentOptionsSchema> = InferComponent<
+  T,
+  // MakeDefaultsOptional - if TypeProps is provided, set to false to use
+  // user props types verbatim
+  unknown extends T['__typeProps'] ? true : false,
+  true
+>
+
+type InferComponent<
+  T extends ComponentOptionsSchema,
+  MakeDefaultsOptional extends boolean,
+  StrictEmits extends boolean,
+  // resolved types
+  Mixin extends ComponentOptionsMixin = T['mixins'][number],
+  Extends extends ComponentOptionsMixin = T['extends'],
+  ResolvedEmits extends ObjectEmitsOptions = ResolveEmitsOptions<
+    T['emits'],
+    T['__typeEmits']
+  >,
+  ResolvedTypeEmits = ResolveTypeEmits<T['emits'], T['__typeEmits']>,
+  InferredProps = Readonly<
+    ExtractPropTypes<
+      unknown extends T['__typeProps']
+        ? T['props'] extends (infer Keys extends string)[]
+          ? { [K in Keys]: null }
+          : T['props']
+        : {}
+    > &
+      T['__typeProps'] &
+      EmitsToProps<
+        ResolvedEmits &
+          TypeEmitsToOptions<
+            string[] extends T['emits']
+              ? T['__typeEmits'] & {}
+              : ResolvedTypeEmits & {}
+          >
+      >
+  >,
+> = ComponentOptionsBase<
+  any,
+  ReturnType<T['setup']>,
+  ReturnType<T['data']>,
+  T['computed'],
+  T['methods'],
+  T['mixins'][number] & {},
+  T['extends'] & {},
+  T['emits'],
+  never,
+  never,
+  {},
+  never,
+  T['slots'],
+  T['components'] & GlobalComponents,
+  T['directives'] & GlobalDirectives,
+  T['expose'],
+  T['provide']
+> & {
+  props?: T['props']
+  __typeProps?: T['__typeProps']
+  __typeEmits?: T['__typeEmits']
+
+  /**
+   * #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 ReturnType<T['data']>
+    | keyof T['computed']
+    | keyof T['methods']
+
+  new (
+    ...args: any[]
+  ): CreateComponentPublicInstanceWithMixins<
+    InferredProps,
+    ReturnType<T['setup']>,
+    ReturnType<T['data']>,
+    T['computed'],
+    T['methods'],
     Mixin,
     Extends,
-    E,
-    PP,
-    Defaults,
+    ResolvedEmits,
+    PublicProps,
+    unknown extends T['__defaults']
+      ? ExtractDefaultPropTypes<T['props']>
+      : T['__defaults'],
     MakeDefaultsOptional,
-    {},
-    S,
-    LC & GlobalComponents,
-    Directives & GlobalDirectives,
-    Exposed,
-    TypeRefs,
-    TypeEl
+    T['inject'],
+    T['slots'],
+    T['components'] & GlobalComponents,
+    T['directives'] & GlobalDirectives,
+    T['expose'],
+    T['__typeRefs'],
+    T['__typeEl'],
+    T['provide'],
+    ResolvedTypeEmits,
+    StrictEmits,
+    any
   >
-> &
-  ComponentOptionsBase<
-    Props,
-    RawBindings,
-    D,
-    C,
-    M,
-    Mixin,
-    Extends,
-    E,
-    EE,
-    Defaults,
-    {},
-    string,
-    S,
-    LC & GlobalComponents,
-    Directives & GlobalDirectives,
-    Exposed,
-    Provide
-  > &
-  PP
+}
 
 export type DefineSetupFnComponent<
   P extends Record<string, any>,
-  E extends EmitsOptions = {},
+  E extends EmitsOptions = string[],
   S extends SlotsType = SlotsType,
   Props = P & EmitsToProps<E>,
   PP = PublicProps,
@@ -126,8 +233,8 @@ export type DefineSetupFnComponent<
   {},
   {},
   {},
-  ComponentOptionsMixin,
-  ComponentOptionsMixin,
+  {},
+  {},
   E,
   PP,
   {},
@@ -136,8 +243,27 @@ export type DefineSetupFnComponent<
   S
 >
 
-type ToResolvedProps<Props, Emits extends EmitsOptions> = Readonly<Props> &
-  Readonly<EmitsToProps<Emits>>
+type ResolveEmitsOptions<
+  RuntimeEmitsOptions extends EmitsOptions,
+  TypeEmits extends ComponentTypeEmits | unknown,
+> = unknown extends TypeEmits
+  ? RuntimeEmitsOptions extends ObjectEmitsOptions
+    ? RuntimeEmitsOptions
+    : {}
+  : TypeEmits extends Record<string, any[]>
+    ? ShortEmitsToObject<TypeEmits>
+    : {}
+
+type ResolveTypeEmits<
+  RuntimeEmitsOptions extends EmitsOptions,
+  TypeEmits extends ComponentTypeEmits | unknown,
+> = TypeEmits extends (...args: any[]) => any
+  ? TypeEmits
+  : TypeEmits extends Record<string, any[]>
+    ? {}
+    : RuntimeEmitsOptions extends (infer Keys extends string)[]
+      ? (event: Keys, ...args: any[]) => void
+      : {}
 
 // defineComponent is a utility that is primarily used for type inference
 // when declaring components. Type inference is provided in the component
@@ -148,7 +274,7 @@ type ToResolvedProps<Props, Emits extends EmitsOptions> = Readonly<Props> &
 // (uses user defined props interface)
 export function defineComponent<
   Props extends Record<string, any>,
-  E extends EmitsOptions = {},
+  E extends EmitsOptions = string[],
   EE extends string = string,
   S extends SlotsType = {},
 >(
@@ -164,7 +290,7 @@ export function defineComponent<
 ): DefineSetupFnComponent<Props, E, S>
 export function defineComponent<
   Props extends Record<string, any>,
-  E extends EmitsOptions = {},
+  E extends EmitsOptions = string[],
   EE extends string = string,
   S extends SlotsType = {},
 >(
@@ -181,45 +307,63 @@ export function defineComponent<
 
 // overload 2: defineComponent with options object, infer props from options
 export function defineComponent<
-  // props
   TypeProps,
-  RuntimePropsOptions extends
-    ComponentObjectPropsOptions = ComponentObjectPropsOptions,
-  RuntimePropsKeys extends string = string,
-  // emits
-  TypeEmits extends ComponentTypeEmits = {},
-  RuntimeEmitsOptions extends EmitsOptions = {},
-  RuntimeEmitsKeys extends string = string,
-  // other options
+  TypeEmits extends ComponentTypeEmits | unknown = unknown,
+  TypeRefs extends Record<string, unknown> = {},
+  TypeEl extends Element = any,
+  Defaults = unknown,
+  RawPropsOptions extends ComponentPropsOptions = {},
+  RawEmitsOptions extends EmitsOptions = string[],
+  InjectOptions extends ComponentInjectOptions = {},
   Data = {},
   SetupBindings = {},
   Computed extends ComputedOptions = {},
   Methods extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
-  InjectOptions extends ComponentInjectOptions = {},
-  InjectKeys extends string = string,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
   Slots extends SlotsType = {},
   LocalComponents extends Record<string, Component> = {},
   Directives extends Record<string, Directive> = {},
+  Provide extends ComponentProvideOptions = {},
   Exposed extends string = string,
-  Provide extends ComponentProvideOptions = ComponentProvideOptions,
+  // assisted input inference
+  _PropsKeys extends string = string,
+  _EmitsKeys extends string = string,
+  _InjectKeys extends string = string,
   // resolved types
-  ResolvedEmits extends EmitsOptions = {} extends RuntimeEmitsOptions
-    ? TypeEmitsToOptions<TypeEmits>
-    : RuntimeEmitsOptions,
-  InferredProps = IsKeyValues<TypeProps> extends true
-    ? TypeProps
-    : string extends RuntimePropsKeys
-      ? ComponentObjectPropsOptions extends RuntimePropsOptions
-        ? {}
-        : ExtractPropTypes<RuntimePropsOptions>
-      : { [key in RuntimePropsKeys]?: any },
-  TypeRefs extends Record<string, unknown> = {},
-  TypeEl extends Element = any,
+  NormalizedProps extends
+    ComponentPropsOptions = ComponentPropsOptions extends RawPropsOptions
+    ? {}
+    : RawPropsOptions,
+  NormalizedEmits extends EmitsOptions = EmitsOptions extends RawEmitsOptions
+    ? string[]
+    : RawEmitsOptions,
+  ResolvedEmits extends ObjectEmitsOptions = ResolveEmitsOptions<
+    NormalizedEmits,
+    TypeEmits
+  >,
+  ResolvedTypeEmits = ResolveTypeEmits<NormalizedEmits, TypeEmits>,
+  InferredProps = Readonly<
+    ExtractPropTypes<
+      unknown extends TypeProps
+        ? NormalizedProps extends (infer Keys extends string)[]
+          ? { [K in Keys]: null }
+          : NormalizedProps
+        : {}
+    > &
+      TypeProps &
+      EmitsToProps<
+        ResolvedEmits &
+          TypeEmitsToOptions<
+            string[] extends NormalizedEmits
+              ? TypeEmits & {}
+              : ResolvedTypeEmits & {}
+          >
+      >
+  >,
 >(
   options: {
-    props?: (RuntimePropsOptions & ThisType<void>) | RuntimePropsKeys[]
+    props?: ComponentObjectPropsOptions | RawPropsOptions | _PropsKeys[]
     /**
      * @private for language-tools use only
      */
@@ -236,28 +380,41 @@ export function defineComponent<
      * @private for language-tools use only
      */
     __typeEl?: TypeEl
+    /**
+     * @private for language-tools use only
+     */
+    __defaults?: Defaults
   } & ComponentOptionsBase<
-    ToResolvedProps<InferredProps, ResolvedEmits>,
+    InferredProps,
     SetupBindings,
     Data,
     Computed,
     Methods,
     Mixin,
     Extends,
-    RuntimeEmitsOptions,
-    RuntimeEmitsKeys,
-    {}, // Defaults
-    InjectOptions,
-    InjectKeys,
+    ObjectEmitsOptions | (RawEmitsOptions & ThisType<void>) | _EmitsKeys[],
+    never,
+    never,
+    ObjectInjectOptions | InjectOptions | _InjectKeys[],
+    never,
     Slots,
-    LocalComponents,
-    Directives,
+    Record<string, Component> | LocalComponents,
+    Record<string, Directive> | Directives,
     Exposed,
-    Provide
+    Provide,
+    CreateComponentPublicInstanceWithMixins<
+      InferredProps,
+      SetupBindings,
+      {},
+      {},
+      MethodOptions,
+      Mixin,
+      Extends
+    >
   > &
     ThisType<
       CreateComponentPublicInstanceWithMixins<
-        ToResolvedProps<InferredProps, ResolvedEmits>,
+        InferredProps,
         SetupBindings,
         Data,
         Computed,
@@ -265,40 +422,45 @@ export function defineComponent<
         Mixin,
         Extends,
         ResolvedEmits,
-        {},
-        {},
+        {}, // PublicProps
+        {}, // Defaults
         false,
         InjectOptions,
         Slots,
-        LocalComponents,
-        Directives,
-        string
-      >
+        {},
+        {},
+        string, // Exposed
+        TypeRefs,
+        TypeEl,
+        {},
+        ResolvedTypeEmits,
+        true,
+        {}
+      > & {
+        $options: typeof options
+      }
     >,
-): DefineComponent<
-  InferredProps,
-  SetupBindings,
-  Data,
-  Computed,
-  Methods,
-  Mixin,
-  Extends,
-  ResolvedEmits,
-  RuntimeEmitsKeys,
-  PublicProps,
-  ToResolvedProps<InferredProps, ResolvedEmits>,
-  ExtractDefaultPropTypes<RuntimePropsOptions>,
-  Slots,
-  LocalComponents,
-  Directives,
-  Exposed,
-  Provide,
-  // MakeDefaultsOptional - if TypeProps is provided, set to false to use
-  // user props types verbatim
-  unknown extends TypeProps ? true : false,
-  TypeRefs,
-  TypeEl
->
+): DefineComponent2<{
+  setup(): SetupBindings
+  data(): Data
+  props: NormalizedProps
+  computed: Computed
+  methods: Methods
+  mixins: Mixin[]
+  extends: Extends
+  emits: NormalizedEmits
+  slots: Slots
+  inject: {} // omitted
+  components: LocalComponents
+  directives: Directives
+  provide: Provide
+  expose: Exposed
+  __typeProps: TypeProps
+  __typeEmits: TypeEmits
+  __typeRefs: TypeRefs
+  __typeEl: TypeEl
+  __defaults: Defaults
+}>
 
 // implementation, close to no-op
 /*@__NO_SIDE_EFFECTS__*/
diff --git a/packages/runtime-core/src/apiSetupHelpers.ts b/packages/runtime-core/src/apiSetupHelpers.ts
index 5c77497bc60..752652d4ccc 100644
--- a/packages/runtime-core/src/apiSetupHelpers.ts
+++ b/packages/runtime-core/src/apiSetupHelpers.ts
@@ -193,8 +193,8 @@ export function defineOptions<
   D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
 >(
   options?: ComponentOptionsBase<
     {},
@@ -206,6 +206,10 @@ export function defineOptions<
     Extends,
     {}
   > & {
+    /**
+     * setup should be defined via `<script setup>`.
+     */
+    setup?: never
     /**
      * props should be defined via defineProps().
      */
diff --git a/packages/runtime-core/src/compat/instance.ts b/packages/runtime-core/src/compat/instance.ts
index 0c5dd14d79c..12e0fd0fa65 100644
--- a/packages/runtime-core/src/compat/instance.ts
+++ b/packages/runtime-core/src/compat/instance.ts
@@ -39,7 +39,14 @@ import { resolveFilter } from '../helpers/resolveAssets'
 import type { Slots } from '../componentSlots'
 import { resolveMergedOptions } from '../componentOptions'
 
-export type LegacyPublicInstance = ComponentPublicInstance &
+export type LegacyPublicInstance = ComponentPublicInstance<
+  {},
+  {},
+  {},
+  {},
+  {},
+  string[]
+> &
   LegacyPublicProperties
 
 export interface LegacyPublicProperties {
diff --git a/packages/runtime-core/src/component.ts b/packages/runtime-core/src/component.ts
index 88faf6306a9..419ca6a901a 100644
--- a/packages/runtime-core/src/component.ts
+++ b/packages/runtime-core/src/component.ts
@@ -116,8 +116,8 @@ export type Data = Record<string, unknown>
  */
 export type ComponentInstance<T> = T extends { new (): ComponentPublicInstance }
   ? InstanceType<T>
-  : T extends FunctionalComponent<infer Props, infer Emits>
-    ? ComponentPublicInstance<Props, {}, {}, {}, {}, ShortEmitsToObject<Emits>>
+  : T extends FunctionalComponent<infer Props, any, any, infer Emits>
+    ? ComponentPublicInstance<Props, {}, {}, {}, {}, Emits>
     : T extends Component<
           infer PropsOrInstance,
           infer RawBindings,
@@ -250,17 +250,17 @@ export interface AsyncComponentInternalOptions<
 
 export interface FunctionalComponent<
   P = {},
-  E extends EmitsOptions | Record<string, any[]> = {},
+  E extends EmitsOptions | Record<string, any[]> = string[],
   S extends Record<string, any> = any,
   EE extends EmitsOptions = ShortEmitsToObject<E>,
 > extends ComponentInternalOptions {
   // use of any here is intentional so it can be a valid JSX Element constructor
   (
-    props: P & EmitsToProps<EE>,
+    props: P & EmitsToProps<string[] extends E ? {} : EE>,
     ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>,
   ): any
   props?: ComponentPropsOptions<P>
-  emits?: EE | (keyof EE)[]
+  emits?: EE extends string[] ? EE : (keyof EE)[] | EE
   slots?: IfAny<S, Slots, SlotsType<S>>
   inheritAttrs?: boolean
   displayName?: string
@@ -295,10 +295,18 @@ export type ConcreteComponent<
   D = any,
   C extends ComputedOptions = ComputedOptions,
   M extends MethodOptions = MethodOptions,
-  E extends EmitsOptions | Record<string, any[]> = {},
+  E extends EmitsOptions | Record<string, any[]> = string[],
   S extends Record<string, any> = any,
 > =
-  | ComponentOptions<Props, RawBindings, D, C, M>
+  | ComponentOptions<
+      Props,
+      RawBindings,
+      D,
+      C,
+      M,
+      ComponentOptions,
+      ComponentOptions
+    >
   | FunctionalComponent<Props, E, S>
 
 /**
@@ -311,7 +319,7 @@ export type Component<
   D = any,
   C extends ComputedOptions = ComputedOptions,
   M extends MethodOptions = MethodOptions,
-  E extends EmitsOptions | Record<string, any[]> = {},
+  E extends EmitsOptions | Record<string, any[]> = string[],
   S extends Record<string, any> = any,
 > =
   | ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S>
@@ -323,13 +331,13 @@ export type LifecycleHook<TFn = Function> = (TFn & SchedulerJob)[] | null
 
 // use `E extends any` to force evaluating type to fix #2362
 export type SetupContext<
-  E = EmitsOptions,
+  E extends EmitsOptions | Record<string, any[]> = EmitsOptions,
   S extends SlotsType = {},
 > = E extends any
   ? {
       attrs: Data
       slots: UnwrapSlotsType<S>
-      emit: EmitFn<E>
+      emit: EmitFn<ShortEmitsToObject<E>>
       expose: <Exposed extends Record<string, any> = Record<string, any>>(
         exposed?: Exposed,
       ) => void
diff --git a/packages/runtime-core/src/componentEmits.ts b/packages/runtime-core/src/componentEmits.ts
index f92d722bacb..50108a74fa7 100644
--- a/packages/runtime-core/src/componentEmits.ts
+++ b/packages/runtime-core/src/componentEmits.ts
@@ -1,5 +1,6 @@
 import {
   EMPTY_OBJ,
+  type IfAny,
   type OverloadParameters,
   type UnionToIntersection,
   camelize,
@@ -92,14 +93,18 @@ export type ShortEmitsToObject<E> =
     : E
 
 export type EmitFn<
-  Options = ObjectEmitsOptions,
+  Options extends EmitsOptions = ObjectEmitsOptions,
   Event extends keyof Options = keyof Options,
-> =
-  Options extends Array<infer V>
+> = EmitsOptions extends Options
+  ? keyof Options extends never
+    ? {}
+    : (event: string, ...args: any[]) => void
+  : Options extends (infer V)[]
     ? (event: V, ...args: any[]) => void
-    : {} extends Options // if the emit is empty object (usually the default value for emit) should be converted to function
-      ? (event: string, ...args: any[]) => void
-      : UnionToIntersection<
+    : IfAny<
+        Event,
+        {},
+        UnionToIntersection<
           {
             [key in Event]: Options[key] extends (...args: infer Args) => any
               ? (event: key, ...args: Args) => void
@@ -108,6 +113,7 @@ export type EmitFn<
                 : (event: key, ...args: any[]) => void
           }[Event]
         >
+      >
 
 export function emit(
   instance: ComponentInternalInstance,
diff --git a/packages/runtime-core/src/componentOptions.ts b/packages/runtime-core/src/componentOptions.ts
index d2e9616a089..38ecf32fc2c 100644
--- a/packages/runtime-core/src/componentOptions.ts
+++ b/packages/runtime-core/src/componentOptions.ts
@@ -64,8 +64,9 @@ import type { Directive } from './directives'
 import {
   type ComponentPublicInstance,
   type CreateComponentPublicInstanceWithMixins,
-  type IntersectionMixin,
-  type UnwrapMixinsType,
+  type ExtractMixinEmits,
+  type ExtractMixinProps,
+  type ExtractMixinTypeProps,
   isReservedPrefix,
 } from './componentPublicInstance'
 import { warn } from './warning'
@@ -125,7 +126,8 @@ export interface ComponentOptionsBase<
   Directives extends Record<string, Directive> = {},
   Exposed extends string = string,
   Provide extends ComponentProvideOptions = ComponentProvideOptions,
-> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II, Provide>,
+  DataVM = any,
+> extends LegacyOptions<DataVM, D, C, M, Mixin, Extends, I, Provide>,
     ComponentInternalOptions,
     AsyncComponentInternalOptions,
     ComponentCustomOptions {
@@ -133,12 +135,12 @@ export interface ComponentOptionsBase<
     this: void,
     props: LooseRequired<
       Props &
-        Prettify<
-          UnwrapMixinsType<
-            IntersectionMixin<Mixin> & IntersectionMixin<Extends>,
-            'P'
-          >
-        >
+        ExtractPropTypes<
+          ExtractMixinProps<Mixin> & ExtractMixinProps<Extends>
+        > &
+        ExtractMixinTypeProps<Mixin> &
+        ExtractMixinTypeProps<Extends> &
+        EmitsToProps<ExtractMixinEmits<Mixin> & ExtractMixinEmits<Extends> & {}>
     >,
     ctx: SetupContext<E, S>,
   ) => Promise<RawBindings> | RawBindings | RenderFunction | void
@@ -150,14 +152,10 @@ export interface ComponentOptionsBase<
   // Luckily `render()` doesn't need any arguments nor does it care about return
   // type.
   render?: Function
-  // NOTE: extending both LC and Record<string, Component> allows objects to be forced
-  // to be of type Component, while still inferring LC generic
-  components?: LC & Record<string, Component>
-  // NOTE: extending both Directives and Record<string, Directive> allows objects to be forced
-  // to be of type Directive, while still inferring Directives generic
-  directives?: Directives & Record<string, Directive>
+  components?: LC
+  directives?: Directives
   inheritAttrs?: boolean
-  emits?: (E | EE[]) & ThisType<void>
+  emits?: E
   slots?: S
   expose?: Exposed[]
   serverPrefetch?(): void | Promise<any>
@@ -203,8 +201,6 @@ export interface ComponentOptionsBase<
   __isFragment?: never
   __isTeleport?: never
   __isSuspense?: never
-
-  __defaults?: Defaults
 }
 
 /**
@@ -223,8 +219,8 @@ export type ComponentOptions<
   D = any,
   C extends ComputedOptions = any,
   M extends MethodOptions = any,
-  Mixin extends ComponentOptionsMixin = any,
-  Extends extends ComponentOptionsMixin = any,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
   E extends EmitsOptions = any,
   EE extends string = string,
   Defaults = {},
@@ -249,8 +245,8 @@ export type ComponentOptions<
   I,
   II,
   S,
-  LC,
-  Directives,
+  Record<string, ComponentOptions> | LC,
+  Record<string, Directive> | Directives,
   Exposed,
   Provide
 > &
@@ -274,26 +270,6 @@ export type ComponentOptions<
     >
   >
 
-export type ComponentOptionsMixin = ComponentOptionsBase<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
->
-
 export type ComputedOptions = Record<
   string,
   ComputedGetter<any> | WritableComputedOptions<any>
@@ -327,7 +303,7 @@ type ObjectProvideOptions = Record<string | symbol, unknown>
 
 export type ComponentInjectOptions = string[] | ObjectInjectOptions
 
-type ObjectInjectOptions = Record<
+export type ObjectInjectOptions = Record<
   string | symbol,
   string | symbol | { from?: string | symbol; default?: unknown }
 >
@@ -344,14 +320,13 @@ export type InjectToObject<T extends ComponentInjectOptions> =
       : never
 
 interface LegacyOptions<
-  Props,
+  DataVM,
   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
@@ -359,35 +334,12 @@ interface LegacyOptions<
   // allow any custom options
   [key: string]: any
 
-  // state
-  // Limitation: we cannot expose RawBindings on the `this` context for data
-  // since that leads to some sort of circular inference and breaks ThisType
-  // for the entire component.
-  data?: (
-    this: CreateComponentPublicInstanceWithMixins<
-      Props,
-      {},
-      {},
-      {},
-      MethodOptions,
-      Mixin,
-      Extends
-    >,
-    vm: CreateComponentPublicInstanceWithMixins<
-      Props,
-      {},
-      {},
-      {},
-      MethodOptions,
-      Mixin,
-      Extends
-    >,
-  ) => D
+  data?: (this: DataVM, vm: DataVM) => D
   computed?: C
   methods?: M
   watch?: ComponentWatchOptions
   provide?: Provide
-  inject?: I | II[]
+  inject?: I
 
   // assets
   filters?: Record<string, Function>
@@ -420,16 +372,6 @@ interface LegacyOptions<
    * @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[]
@@ -457,24 +399,6 @@ export type MergedComponentOptionsOverride = {
   errorCaptured?: MergedHook<ErrorCapturedHook>
 }
 
-export type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults'
-
-export type OptionTypesType<
-  P = {},
-  B = {},
-  D = {},
-  C extends ComputedOptions = {},
-  M extends MethodOptions = {},
-  Defaults = {},
-> = {
-  P: P
-  B: B
-  D: D
-  C: C
-  M: M
-  Defaults: Defaults
-}
-
 enum OptionTypes {
   PROPS = 'Props',
   DATA = 'Data',
@@ -959,9 +883,7 @@ export function mergeOptions(
     mergeOptions(to, extendsOptions, strats, true)
   }
   if (mixins) {
-    mixins.forEach((m: ComponentOptionsMixin) =>
-      mergeOptions(to, m, strats, true),
-    )
+    mixins.forEach((m: {}) => mergeOptions(to, m, strats, true))
   }
 
   for (const key in from) {
@@ -1103,6 +1025,11 @@ function mergeWatchOptions(
 
 // Deprecated legacy types, kept because they were previously exported ---------
 
+/**
+ * @deprecated
+ */
+export type ComponentOptionsMixin = {}
+
 /**
  * @deprecated
  */
@@ -1112,9 +1039,9 @@ export type ComponentOptionsWithoutProps<
   D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
-  E extends EmitsOptions = {},
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
+  E extends EmitsOptions = string[],
   EE extends string = string,
   I extends ComponentInjectOptions = {},
   II extends string = string,
@@ -1186,8 +1113,8 @@ export type ComponentOptionsWithArrayProps<
   D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
   E extends EmitsOptions = EmitsOptions,
   EE extends string = string,
   I extends ComponentInjectOptions = {},
@@ -1248,8 +1175,8 @@ export type ComponentOptionsWithObjectProps<
   D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
   E extends EmitsOptions = EmitsOptions,
   EE extends string = string,
   I extends ComponentInjectOptions = {},
diff --git a/packages/runtime-core/src/componentPublicInstance.ts b/packages/runtime-core/src/componentPublicInstance.ts
index 1ee758be0ff..8ad7136d968 100644
--- a/packages/runtime-core/src/componentPublicInstance.ts
+++ b/packages/runtime-core/src/componentPublicInstance.ts
@@ -44,18 +44,20 @@ import {
   type InjectToObject,
   type MergedComponentOptionsOverride,
   type MethodOptions,
-  type OptionTypesKeys,
-  type OptionTypesType,
   resolveMergedOptions,
   shouldCacheAccess,
 } from './componentOptions'
-import type { EmitFn, EmitsOptions } from './componentEmits'
+import type { EmitFn, EmitsOptions, EmitsToProps } from './componentEmits'
 import type { SlotsType, UnwrapSlotsType } from './componentSlots'
 import { markAttrsAccessed } from './componentRenderUtils'
 import { currentRenderingInstance } from './componentRenderContext'
 import { warn } from './warning'
 import { installCompatInstanceProperties } from './compat/instance'
 import type { Directive } from './directives'
+import type {
+  ExtractDefaultPropTypes,
+  ExtractPropTypes,
+} from './componentProps'
 
 /**
  * Custom properties added to component instances in any way and can be accessed through `this`
@@ -84,68 +86,45 @@ import type { Directive } from './directives'
  */
 export interface ComponentCustomProperties {}
 
-type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin
-  ? ComponentOptionsMixin extends T
-    ? true
-    : false
-  : false
-
-type MixinToOptionTypes<T> =
-  T extends ComponentOptionsBase<
-    infer P,
-    infer B,
-    infer D,
-    infer C,
-    infer M,
-    infer Mixin,
-    infer Extends,
-    any,
-    any,
-    infer Defaults,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  >
-    ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> &
-        IntersectionMixin<Mixin> &
-        IntersectionMixin<Extends>
-    : never
-
-// ExtractMixin(map type) is used to resolve circularly references
-type ExtractMixin<T> = {
-  Mixin: MixinToOptionTypes<T>
-}[T extends ComponentOptionsMixin ? 'Mixin' : never]
-
-export type IntersectionMixin<T> =
-  IsDefaultMixinComponent<T> extends true
-    ? OptionTypesType
-    : UnionToIntersection<ExtractMixin<T>>
-
-export type UnwrapMixinsType<
-  T,
-  Type extends OptionTypesKeys,
-> = T extends OptionTypesType ? T[Type] : never
+export type ExtractMixinProps<T> = UnionToIntersection<
+  T extends { props?: infer P }
+    ? P extends (infer K extends string)[]
+      ? { [key in K]: null }
+      : P
+    : {}
+>
 
-type EnsureNonVoid<T> = T extends void ? {} : T
+export type ExtractMixinTypeProps<T> = UnionToIntersection<
+  T extends { __typeProps?: infer P } ? P : {}
+>
 
-export type ComponentPublicInstanceConstructor<
-  T extends ComponentPublicInstance<
-    Props,
-    RawBindings,
-    D,
-    C,
-    M
-  > = ComponentPublicInstance<any>,
-  Props = any,
-  RawBindings = any,
-  D = any,
-  C extends ComputedOptions = ComputedOptions,
-  M extends MethodOptions = MethodOptions,
-> = {
+export type ExtractMixinEmits<T> = UnionToIntersection<
+  T extends { emits?: infer E }
+    ? E extends (infer K extends string)[]
+      ? { [key in K]: (...args: any) => any }
+      : E
+    : {}
+>
+
+export type ExtractMixinMethods<T> = UnionToIntersection<
+  T extends { methods?: infer M } ? M : {}
+>
+
+export type ExtractMixinComputed<T> = UnionToIntersection<
+  T extends { computed?: infer C } ? C : {}
+>
+
+export type ExtractMixinData<T> = UnionToIntersection<
+  T extends { data?(...args: any): infer P } ? P : {}
+>
+
+export type ExtractMixinSetupBindings<T> = UnionToIntersection<
+  T extends { setup?(...args: any): infer B } ? B : {}
+>
+
+export type EnsureNonVoid<T> = T extends void ? {} : T
+
+export interface ComponentPublicInstanceConstructor<T> {
   __isFragment?: never
   __isTeleport?: never
   __isSuspense?: never
@@ -162,24 +141,31 @@ export type CreateComponentPublicInstance<
   D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
-  E extends EmitsOptions = {},
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
+  E extends EmitsOptions = string[],
   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>,
+  PublicP = ExtractPropTypes<
+    ExtractMixinProps<Mixin> & ExtractMixinProps<Extends>
+  > &
+    P,
+  PublicB = ExtractMixinSetupBindings<Mixin> &
+    ExtractMixinSetupBindings<Extends> &
+    EnsureNonVoid<B>,
+  PublicD = ExtractMixinData<Mixin> &
+    ExtractMixinData<Extends> &
+    EnsureNonVoid<D>,
+  PublicC extends ComputedOptions = ExtractMixinComputed<Mixin> &
+    ExtractMixinComputed<Extends> &
+    C,
+  PublicM extends MethodOptions = ExtractMixinMethods<Mixin> &
+    ExtractMixinMethods<Extends> &
+    M,
+  PublicDefaults = {} & Defaults,
 > = ComponentPublicInstance<
   PublicP,
   PublicB,
@@ -222,9 +208,9 @@ export type CreateComponentPublicInstanceWithMixins<
   D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
-  E extends EmitsOptions = {},
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
+  E extends EmitsOptions = string[],
   PublicProps = P,
   Defaults = {},
   MakeDefaultsOptional extends boolean = false,
@@ -236,17 +222,33 @@ export type CreateComponentPublicInstanceWithMixins<
   TypeRefs extends Data = {},
   TypeEl extends Element = any,
   Provide extends ComponentProvideOptions = ComponentProvideOptions,
+  TypeEmits = unknown,
+  StrictEmits extends boolean = false,
+  Options = any,
   // mixin inference
-  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>,
+  PublicP = Readonly<
+    ExtractPropTypes<ExtractMixinProps<Mixin> & ExtractMixinProps<Extends>> &
+      ExtractMixinTypeProps<Mixin> &
+      ExtractMixinTypeProps<Extends> &
+      EmitsToProps<ExtractMixinEmits<Mixin> & ExtractMixinEmits<Extends> & {}>
+  > &
+    P,
+  PublicB = ExtractMixinSetupBindings<Mixin> &
+    ExtractMixinSetupBindings<Extends> &
+    EnsureNonVoid<B>,
+  PublicD = ExtractMixinData<Mixin> &
+    ExtractMixinData<Extends> &
+    EnsureNonVoid<D>,
+  PublicC extends ComputedOptions = ExtractMixinComputed<Mixin> &
+    ExtractMixinComputed<Extends> &
+    C,
+  PublicM extends MethodOptions = ExtractMixinMethods<Mixin> &
+    ExtractMixinMethods<Extends> &
+    M,
+  PublicDefaults = ExtractDefaultPropTypes<
+    ExtractMixinProps<Mixin> & ExtractMixinProps<Extends>
+  > &
+    Defaults,
 > = ComponentPublicInstance<
   PublicP,
   PublicB,
@@ -257,30 +259,14 @@ export type CreateComponentPublicInstanceWithMixins<
   PublicProps,
   PublicDefaults,
   MakeDefaultsOptional,
-  ComponentOptionsBase<
-    P,
-    B,
-    D,
-    C,
-    M,
-    Mixin,
-    Extends,
-    E,
-    string,
-    Defaults,
-    {},
-    string,
-    S,
-    LC,
-    Directives,
-    Exposed,
-    Provide
-  >,
+  Options,
   I,
   S,
   Exposed,
   TypeRefs,
-  TypeEl
+  TypeEl,
+  TypeEmits,
+  StrictEmits
 >
 
 export type ExposedKeys<
@@ -296,16 +282,18 @@ export type ComponentPublicInstance<
   D = {}, // return from data()
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  E extends EmitsOptions = {},
+  E extends EmitsOptions = string[],
   PublicProps = {},
   Defaults = {},
   MakeDefaultsOptional extends boolean = false,
-  Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>,
+  Options = any,
   I extends ComponentInjectOptions = {},
   S extends SlotsType = {},
   Exposed extends string = '',
   TypeRefs extends Data = {},
   TypeEl extends Element = any,
+  TypeEmits = {},
+  StrictEmits extends boolean = false,
 > = {
   $: ComponentInternalInstance
   $data: D
@@ -318,7 +306,8 @@ export type ComponentPublicInstance<
   $root: ComponentPublicInstance | null
   $parent: ComponentPublicInstance | null
   $host: Element | null
-  $emit: EmitFn<E>
+  $emit: EmitFn<StrictEmits extends true ? E : {} extends E ? string[] : E> &
+    TypeEmits
   $el: TypeEl
   $options: Options & MergedComponentOptionsOverride
   $forceUpdate: () => void
diff --git a/packages/runtime-core/src/h.ts b/packages/runtime-core/src/h.ts
index adc984563b2..b4a98cb1458 100644
--- a/packages/runtime-core/src/h.ts
+++ b/packages/runtime-core/src/h.ts
@@ -1,3 +1,13 @@
+import { type IfAny, isArray, isObject } from '@vue/shared'
+import type { Component, FunctionalComponent } from './component'
+import type { EmitsOptions } from './componentEmits'
+import type {
+  ComponentObjectPropsOptions,
+  ExtractPublicPropTypes,
+} from './componentProps'
+import type { Suspense, SuspenseProps } from './components/Suspense'
+import type { Teleport, TeleportProps } from './components/Teleport'
+import type { RawSlots } from './componentSlots'
 import {
   type Comment,
   type Fragment,
@@ -9,18 +19,6 @@ import {
   isVNode,
   setBlockTracking,
 } from './vnode'
-import type { Teleport, TeleportProps } from './components/Teleport'
-import type { Suspense, SuspenseProps } from './components/Suspense'
-import { type IfAny, isArray, isObject } from '@vue/shared'
-import type { RawSlots } from './componentSlots'
-import type {
-  Component,
-  ComponentOptions,
-  ConcreteComponent,
-  FunctionalComponent,
-} from './component'
-import type { EmitsOptions } from './componentEmits'
-import type { DefineComponent } from './apiDefineComponent'
 
 // `h` is a more user-friendly version of `createVNode` that allows omitting the
 // props when possible. It is intended for manually written render functions.
@@ -86,12 +84,12 @@ type HTMLElementEventHandler = {
 // manually written render functions.
 
 // element
-export function h<K extends keyof HTMLElementTagNameMap>(
-  type: K,
+export function h(
+  type: keyof HTMLElementTagNameMap,
   children?: RawChildren,
 ): VNode
-export function h<K extends keyof HTMLElementTagNameMap>(
-  type: K,
+export function h(
+  type: keyof HTMLElementTagNameMap,
   props?: (RawProps & HTMLElementEventHandler) | null,
   children?: RawChildren | RawSlots,
 ): VNode
@@ -140,55 +138,40 @@ export function h(
 // functional component
 export function h<
   P,
-  E extends EmitsOptions = {},
+  E extends EmitsOptions = string[],
   S extends Record<string, any> = any,
 >(
   type: FunctionalComponent<P, any, S, any>,
-  props?: (RawProps & P) | ({} extends P ? null : never),
-  children?: RawChildren | IfAny<S, RawSlots, S>,
+  props?: NoInfer<(RawProps & P) | ({} extends P ? null : never)>,
+  children?: NoInfer<RawChildren | IfAny<S, RawSlots, S>>,
 ): VNode
 
 // catch-all for generic component types
 export function h(type: Component, children?: RawChildren): VNode
 
-// concrete component
-export function h<P>(
-  type: ConcreteComponent | string,
-  children?: RawChildren,
-): VNode
-export function h<P>(
-  type: ConcreteComponent<P> | string,
-  props?: (RawProps & P) | ({} extends P ? null : never),
-  children?: RawChildren,
-): VNode
-
-// component without props
-export function h<P>(
-  type: Component<P>,
-  props?: (RawProps & P) | null,
-  children?: RawChildren | RawSlots,
-): VNode
-
-// exclude `defineComponent` constructors
-export function h<P>(
-  type: ComponentOptions<P>,
-  props?: (RawProps & P) | ({} extends P ? null : never),
-  children?: RawChildren | RawSlots,
-): VNode
-
 // fake constructor type returned by `defineComponent` or class component
 export function h(type: Constructor, children?: RawChildren): VNode
 export function h<P>(
   type: Constructor<P>,
-  props?: (RawProps & P) | ({} extends P ? null : never),
+  props?: NoInfer<(RawProps & P) | ({} extends P ? null : never)>,
   children?: RawChildren | RawSlots,
 ): VNode
 
-// fake constructor type returned by `defineComponent`
-export function h(type: DefineComponent, children?: RawChildren): VNode
-export function h<P>(
-  type: DefineComponent<P>,
-  props?: (RawProps & P) | ({} extends P ? null : never),
+// export function h(type: { props: any }, children?: RawChildren): VNode
+export function h<
+  P extends string,
+  PP = ExtractPublicPropTypes<{ [K in P]: null }>,
+>(
+  type: { props: P[] },
+  props?: NoInfer<(RawProps & PP) | ({} extends PP ? null : never)>,
+  children?: RawChildren | RawSlots,
+): VNode
+export function h<
+  P extends ComponentObjectPropsOptions,
+  PP = ExtractPublicPropTypes<P>,
+>(
+  type: { props: P },
+  props?: NoInfer<(RawProps & PP) | ({} extends PP ? null : never)>,
   children?: RawChildren | RawSlots,
 ): VNode
 
@@ -196,7 +179,7 @@ export function h<P>(
 export function h(type: string | Component, children?: RawChildren): VNode
 export function h<P>(
   type: string | Component<P>,
-  props?: (RawProps & P) | ({} extends P ? null : never),
+  props?: NoInfer<(RawProps & P) | ({} extends P ? null : never)>,
   children?: RawChildren | RawSlots,
 ): VNode
 
diff --git a/packages/runtime-core/src/index.ts b/packages/runtime-core/src/index.ts
index 58f6f40b9f0..6d57a13007d 100644
--- a/packages/runtime-core/src/index.ts
+++ b/packages/runtime-core/src/index.ts
@@ -280,6 +280,7 @@ export type {
 } from './component'
 export type {
   DefineComponent,
+  DefineComponent2,
   DefineSetupFnComponent,
   PublicProps,
 } from './apiDefineComponent'
@@ -294,6 +295,7 @@ export type {
   ComputedOptions,
   RuntimeCompilerOptions,
   ComponentInjectOptions,
+  ObjectInjectOptions,
   // deprecated
   ComponentOptionsWithoutProps,
   ComponentOptionsWithArrayProps,
@@ -307,6 +309,7 @@ export type {
   EmitFn,
 } from './componentEmits'
 export type {
+  ExtractMixinProps,
   ComponentPublicInstance,
   ComponentCustomProperties,
   CreateComponentPublicInstance,
diff --git a/packages/runtime-core/src/vnode.ts b/packages/runtime-core/src/vnode.ts
index db7f6fcfbc6..2c9dbd2aa48 100644
--- a/packages/runtime-core/src/vnode.ts
+++ b/packages/runtime-core/src/vnode.ts
@@ -93,7 +93,7 @@ export type VNodeRef =
   | ((
       ref: Element | ComponentPublicInstance | null,
       refs: Record<string, any>,
-    ) => void)
+    ) => unknown)
 
 export type VNodeNormalizedRefAtom = {
   /**
diff --git a/packages/runtime-dom/__tests__/customElement.spec.ts b/packages/runtime-dom/__tests__/customElement.spec.ts
index 1225326abc5..9cb1d78fb40 100644
--- a/packages/runtime-dom/__tests__/customElement.spec.ts
+++ b/packages/runtime-dom/__tests__/customElement.spec.ts
@@ -4,6 +4,7 @@ import {
   type Ref,
   Teleport,
   type VueElement,
+  type VueElementConstructor,
   createApp,
   defineAsyncComponent,
   defineComponent,
@@ -1268,7 +1269,7 @@ describe('defineCustomElement', () => {
     })
 
     test('set DOM property before resolve', async () => {
-      const E = defineCustomElement(
+      const E: VueElementConstructor<any> = defineCustomElement(
         defineAsyncComponent(() => {
           return Promise.resolve({
             props: ['msg'],
diff --git a/packages/runtime-dom/src/apiCustomElement.ts b/packages/runtime-dom/src/apiCustomElement.ts
index 596e03112ba..8ed592d8c1c 100644
--- a/packages/runtime-dom/src/apiCustomElement.ts
+++ b/packages/runtime-dom/src/apiCustomElement.ts
@@ -6,20 +6,19 @@ import {
   type ComponentObjectPropsOptions,
   type ComponentOptions,
   type ComponentOptionsBase,
-  type ComponentOptionsMixin,
   type ComponentProvideOptions,
-  type ComponentPublicInstance,
   type ComputedOptions,
   type ConcreteComponent,
   type CreateAppFunction,
   type CreateComponentPublicInstanceWithMixins,
-  type DefineComponent,
   type Directive,
-  type EmitsOptions,
   type EmitsToProps,
+  type ExtractMixinProps,
   type ExtractPropTypes,
   type GenericComponentInstance,
   type MethodOptions,
+  type ObjectEmitsOptions,
+  type ObjectInjectOptions,
   type RenderFunction,
   type SetupContext,
   type SlotsType,
@@ -33,6 +32,7 @@ import {
   warn,
 } from '@vue/runtime-core'
 import {
+  type Prettify,
   camelize,
   extend,
   hasOwn,
@@ -41,7 +41,7 @@ import {
   isPlainObject,
   toNumber,
 } from '@vue/shared'
-import { createApp, createSSRApp, render } from '.'
+import { type ComponentOptionsMixin, createApp, createSSRApp, render } from '.'
 
 // marker for attr removal
 const REMOVAL = {}
@@ -80,89 +80,91 @@ export function defineCustomElement<Props, RawBindings = object>(
 // overload 2: defineCustomElement with options object, infer props from options
 export function defineCustomElement<
   // props
-  RuntimePropsOptions extends
-    ComponentObjectPropsOptions = ComponentObjectPropsOptions,
-  PropsKeys extends string = string,
+  RuntimePropsOptions extends ComponentObjectPropsOptions = {},
   // emits
-  RuntimeEmitsOptions extends EmitsOptions = {},
-  EmitsKeys extends string = string,
+  RuntimeEmitsOptions extends ObjectEmitsOptions = {},
   // other options
   Data = {},
   SetupBindings = {},
   Computed extends ComputedOptions = {},
   Methods extends MethodOptions = {},
-  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
-  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Mixin extends ComponentOptionsMixin = {},
+  Extends extends ComponentOptionsMixin = {},
   InjectOptions extends ComponentInjectOptions = {},
-  InjectKeys extends string = string,
   Slots extends SlotsType = {},
   LocalComponents extends Record<string, Component> = {},
   Directives extends Record<string, Directive> = {},
   Exposed extends string = string,
   Provide extends ComponentProvideOptions = ComponentProvideOptions,
+  // assisted input types
+  _PropsKeys extends string = string,
+  _EmitsKeys extends string = string,
+  _InjectKeys extends string = string,
   // resolved types
-  InferredProps = string extends PropsKeys
-    ? ComponentObjectPropsOptions extends RuntimePropsOptions
-      ? {}
-      : ExtractPropTypes<RuntimePropsOptions>
-    : { [key in PropsKeys]?: any },
+  InferredProps = RuntimePropsOptions extends (infer Keys extends string)[]
+    ? { [K in Keys]?: any }
+    : ExtractPropTypes<RuntimePropsOptions>,
   ResolvedProps = InferredProps & EmitsToProps<RuntimeEmitsOptions>,
+  PublicP = ResolvedProps &
+    Prettify<
+      ExtractPropTypes<ExtractMixinProps<Mixin> & ExtractMixinProps<Extends>>
+    >,
+  InternalInstance = CreateComponentPublicInstanceWithMixins<
+    Readonly<ResolvedProps>,
+    SetupBindings,
+    Data,
+    Computed,
+    Methods,
+    Mixin,
+    Extends,
+    RuntimeEmitsOptions,
+    _EmitsKeys,
+    {},
+    false,
+    InjectOptions,
+    Slots,
+    LocalComponents,
+    Directives,
+    Exposed
+  >,
 >(
   options: CustomElementOptions & {
-    props?: (RuntimePropsOptions & ThisType<void>) | PropsKeys[]
+    props?:
+      | ComponentObjectPropsOptions
+      | (RuntimePropsOptions & ThisType<void>)
+      | _PropsKeys[]
   } & ComponentOptionsBase<
-      ResolvedProps,
+      InferredProps,
       SetupBindings,
       Data,
       Computed,
       Methods,
       Mixin,
       Extends,
-      RuntimeEmitsOptions,
-      EmitsKeys,
-      {}, // Defaults
-      InjectOptions,
-      InjectKeys,
+      | ObjectEmitsOptions
+      | (RuntimeEmitsOptions & ThisType<void>)
+      | _EmitsKeys[],
+      never,
+      never,
+      ObjectInjectOptions | InjectOptions | _InjectKeys[],
+      never,
       Slots,
       LocalComponents,
       Directives,
       Exposed,
-      Provide
+      Provide,
+      InternalInstance
     > &
-    ThisType<
-      CreateComponentPublicInstanceWithMixins<
-        Readonly<ResolvedProps>,
-        SetupBindings,
-        Data,
-        Computed,
-        Methods,
-        Mixin,
-        Extends,
-        RuntimeEmitsOptions,
-        EmitsKeys,
-        {},
-        false,
-        InjectOptions,
-        Slots,
-        LocalComponents,
-        Directives,
-        Exposed
-      >
-    >,
+    ThisType<NoInfer<InternalInstance>>,
   extraOptions?: CustomElementOptions,
 ): VueElementConstructor<ResolvedProps>
 
 // overload 3: defining a custom element from the returned value of
 // `defineComponent`
-export function defineCustomElement<
-  // this should be `ComponentPublicInstanceConstructor` but that type is not exported
-  T extends { new (...args: any[]): ComponentPublicInstance<any> },
->(
-  options: T,
+export function defineCustomElement<P>(
+  options: { props?: P },
   extraOptions?: CustomElementOptions,
-): VueElementConstructor<
-  T extends DefineComponent<infer P, any, any, any> ? P : unknown
->
+): VueElementConstructor<ExtractPropTypes<P>>
 
 /*@__NO_SIDE_EFFECTS__*/
 export function defineCustomElement(
diff --git a/packages/shared/src/typeUtils.ts b/packages/shared/src/typeUtils.ts
index f5b9e6ec3c8..1fd161ceb05 100644
--- a/packages/shared/src/typeUtils.ts
+++ b/packages/shared/src/typeUtils.ts
@@ -13,12 +13,6 @@ export type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] }
 // https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
 export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N
 
-export type IsKeyValues<T, K = string> = IfAny<
-  T,
-  false,
-  T extends object ? (keyof T extends K ? true : false) : false
->
-
 /**
  * Utility for extracting the parameters from a function overload (for typed emits)
  * https://github.com/microsoft/TypeScript/issues/32164#issuecomment-1146737709