// use unique symbol to prevent collision
declare const unique: unique symbol

// use this type to "mark"(by union) a key so you can differentiate it and run extra operation on it
// in this case, key with this type will not union with null
type CannotBeNull = typeof unique

// find optional key by comparing X to Required<X>
type FindOptionalKey<T extends Record<string, unknown>> = Exclude<{ [K in keyof T]: T[K] extends Required<T>[K] ? never : K }[keyof T], undefined>

// Remove the optional key, we are going to rebuild them later
type OmitOptionalKey<T extends Record<string, unknown>> = Omit<T, FindOptionalKey<T>>

// Remove CannotBeNull after it serves its purpose
// also remove undefined type
type RemoveSpecialType<T> = Exclude<T, CannotBeNull | undefined>

// check whether the key is marked with CannotBeNull
// if so do not union with null
type IsUnionWithSpecialType<T> = Extract<T, CannotBeNull> extends never ? T | null: T

// Rebuild the omitted optional key
type RebuildOptionalKey<T extends Record<string, unknown>> = { [K in FindOptionalKey<T>]: RemoveSpecialType<IsUnionWithSpecialType<T[K]>> }

// just to make the type look nicer in hint, does not change the result or what so ever
// without it, the type look like OmitOptional<A> & { b:string, c: boolean | null } instead of  {a: number, b:string, c: boolean | null } 
type Prettify<T extends Record<string, unknown>> = { [K in keyof T]: T[K] }

// finally combine all the keys
type ConvertOptionalToNullUnion<T extends Record<string, unknown>> = Prettify<OmitOptionalKey<T> & RebuildOptionalKey<T>>

type A = {
   a: number;
   b?: string | CannotBeNull;
   c?: boolean;
}

type D = ConvertOptionalToNullUnion<A>

运动场