type U2I<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I & U : never;

type Split<S extends string, Sep extends string, _Acc extends string = "", _Res extends string[] = []> =
  S extends `${infer C}${infer R}`
  ? C extends Sep
  ? Split<R, Sep, "", [..._Res, _Acc]>
  : Split<R, Sep, `${_Acc}${C}`, _Res>
  : _Acc extends ""
  ? _Res
  : [..._Res, _Acc]

type DeepPick_Impl<T, P extends string[]> = P extends [infer K, ...infer R]
  ? K extends keyof T
  ? R extends string[]
  ? { [P in K]: DeepPick_Impl<T[K], R> }
  : { [P in K]: T[K] }
  : unknown
  : T

type DeepPick<T, P extends string> = U2I<P extends P ? P extends ""?unknown: DeepPick_Impl<T, Split<P, ".">> : never>

import type { Equal, Expect } from '@type-challenges/utils'

type Obj = {
  a: number
  b: string
  c: boolean
  obj: {
    d: number
    e: string
    f: boolean
    obj2: {
      g: number
      h: string
      i: boolean
    }
  }
  obj3: {
    j: number
    k: string
    l: boolean
  }
}

type cases = [
  Expect<Equal<DeepPick<Obj, ''>, unknown >>,
  Expect<Equal<DeepPick<Obj, 'a'>, { a: number }>>,
  Expect<Equal<DeepPick<Obj, 'a' | 'obj.e'>, { a: number } & { obj: { e: string } }>>,
  Expect<Equal<DeepPick<Obj, 'a' | 'obj.e' | 'obj.obj2.i'>, { a: number } & { obj: { e: string } } & { obj: { obj2: { i: boolean } } }>>,
]