Type Alias DeepOverride<T, U>

DeepOverride: [T] extends [never]
    ? U
    : [U] extends [never]
        ? T
        : T extends any[]
            ? U
            : U extends any[]
                ? U
                : T extends object
                    ? U extends object
                        ? {
                            [K in keyof (T & U)]: K extends keyof U
                                ? DeepOverride<
                                    K extends keyof (...) ? (...)[(...)] : never,
                                    U[(...) & (...)],
                                >
                                : K extends keyof T ? T[K] : never
                        }
                        : T
                    : U

DeepOverride ----------- * For two object types T (base) and U (override), produce a new type where keys present in U replace those in T; nested objects are recursed. Arrays and primitives are replaced wholesale.

If T is never, we fall back to U (used when no explicit EventType is provided).
If U is never, we keep T.

Type Parameters

T
base type to be overridden
U
override type whose keys replace the base

Example

type A = { x: { a: number }, y: string };
type B = { x: { a: string }, z: boolean };
// => { x: { a: string }, y: string, z: boolean }
type R = DeepOverride<A, B>;

Type Alias DeepOverride<T, U>

Type Parameters

Example

Settings