type-fest 2.18.1 → 3.0.0

package/index.d.ts

@@ -5,45 +5,53 @@ export * from './source/basic';
 export * from './source/observable-like';
 
 // Utilities
-export {Except} from './source/except';
-export {Mutable} from './source/mutable';
-export {Writable} from './source/writable';
-export {Merge} from './source/merge';
-export {MergeExclusive} from './source/merge-exclusive';
-export {RequireAtLeastOne} from './source/require-at-least-one';
-export {RequireExactlyOne} from './source/require-exactly-one';
-export {RequireAllOrNone} from './source/require-all-or-none';
-export {RemoveIndexSignature} from './source/remove-index-signature';
-export {PartialDeep, PartialDeepOptions} from './source/partial-deep';
-export {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep';
-export {ReadonlyDeep} from './source/readonly-deep';
-export {LiteralUnion} from './source/literal-union';
-export {Promisable} from './source/promisable';
-export {Opaque, UnwrapOpaque} from './source/opaque';
-export {InvariantOf} from './source/invariant-of';
-export {SetOptional} from './source/set-optional';
-export {SetRequired} from './source/set-required';
-export {ValueOf} from './source/value-of';
-export {PromiseValue} from './source/promise-value';
-export {AsyncReturnType} from './source/async-return-type';
-export {ConditionalExcept} from './source/conditional-except';
-export {ConditionalKeys} from './source/conditional-keys';
-export {ConditionalPick} from './source/conditional-pick';
-export {UnionToIntersection} from './source/union-to-intersection';
-export {Stringified} from './source/stringified';
-export {FixedLengthArray} from './source/fixed-length-array';
-export {MultidimensionalArray} from './source/multidimensional-array';
-export {MultidimensionalReadonlyArray} from './source/multidimensional-readonly-array';
-export {IterableElement} from './source/iterable-element';
-export {Entry} from './source/entry';
-export {Entries} from './source/entries';
-export {SetReturnType} from './source/set-return-type';
-export {Asyncify} from './source/asyncify';
-export {Simplify, SimplifyOptions} from './source/simplify';
-export {Jsonify} from './source/jsonify';
-export {Schema} from './source/schema';
-export {LiteralToPrimitive} from './source/literal-to-primitive';
-export {
+export type {EmptyObject, IsEmptyObject} from './source/empty-object';
+export type {Except} from './source/except';
+export type {Writable} from './source/writable';
+export type {Merge} from './source/merge';
+export type {MergeExclusive} from './source/merge-exclusive';
+export type {RequireAtLeastOne} from './source/require-at-least-one';
+export type {RequireExactlyOne} from './source/require-exactly-one';
+export type {RequireAllOrNone} from './source/require-all-or-none';
+export type {
+	OmitIndexSignature,
+	/**
+	@deprecated Renamed to {@link OmitIndexSignature}.
+	*/
+	OmitIndexSignature as RemoveIndexSignature,
+} from './source/omit-index-signature';
+export type {PickIndexSignature} from './source/pick-index-signature';
+export type {PartialDeep, PartialDeepOptions} from './source/partial-deep';
+export type {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep';
+export type {ReadonlyDeep} from './source/readonly-deep';
+export type {LiteralUnion} from './source/literal-union';
+export type {Promisable} from './source/promisable';
+export type {Opaque, UnwrapOpaque} from './source/opaque';
+export type {InvariantOf} from './source/invariant-of';
+export type {SetOptional} from './source/set-optional';
+export type {SetRequired} from './source/set-required';
+export type {SetNonNullable} from './source/set-non-nullable';
+export type {ValueOf} from './source/value-of';
+export type {AsyncReturnType} from './source/async-return-type';
+export type {ConditionalExcept} from './source/conditional-except';
+export type {ConditionalKeys} from './source/conditional-keys';
+export type {ConditionalPick} from './source/conditional-pick';
+export type {ConditionalPickDeep, ConditionalPickDeepOptions} from './source/conditional-pick-deep';
+export type {UnionToIntersection} from './source/union-to-intersection';
+export type {Stringified} from './source/stringified';
+export type {FixedLengthArray} from './source/fixed-length-array';
+export type {MultidimensionalArray} from './source/multidimensional-array';
+export type {MultidimensionalReadonlyArray} from './source/multidimensional-readonly-array';
+export type {IterableElement} from './source/iterable-element';
+export type {Entry} from './source/entry';
+export type {Entries} from './source/entries';
+export type {SetReturnType} from './source/set-return-type';
+export type {Asyncify} from './source/asyncify';
+export type {Simplify} from './source/simplify';
+export type {Jsonify} from './source/jsonify';
+export type {Schema} from './source/schema';
+export type {LiteralToPrimitive} from './source/literal-to-primitive';
+export type {
 	PositiveInfinity,
 	NegativeInfinity,
 	Finite,
@@ -55,40 +63,41 @@ export {
 	NegativeInteger,
 	NonNegativeInteger,
 } from './source/numeric';
-export {StringKeyOf} from './source/string-key-of';
-export {Exact} from './source/exact';
-export {ReadonlyTuple} from './source/readonly-tuple';
-export {OptionalKeysOf} from './source/optional-keys-of';
-export {HasOptionalKeys} from './source/has-optional-keys';
-export {RequiredKeysOf} from './source/required-keys-of';
-export {HasRequiredKeys} from './source/has-required-keys';
-export {Spread} from './source/spread';
+export type {StringKeyOf} from './source/string-key-of';
+export type {Exact} from './source/exact';
+export type {ReadonlyTuple} from './source/readonly-tuple';
+export type {OptionalKeysOf} from './source/optional-keys-of';
+export type {HasOptionalKeys} from './source/has-optional-keys';
+export type {RequiredKeysOf} from './source/required-keys-of';
+export type {HasRequiredKeys} from './source/has-required-keys';
+export type {Spread} from './source/spread';
+export type {TupleToUnion} from './source/tuple-to-union';
 
 // Template literal types
-export {CamelCase} from './source/camel-case';
-export {CamelCasedProperties} from './source/camel-cased-properties';
-export {CamelCasedPropertiesDeep} from './source/camel-cased-properties-deep';
-export {KebabCase} from './source/kebab-case';
-export {KebabCasedProperties} from './source/kebab-cased-properties';
-export {KebabCasedPropertiesDeep} from './source/kebab-cased-properties-deep';
-export {PascalCase} from './source/pascal-case';
-export {PascalCasedProperties} from './source/pascal-cased-properties';
-export {PascalCasedPropertiesDeep} from './source/pascal-cased-properties-deep';
-export {SnakeCase} from './source/snake-case';
-export {SnakeCasedProperties} from './source/snake-cased-properties';
-export {SnakeCasedPropertiesDeep} from './source/snake-cased-properties-deep';
-export {ScreamingSnakeCase} from './source/screaming-snake-case';
-export {DelimiterCase} from './source/delimiter-case';
-export {DelimiterCasedProperties} from './source/delimiter-cased-properties';
-export {DelimiterCasedPropertiesDeep} from './source/delimiter-cased-properties-deep';
-export {Join} from './source/join';
-export {Split} from './source/split';
-export {Trim} from './source/trim';
-export {Replace} from './source/replace';
-export {Includes} from './source/includes';
-export {Get} from './source/get';
-export {LastArrayElement} from './source/last-array-element';
+export type {CamelCase} from './source/camel-case';
+export type {CamelCasedProperties} from './source/camel-cased-properties';
+export type {CamelCasedPropertiesDeep} from './source/camel-cased-properties-deep';
+export type {KebabCase} from './source/kebab-case';
+export type {KebabCasedProperties} from './source/kebab-cased-properties';
+export type {KebabCasedPropertiesDeep} from './source/kebab-cased-properties-deep';
+export type {PascalCase} from './source/pascal-case';
+export type {PascalCasedProperties} from './source/pascal-cased-properties';
+export type {PascalCasedPropertiesDeep} from './source/pascal-cased-properties-deep';
+export type {SnakeCase} from './source/snake-case';
+export type {SnakeCasedProperties} from './source/snake-cased-properties';
+export type {SnakeCasedPropertiesDeep} from './source/snake-cased-properties-deep';
+export type {ScreamingSnakeCase} from './source/screaming-snake-case';
+export type {DelimiterCase} from './source/delimiter-case';
+export type {DelimiterCasedProperties} from './source/delimiter-cased-properties';
+export type {DelimiterCasedPropertiesDeep} from './source/delimiter-cased-properties-deep';
+export type {Join} from './source/join';
+export type {Split} from './source/split';
+export type {Trim} from './source/trim';
+export type {Replace} from './source/replace';
+export type {Includes} from './source/includes';
+export type {Get} from './source/get';
+export type {LastArrayElement} from './source/last-array-element';
 
 // Miscellaneous
-export {PackageJson} from './source/package-json';
-export {TsConfigJson} from './source/tsconfig-json';
+export type {PackageJson} from './source/package-json';
+export type {TsConfigJson} from './source/tsconfig-json';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "2.18.1",
+	"version": "3.0.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -10,8 +10,9 @@
 		"email": "sindresorhus@gmail.com",
 		"url": "https://sindresorhus.com"
 	},
+	"types": "./index.d.ts",
 	"engines": {
-		"node": ">=12.20"
+		"node": ">=14.16"
 	},
 	"scripts": {
 		"test": "xo && tsd && tsc && node script/test/source-files-extension.js"
@@ -29,21 +30,21 @@
 		"utilities",
 		"omit",
 		"merge",
-		"json"
+		"json",
+		"generics"
 	],
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
-		"expect-type": "^0.13.0",
-		"tsd": "^0.20.0",
-		"typescript": "^4.6.3",
-		"xo": "^0.43.0"
+		"expect-type": "^0.14.2",
+		"tsd": "^0.24.1",
+		"typescript": "^4.8.3",
+		"xo": "^0.52.2"
 	},
-	"types": "./index.d.ts",
 	"xo": {
 		"rules": {
+			"@typescript-eslint/ban-ts-comment": "off",
 			"@typescript-eslint/ban-types": "off",
-			"@typescript-eslint/indent": "off",
-			"node/no-unsupported-features/es-builtins": "off",
+			"@typescript-eslint/naming-convention": "off",
 			"import/extensions": "off",
 			"@typescript-eslint/no-redeclare": "off",
 			"@typescript-eslint/no-confusing-void-expression": "off"

package/readme.md

@@ -68,6 +68,20 @@
 					</sub>
 				</div>
 			</a>
+			<br>
+			<br>
+			<a href="https://sizzy.co/?utm_campaign=github_repo&utm_source=github&utm_medium=referral&utm_content=type-fest&utm_term=sindre">
+				<div>
+					<img src="https://sindresorhus.com/assets/thanks/sizzy-logo.png" width="240" alt="Sizzy">
+				</div>
+				<div>
+					<sub>
+					<b>Before Sizzy:</b> web development is stressing you out, responsive design is hard, you have an overwhelming amount of opened tabs & apps.
+					<br>
+					<b>After Sizzy:</b> all the tools you need in one place, responsive design is a breeze, no more context switching.
+					</sub>
+				</div>
+			</a>
 		</p>
 	</div>
 	<br>
@@ -95,7 +109,7 @@ PR welcome for additional commonly needed types and docs improvements. Read the
 npm install type-fest
 ```
 
-*Requires TypeScript >=4.2*
+*Requires TypeScript >=4.7*
 
 ## Usage
 
@@ -125,14 +139,17 @@ Click the type names for complete docs.
 
 ### Utilities
 
+- [`EmptyObject`](source/empty-object.d.ts) - Represents a strictly empty plain object, the `{}` value.
+- [`IsEmptyObject`](source/empty-object.d.ts) - Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
 - [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys).
-- [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from all or some of an object's keys. The inverse of `Readonly<T>`. Formerly named `Mutable`.
+- [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from all or some of an object's keys. The inverse of `Readonly<T>`.
 - [`Merge`](source/merge.d.ts) - Merge two types into a new type. Keys of the second type overrides keys of the first type.
 - [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys.
 - [`RequireAtLeastOne`](source/require-at-least-one.d.ts) - Create a type that requires at least one of the given keys.
 - [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys.
-- [`RemoveIndexSignature`](source/remove-index-signature.d.ts) - Create a type that only has explicitly defined properties, absent of any index signatures.
+- [`OmitIndexSignature`](source/omit-index-signature.d.ts) - Omit any index signatures from the given object type, leaving only explicitly defined properties.
+- [`PickIndexSignature`](source/pick-index-signature.d.ts) - Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 - [`PartialDeep`](source/partial-deep.d.ts) - Create a deeply optional version of another type. Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
 - [`PartialOnUndefinedDeep`](source/partial-on-undefined-deep.d.ts) - Create a deep version of another type where all keys accepting `undefined` type are set to optional.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
@@ -142,9 +159,11 @@ Click the type names for complete docs.
 - [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
 - [`SetOptional`](source/set-optional.d.ts) - Create a type that makes the given keys optional.
 - [`SetRequired`](source/set-required.d.ts) - Create a type that makes the given keys required.
+- [`SetNonNullable`](source/set-non-nullable.d.ts) - Create a type that makes the given keys non-nullable.
 - [`ValueOf`](source/value-of.d.ts) - Create a union of the given object's values, and optionally specify which keys to get the values from.
 - [`ConditionalKeys`](source/conditional-keys.d.ts) - Extract keys from a shape where values extend the given `Condition` type.
 - [`ConditionalPick`](source/conditional-pick.d.ts) - Like `Pick` except it selects properties from a shape where the values extend the given `Condition` type.
+- [`ConditionalPickDeep`](source/conditional-pick-deep.d.ts) - Like `ConditionalPick` except that it selects the properties deeply.
 - [`ConditionalExcept`](source/conditional-except.d.ts) - Like `Omit` except it removes properties from a shape where the values extend the given `Condition` type.
 - [`UnionToIntersection`](source/union-to-intersection.d.ts) - Convert a union type to an intersection type.
 - [`LiteralToPrimitive`](source/literal-to-primitive.d.ts) - Convert a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) to the [primitive type](source/primitive.d.ts) it belongs to.
@@ -193,6 +212,7 @@ Click the type names for complete docs.
 - [`MultidimensionalArray`](source/multidimensional-array.d.ts) - Create a type that represents a multidimensional array of the given type and dimensions.
 - [`MultidimensionalReadonlyArray`](source/multidimensional-readonly-array.d.ts) - Create a type that represents a multidimensional readonly array of the given type and dimensions.
 - [`ReadonlyTuple`](source/readonly-tuple.d.ts) - Create a type that represents a read-only tuple of the given type and length.
+- [`TupleToUnion`](source/tuple-to-union.d.ts) - Convert a tuple into a union type of its elements.
 
 ### Numeric
 
@@ -229,7 +249,7 @@ Click the type names for complete docs.
 ### Miscellaneous
 
 - [`PackageJson`](source/package-json.d.ts) - Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). It also includes support for [TypeScript Declaration Files](https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) and [Yarn Workspaces](https://classic.yarnpkg.com/lang/en/docs/workspaces/).
-- [`TsConfigJson`](source/tsconfig-json.d.ts) - Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) (TypeScript 4.4).
+- [`TsConfigJson`](source/tsconfig-json.d.ts) - Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html).
 
 ## Declined types
 
@@ -250,6 +270,7 @@ Click the type names for complete docs.
 
 - `PartialBy` - See [`SetOptional`](https://github.com/sindresorhus/type-fest/blob/main/source/set-optional.d.ts)
 - `RecordDeep`- See [`Schema`](https://github.com/sindresorhus/type-fest/blob/main/source/schema.d.ts)
+- `Mutable`- See [`Writable`](https://github.com/sindresorhus/type-fest/blob/main/source/writable.d.ts)
 
 ## Tips
 
@@ -886,19 +907,8 @@ You can find some examples in the [TypeScript docs](https://www.typescriptlang.o
 - [Jarek Radosz](https://github.com/CvX)
 - [Dimitri Benin](https://github.com/BendingBender)
 - [Pelle Wessman](https://github.com/voxpelli)
+- [Sébastien Mischler](https://github.com/skarab42)
 
 ## License
 
 SPDX-License-Identifier: (MIT OR CC0-1.0)
-
----
-
-<div align="center">
-	<b>
-		<a href="https://tidelift.com/subscription/pkg/npm-type-fest?utm_source=npm-type-fest&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
-	</b>
-	<br>
-	<sub>
-		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
-	</sub>
-</div>

package/source/async-return-type.d.ts

@@ -1,5 +1,3 @@
-import type {PromiseValue} from './promise-value';
-
 type AsyncFunction = (...args: any[]) => Promise<unknown>;
 
 /**
@@ -22,4 +20,4 @@ asyncFunction().then(value => doSomething(value));
 
 @category Async
 */
-export type AsyncReturnType<Target extends AsyncFunction> = PromiseValue<ReturnType<Target>>;
+export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;

package/source/asyncify.d.ts

@@ -1,4 +1,3 @@
-import type {PromiseValue} from './promise-value';
 import type {SetReturnType} from './set-return-type';
 
 /**
@@ -30,4 +29,4 @@ const getFooAsync: AsyncifiedFooGetter = (someArg) => {
 
 @category Async
 */
-export type Asyncify<Fn extends (...args: any[]) => any> = SetReturnType<Fn, Promise<PromiseValue<ReturnType<Fn>>>>;
+export type Asyncify<Fn extends (...args: any[]) => any> = SetReturnType<Fn, Promise<Awaited<ReturnType<Fn>>>>;

package/source/basic.d.ts

@@ -19,7 +19,7 @@ This type can be useful to enforce some input to be JSON-compatible or as a supe
 
 @category JSON
 */
-export type JsonObject = {[Key in string]?: JsonValue};
+export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
 
 /**
 Matches a JSON array.

package/source/camel-case.d.ts

@@ -13,8 +13,8 @@ type InnerCamelCaseStringArray<Parts extends readonly any[], PreviousPart> =
 		? FirstPart extends undefined
 			? ''
 			: FirstPart extends ''
-					? InnerCamelCaseStringArray<RemainingParts, PreviousPart>
-					: `${PreviousPart extends '' ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`
+				? InnerCamelCaseStringArray<RemainingParts, PreviousPart>
+				: `${PreviousPart extends '' ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`
 		: '';
 
 /**

package/source/camel-cased-properties-deep.d.ts

@@ -47,8 +47,8 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 export type CamelCasedPropertiesDeep<Value> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
-	? Array<CamelCasedPropertiesDeep<U>>
-	: Value extends Set<infer U>
-	? Set<CamelCasedPropertiesDeep<U>> : {
-			[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
-	};
+		? Array<CamelCasedPropertiesDeep<U>>
+		: Value extends Set<infer U>
+			? Set<CamelCasedPropertiesDeep<U>> : {
+				[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
+			};

package/source/camel-cased-properties.d.ts

@@ -30,7 +30,7 @@ const result: CamelCasedProperties<User> = {
 export type CamelCasedProperties<Value> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
-	? Value
-	: {
+		? Value
+		: {
 			[K in keyof Value as CamelCase<K>]: Value[K];
-	};
+		};

package/source/conditional-except.d.ts

@@ -40,6 +40,6 @@ type NonStringKeysOnly = ConditionalExcept<Example, string>;
 @category Object
 */
 export type ConditionalExcept<Base, Condition> = Except<
-	Base,
-	ConditionalKeys<Base, Condition>
+Base,
+ConditionalKeys<Base, Condition>
 >;

package/source/conditional-keys.d.ts

@@ -31,17 +31,17 @@ type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
 @category Object
 */
 export type ConditionalKeys<Base, Condition> = NonNullable<
-	// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
-	{
-		// Map through all the keys of the given base type.
-		[Key in keyof Base]:
-			// Pick only keys with types extending the given `Condition` type.
-			Base[Key] extends Condition
-				// Retain this key since the condition passes.
-				? Key
-				// Discard this key since the condition fails.
-				: never;
+// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+{
+	// Map through all the keys of the given base type.
+	[Key in keyof Base]:
+	// Pick only keys with types extending the given `Condition` type.
+	Base[Key] extends Condition
+	// Retain this key since the condition passes.
+		? Key
+	// Discard this key since the condition fails.
+		: never;
 
 	// Convert the produced object into a union type of the keys which passed the conditional test.
-	}[keyof Base]
+}[keyof Base]
 >;

package/source/conditional-pick-deep.d.ts

@@ -0,0 +1,102 @@
+import type {Opaque} from './opaque';
+import type {IsEqual} from './internal';
+import type {ConditionalExcept} from './conditional-except';
+import type {ConditionalSimplifyDeep} from './conditional-simplify';
+
+/**
+Used to mark properties that should be excluded.
+*/
+type ConditionalPickDeepSymbol = Opaque<symbol, 'conditional-pick-deep-symbol'>;
+
+/**
+Assert the condition according to the {@link ConditionalPickDeepOptions.condition|condition} option.
+*/
+type AssertCondition<Type, Condition, Options extends ConditionalPickDeepOptions> = Options['condition'] extends 'equality'
+	? IsEqual<Type, Condition>
+	: Type extends Condition
+		? true
+		: false;
+
+/**
+ConditionalPickDeep options.
+
+@see ConditionalPickDeep
+*/
+export type ConditionalPickDeepOptions = {
+	/**
+	The condition assertion mode.
+
+	@default 'extends'
+	*/
+	condition?: 'extends' | 'equality';
+};
+
+/**
+Pick keys recursively from the shape that matches the given condition.
+
+@see ConditionalPick
+
+@example
+```
+import type {ConditionalPickDeep} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | boolean;
+	c: {
+		d: string;
+		e: {
+			f?: string;
+			g?: boolean;
+			h: string | boolean;
+			i: boolean | bigint;
+		};
+		j: boolean;
+	};
+}
+
+type StringPick = ConditionalPickDeep<Example, string>;
+//=> {a: string; c: {d: string}}
+
+type StringPickOptional = ConditionalPickDeep<Example, string | undefined>;
+//=> {a: string; c: {d: string; e: {f?: string}}}
+
+type StringPickOptionalOnly = ConditionalPickDeep<Example, string | undefined, {condition: 'equality'}>;
+//=> {c: {e: {f?: string}}}
+
+type BooleanPick = ConditionalPickDeep<Example, boolean | undefined>;
+//=> {c: {e: {g?: boolean}; j: boolean}}
+
+type NumberPick = ConditionalPickDeep<Example, number>;
+//=> {}
+
+type StringOrBooleanPick = ConditionalPickDeep<Example, string | boolean>;
+//=> {
+// 	a: string;
+// 	b: string | boolean;
+// 	c: {
+// 		d: string;
+// 		e: {
+// 			h: string | boolean
+// 		};
+// 		j: boolean;
+// 	};
+// }
+
+type StringOrBooleanPickOnly = ConditionalPickDeep<Example, string | boolean, {condition: 'equality'}>;
+//=> {b: string | boolean; c: {e: {h: string | boolean}}}
+```
+
+@category Object
+*/
+export type ConditionalPickDeep<
+	Type,
+	Condition,
+	Options extends ConditionalPickDeepOptions = {},
+> = ConditionalSimplifyDeep<ConditionalExcept<{
+	[Key in keyof Type]: AssertCondition<Type[Key], Condition, Options> extends true
+		? Type[Key]
+		: Type[Key] extends object
+			? ConditionalPickDeep<Type[Key], Condition, Options>
+			: ConditionalPickDeepSymbol;
+}, (ConditionalPickDeepSymbol | undefined) | Record<PropertyKey, never>>>;

package/source/conditional-pick.d.ts

@@ -39,6 +39,6 @@ type StringKeysOnly = ConditionalPick<Example, string>;
 @category Object
 */
 export type ConditionalPick<Base, Condition> = Pick<
-	Base,
-	ConditionalKeys<Base, Condition>
+Base,
+ConditionalKeys<Base, Condition>
 >;

package/source/conditional-simplify.d.ts

@@ -0,0 +1,32 @@
+/**
+Simplifies a type while including and/or excluding certain types from being simplified. Useful to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
+
+@internal
+@experimental
+@see Simplify
+@category Object
+*/
+export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
+	? Type
+	: Type extends IncludeType
+		? {[TypeKey in keyof Type]: Type[TypeKey]}
+		: Type;
+
+/**
+Recursively simplifies a type while including and/or excluding certain types from being simplified.
+
+This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
+
+See {@link ConditionalSimplify} for usages and examples.
+
+@internal
+@experimental
+@category Object
+*/
+export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
+	? Type
+	: Type extends IncludeType
+		? {[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>}
+		: Type;