Type Alias PartialDeep<T, Options>

PartialDeep: T extends BuiltIns
    ? T
    : T extends Map<infer KeyType, infer ValueType>
        ? PartialMapDeep<KeyType, ValueType, Options>
        : T extends Set<infer ItemType>
            ? PartialSetDeep<ItemType, Options>
            : T extends ReadonlyMap<infer KeyType, infer ValueType>
                ? PartialReadonlyMapDeep<KeyType, ValueType, Options>
                : T extends ReadonlySet<infer ItemType>
                    ? PartialReadonlySetDeep<ItemType, Options>
                    : T extends (...arguments: any[]) => unknown
                        ? T | undefined
                        : T extends object
                            ? T extends ReadonlyArray<infer ItemType>
                                ? Options["recurseIntoArrays"] extends true
                                    ? (...)[] extends T
                                        ? (...) extends (...) ? (...) : (...)
                                        : PartialObjectDeep<(...), (...)>
                                    : T
                                : PartialObjectDeep<T, Options>
                            : unknown

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

Use-cases:

Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.

Type Parameters

T
Options extends PartialDeepOptions = {}

Example

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

const settings: Settings = {
	textEditor: {
		fontSize: 14;
		fontColor: '#000000';
		fontWeight: 400;
	}
	autocomplete: false;
	autosave: true;
};

const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
	return {...settings, ...savedSettings};
}

settings = applySavedSettings({textEditor: {fontWeight: 500}});

By default, this does not affect elements in array and tuple types. You can change this by passing {recurseIntoArrays: true} as the second type argument:

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

interface Settings {
	languages: string[];
}

const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
	languages: [undefined]
};