Qfyilyi

type Old = Other & {rewrite:number};

type New = Old & {rewrite:string};

Exected behavior:

type of New: Other & {rewrite:string}

Actual behavior:

type of New: Other & {rewrite:string & number}

This is the by design behavior of intersection types. If the property exists on both members of the intersection the resulting property type will be an intersection of the original types.

To replace a property, we can first exclude it from the original type using Pick and Exclude:

type Omit<T, TKey extends keyof T> = Pick<T, Exclude<keyof T, TKey>>



type Other = { a: number };

type Old = Other & {rewrite:number};

type New = Omit<Old, 'rewrite'> & {rewrite:string};

let n: New;

n.rewrite // string 

n.a // number

We can ecen create a generic type to do the replacement if this is a common scenario:

type Omit<T, TKey extends keyof T> = Pick<T, Exclude<keyof T, TKey>>



type Other = { a: number };

type Old = Other & {rewrite:number, rewrite2:number};

type Replace<T, TKey extends keyof T, TKeyType> = Omit<T, TKey> & Record<TKey, TKeyType>

type New = Replace<Old, 'rewrite', string>   // replace one

type New2 = Replace<Old, 'rewrite' | 'rewrite2', string> // replace more