Playground：https://tsplay.dev/wOlQdN

// key mapping type: a recursive type
//    which maps 'key' to 'newKey' for renaming
//    or to ['newKey', Mapping] for deeper renaming
type Mapping<T> = {
    [K in keyof T]?: string | (
        T[K] extends Record<any, any> ? readonly [string, Mapping<T[K]>]
        : never
    )
}
// result of mapping
type Mapped<T, M extends Mapping<T>> = {
    [K in keyof M & keyof T // take keys
    as ( // and rename them
        | M[K] extends string ? M[K] // if mapping is string, to that string
        : M[K] extends readonly [infer P extends string, any] ? P // if mapping is tuple, to its first element
        : never
    )]: (
        | M[K] extends string ? T[K] // if mapping is string, keep original value
        : M[K] extends readonly [any, infer P extends Mapping<T[K]>] ? Mapped<T[K], P> // otherwise map it using 2nd tuple item
        : never
    )
}
// unwraps inferred types display to avoid intellisence saying `Mapped<T, M>` and to say `{ b: 1 }`
export type Debug<T> = T extends Record<any, any> ? { [K in keyof T]: Debug<T[K]> } : T
// advanced typings to reduce amount of `any` and `as any`. Feel free to use just `Object.fn` instead.
const recordEntries = Object.entries as <T>(o: T) => { [K in keyof T]: [K, T[K]] }[keyof T][]
const fromEntries = Object.fromEntries as <T extends readonly (readonly [any, any])[]>(a: T) => { [K in T[number][0]]: Extract<T[number], [K, any]>[1] }
function convert<T extends Record<string, any>, M extends Mapping<T>>(obj: T, mapping: M): Debug<Mapped<T, M>> {
    let entries = recordEntries(obj) // take [key, value] pairs
    let mappedEntries =
        entries.map(([key, value]) => { // map them
            let mapped = mapping[key]!
            if (typeof mapped === 'string') return [mapped, value] as const // changing key to mapping if it's a string
            else return [mapped[0], convert(value, mapped[1])] as const // changing key to mapping[0] and value to converted if it's a tuple
        })
    return fromEntries(mappedEntries) as any // the type for generic case can't be inferred, thus `as any` 
};
let test1 = convert(
    // ^?
    // let test1: { b: 1; }
    { a: 1 } as const,
    { a: 'b' } as const
)
console.log(test1)
let test2 = convert(
    // ^?
    // let test2: { aaa: { bbb: { ccc: { readonly d: 123; }; }; }; }
    { a: { b: { c: { d: 123 } } } } as const,
    { a: ['aaa', { b: ['bbb', { c: 'ccc' }] }] } as const
)
console.log(test2)