Type Alias RequiredDeep<T, E>

RequiredDeep: E extends BuiltIns
    ? E
    : E extends Map<infer KeyType, infer ValueType>
        ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
        : E extends Set<infer ItemType>
            ? Set<RequiredDeep<ItemType>>
            : E extends ReadonlyMap<infer KeyType, infer ValueType>
                ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
                : E extends ReadonlySet<infer ItemType>
                    ? ReadonlySet<RequiredDeep<ItemType>>
                    : E extends WeakMap<infer KeyType, infer ValueType>
                        ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
                        : E extends WeakSet<infer ItemType>
                            ? WeakSet<RequiredDeep<ItemType>>
                            : E extends Promise<infer ValueType>
                                ? Promise<RequiredDeep<ValueType>>
                                : E extends (...args: (...)[]) => unknown
                                    ? {} extends RequiredObjectDeep<(...)>
                                        ? E
                                        : (...) extends (...) ? (...) : (...)
                                    : E extends object ? (...) extends (...) ? (...) : (...) : unknown

Create a type from another type with all keys and nested keys set to required.

Use-cases:

Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
Modeling the resulting type after a deep merge with a set of defaults.

Type Parameters

T
E extends ExcludeUndefined<T> = ExcludeUndefined<T>

Example

import type {RequiredDeep} from 'type-fest';

type Settings = {
	textEditor?: {
		fontSize?: number | undefined;
		fontColor?: string | undefined;
		fontWeight?: number | undefined;
	}
	autocomplete?: boolean | undefined;
	autosave?: boolean | undefined;
};

type RequiredSettings = RequiredDeep<Settings>;
// type RequiredSettings = {
// 	textEditor: {
// 		fontSize: number;
// 		fontColor: string;
// 		fontWeight: number;
// 	}
// 	autocomplete: boolean;
// 	autosave: boolean;
// }

Note that types containing overloaded functions are not made deeply required due to a TypeScript limitation.