type-fest 5.1.0 → 5.2.0

package/index.d.ts

@@ -141,6 +141,7 @@ export type {ArrayValues} from './source/array-values.d.ts';
 export type {ArraySlice} from './source/array-slice.d.ts';
 export type {ArraySplice} from './source/array-splice.d.ts';
 export type {ArrayTail} from './source/array-tail.d.ts';
+export type {ArrayElement} from './source/array-element.d.ts';
 export type {SetFieldType, SetFieldTypeOptions} from './source/set-field-type.d.ts';
 export type {Paths, PathsOptions} from './source/paths.d.ts';
 export type {AllUnionFields} from './source/all-union-fields.d.ts';
@@ -162,6 +163,7 @@ export type {IsUppercase} from './source/is-uppercase.d.ts';
 export type {IsOptional} from './source/is-optional.d.ts';
 export type {IsNullable} from './source/is-nullable.d.ts';
 export type {TupleOf} from './source/tuple-of.d.ts';
+export type {ExclusifyUnion} from './source/exclusify-union.d.ts';
 
 // Template literal types
 export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';
@@ -202,3 +204,5 @@ export type {TsConfigJson} from './source/tsconfig-json.d.ts';
 export type {ExtendsStrict} from './source/extends-strict.d.ts';
 export type {ExtractStrict} from './source/extract-strict.d.ts';
 export type {ExcludeStrict} from './source/exclude-strict.d.ts';
+
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.1.0",
+	"version": "5.2.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -54,6 +54,8 @@
 	},
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^8.0.1",
+		"@typescript-eslint/parser": "^8.44.0",
+		"eslint": "^9.35.0",
 		"expect-type": "^1.2.2",
 		"npm-run-all2": "^8.0.4",
 		"tsd": "^0.33.0",

package/readme.md

@@ -179,7 +179,7 @@ Click the type names for complete docs.
 - [`DistributedOmit`](source/distributed-omit.d.ts) - Omits keys from a type, distributing the operation over a union.
 - [`DistributedPick`](source/distributed-pick.d.ts) - Picks keys from a type, distributing the operation over a union.
 - [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both true.
-- [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types are true.
+- [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types is true.
 - [`Xor`](source/xor.d.ts) - Returns a boolean for whether only one of two given types is true.
 - [`AllExtend`](source/all-extend.d.ts) - Returns a boolean for whether every element in an array type extends another type.
 - [`NonEmptyTuple`](source/non-empty-tuple.d.ts) - Matches any non-empty tuple.
@@ -188,6 +188,7 @@ Click the type names for complete docs.
 - [`FindGlobalInstanceType`](source/find-global-type.d.ts) - Tries to find one or more types from their globally-defined constructors.
 - [`ConditionalSimplify`](source/conditional-simplify.d.ts) - Simplifies a type while including and/or excluding certain types from being simplified.
 - [`ConditionalSimplifyDeep`](source/conditional-simplify-deep.d.ts) - Recursively simplifies a type while including and/or excluding certain types from being simplified.
+- [`ExclusifyUnion`](source/exclusify-union.d.ts) - Ensure mutual exclusivity in object unions by adding other members’ keys as `?: never`.
 
 ### Type Guard
 
@@ -249,6 +250,7 @@ Click the type names for complete docs.
 - [`Includes`](source/includes.d.ts) - Returns a boolean for whether the given array includes the given item.
 - [`Join`](source/join.d.ts) - Join an array of strings and/or numbers using the given string as a delimiter.
 - [`ArraySlice`](source/array-slice.d.ts) - Returns an array slice of a given range, just like `Array#slice()`.
+- [`ArrayElement`](source/array-element.d.ts) - Extracts the element type of an array or tuple.
 - [`LastArrayElement`](source/last-array-element.d.ts) - Extract the type of the last element of an array.
 - [`FixedLengthArray`](source/fixed-length-array.d.ts) - Create a type that represents an array of the given type and length. The `Array` prototype methods that manipulate its length are excluded from the resulting type.
 - [`MultidimensionalArray`](source/multidimensional-array.d.ts) - Create a type that represents a multidimensional array of the given type and dimensions.

package/source/all-union-fields.d.ts

@@ -62,7 +62,7 @@ function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
 }
 ```
 
-@see SharedUnionFields
+@see {@link SharedUnionFields}
 
 @category Object
 @category Union

package/source/and.d.ts

@@ -46,6 +46,7 @@ type E = And<boolean, boolean>;
 ```
 
 Note: If either of the types is `never`, the result becomes `false`.
+
 @example
 ```
 import type {And} from 'type-fest';
@@ -73,6 +74,7 @@ type G = And<never, never>;
 ```
 
 @see {@link Or}
+@see {@link Xor}
 */
 export type And<A extends boolean, B extends boolean> = AllExtend<[A, B], true>;
 

package/source/array-element.d.ts

@@ -0,0 +1,46 @@
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Extracts the element type of an array or tuple.
+
+Use-cases:
+- When you need type-safe element extraction that returns `never` for non-arrays.
+- When extracting element types from generic array parameters in function signatures.
+- For better readability and explicit intent over using `T[number]` directly.
+
+Note: Returns `never` if the type is not an array.
+
+@example
+```
+import type {ArrayElement} from 'type-fest';
+
+// Arrays
+type StringArray = ArrayElement<string[]>;
+//=> string
+
+// Tuples
+type Tuple = ArrayElement<[1, 2, 3]>;
+//=> 1 | 2 | 3
+
+// Type-safe
+type NotArray = ArrayElement<{a: string}>;
+//=> never
+
+// Practical example
+declare function getRandomElement<T extends readonly unknown[]>(array: T): ArrayElement<T>;
+
+getRandomElement(['foo', 'bar', 'baz'] as const);
+//=> 'foo' | 'bar' | 'baz'
+```
+
+@see {@link ArrayValues} - For directly extracting values from a constant array type.
+@see {@link IterableElement} - For iterables like `Set`, `Map`, and generators (not suitable for all use cases due to different inference behavior).
+
+@category Array
+*/
+export type ArrayElement<T> =
+	T extends UnknownArray
+		? T[number]
+		: never;
+
+export {};

package/source/arrayable.d.ts

@@ -1,7 +1,7 @@
 /**
 Create a type that represents either the value or an array of the value.
 
-@see Promisable
+@see {@link Promisable}
 
 @example
 ```

package/source/camel-case.d.ts

@@ -1,12 +1,12 @@
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
-import type {Words} from './words.d.ts';
+import type {Words, WordsOptions} from './words.d.ts';
 
 /**
 CamelCase options.
 
 @see {@link CamelCase}
 */
-export type CamelCaseOptions = {
+export type CamelCaseOptions = WordsOptions & {
 	/**
 	Whether to preserved consecutive uppercase letter.
 
@@ -16,6 +16,7 @@ export type CamelCaseOptions = {
 };
 
 export type _DefaultCamelCaseOptions = {
+	splitOnNumbers: true;
 	preserveConsecutiveUppercase: false;
 };
 
@@ -83,7 +84,7 @@ export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extend
 	? string extends Type
 		? Type
 		: Uncapitalize<CamelCaseFromArray<
-			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
+			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type, Options>,
 			ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>
 		>>
 	: Type;

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

@@ -7,8 +7,8 @@ Convert object properties to camel case recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see CamelCasedProperties
-@see CamelCase
+@see {@link CamelCasedProperties}
+@see {@link CamelCase}
 
 @example
 ```

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

@@ -6,8 +6,8 @@ Convert object properties to camel case but not recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see CamelCasedPropertiesDeep
-@see CamelCase
+@see {@link CamelCasedPropertiesDeep}
+@see {@link CamelCase}
 
 @example
 ```

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

@@ -22,7 +22,7 @@ type AssertCondition<Type, Condition, Options extends ConditionalPickDeepOptions
 /**
 ConditionalPickDeep options.
 
-@see ConditionalPickDeep
+@see {@link ConditionalPickDeep}
 */
 export type ConditionalPickDeepOptions = {
 	/**
@@ -40,7 +40,7 @@ type DefaultConditionalPickDeepOptions = {
 /**
 Pick keys recursively from the shape that matches the given condition.
 
-@see ConditionalPick
+@see {@link ConditionalPick}
 
 @example
 ```

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

@@ -61,7 +61,7 @@ type SimplifyDeepTypeAB = ConditionalSimplifyDeep<TypeA & TypeB, SomeComplexType
 // }
 ```
 
-@see SimplifyDeep
+@see {@link SimplifyDeep}
 @category Object
 */
 export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType

package/source/conditional-simplify.d.ts

@@ -38,7 +38,7 @@ type C = Simplify<{a: number} & {b: string}>;
 //=> {a: number; b: string}
 ```
 
-@see ConditionalSimplifyDeep
+@see {@link ConditionalSimplifyDeep}
 @category Object
 */
 export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType

package/source/delimiter-case.d.ts

@@ -27,8 +27,8 @@ Convert a string literal to a custom string delimiter casing.
 
 This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
 
-@see KebabCase
-@see SnakeCase
+@see {@link KebabCase}
+@see {@link SnakeCase}
 
 @example
 ```

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

@@ -8,8 +8,8 @@ Convert object properties to delimiter case recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see DelimiterCase
-@see DelimiterCasedProperties
+@see {@link DelimiterCase}
+@see {@link DelimiterCasedProperties}
 
 @example
 ```

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

@@ -7,8 +7,8 @@ Convert object properties to delimiter case but not recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see DelimiterCase
-@see DelimiterCasedPropertiesDeep
+@see {@link DelimiterCase}
+@see {@link DelimiterCasedPropertiesDeep}
 
 @example
 ```

package/source/empty-object.d.ts

@@ -40,7 +40,7 @@ type Fail = IsEmptyObject<[]>; //=> false
 type Fail = IsEmptyObject<null>; //=> false
 ```
 
-@see EmptyObject
+@see {@link EmptyObject}
 @category Object
 */
 export type IsEmptyObject<T> = T extends EmptyObject ? true : false;

package/source/exact.d.ts

@@ -1,4 +1,5 @@
-import type {ArrayElement, ObjectValue} from './internal/index.d.ts';
+import type {ObjectValue} from './internal/index.d.ts';
+import type {ArrayElement} from './array-element.d.ts';
 import type {IsEqual} from './is-equal.d.ts';
 import type {KeysOfUnion} from './keys-of-union.d.ts';
 import type {IsUnknown} from './is-unknown.d.ts';

package/source/exclude-rest-element.d.ts

@@ -1,6 +1,7 @@
 import type {SplitOnRestElement} from './split-on-rest-element.d.ts';
 import type {IsArrayReadonly} from './internal/array.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
 
 /**
 Create a tuple with the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element removed.
@@ -22,16 +23,18 @@ type T4 = ExcludeRestElement<[number, string]>;
 //=> [number, string]
 ```
 
-@see ExtractRestElement, SplitOnRestElement
+@see {@link ExtractRestElement}
+@see {@link SplitOnRestElement}
 @category Array
 */
-export type ExcludeRestElement<Array_ extends UnknownArray> =
+export type ExcludeRestElement<Array_ extends UnknownArray> = IfNotAnyOrNever<Array_,
 	SplitOnRestElement<Array_> extends infer Result
 		? Result extends readonly UnknownArray[]
 			? IsArrayReadonly<Array_> extends true
 				? Readonly<[...Result[0], ...Result[2]]>
 				: [...Result[0], ...Result[2]]
-			: Result
-		: never;
+			: never
+		: never
+>;
 
 export {};

package/source/exclusify-union.d.ts

@@ -0,0 +1,113 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, MapsSetsOrArrays, NonRecursiveType} from './internal/type.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Ensure mutual exclusivity in object unions by adding other members’ keys as `?: never`.
+
+Use-cases:
+- You want each union member to be exclusive, preventing overlapping object shapes.
+- You want to safely access any property defined across the union without additional type guards.
+
+@example
+```
+import type {ExclusifyUnion} from 'type-fest';
+
+type FileConfig = {
+	filePath: string;
+};
+
+type InlineConfig = {
+	content: string;
+};
+
+declare function loadConfig1(options: FileConfig | InlineConfig): void;
+
+// Someone could mistakenly provide both `filePath` and `content`.
+loadConfig1({filePath: './config.json', content: '{ "name": "app" }'}); // No errors
+
+// Use `ExclusifyUnion` to prevent that mistake.
+type Config = ExclusifyUnion<FileConfig | InlineConfig>;
+//=> {filePath: string; content?: never} | {content: string; filePath?: never}
+
+declare function loadConfig2(options: Config): void;
+
+// @ts-expect-error
+loadConfig2({filePath: './config.json', content: '{ "name": "app" }'});
+//=> Error: Argument of type '{ filePath: string; content: string; }' is not assignable to parameter of type '{ filePath: string; content?: never; } | { content: string; filePath?: never; }'.
+
+loadConfig2({filePath: './config.json'}); // Ok
+
+loadConfig2({content: '{ "name": "app" }'}); // Ok
+```
+
+@example
+```
+import type {ExclusifyUnion} from 'type-fest';
+
+type CardPayment = {
+	amount: number;
+	cardNumber: string;
+};
+
+type PaypalPayment = {
+	amount: number;
+	paypalId: string;
+};
+
+function processPayment1(payment: CardPayment | PaypalPayment) {
+	// @ts-expect-error
+	const details = payment.cardNumber ?? payment.paypalId; // Cannot access `cardNumber` or `paypalId` directly
+}
+
+type Payment = ExclusifyUnion<CardPayment | PaypalPayment>;
+//=> {amount: number; cardNumber: string; paypalId?: never} | {amount: number; paypalId: string; cardNumber?: never}
+
+function processPayment2(payment: Payment) {
+	const details = payment.cardNumber ?? payment.paypalId; // Ok
+	//=> string
+}
+```
+
+@example
+```
+import type {ExclusifyUnion} from 'type-fest';
+
+type A = ExclusifyUnion<{a: string} | {b: number}>;
+//=> {a: string; b?: never} | {a?: never; b: number}
+
+type B = ExclusifyUnion<{a: string} | {b: number} | {c: boolean}>;
+//=> {a: string; b?: never; c?: never} | {a?: never; b: number; c?: never} | {a?: never; b?: never; c: boolean}
+
+type C = ExclusifyUnion<{a: string; b: number} | {b: string; c: number}>;
+//=> {a: string; b: number; c?: never} | {a?: never; b: string; c: number}
+
+type D = ExclusifyUnion<{a?: 1; readonly b: 2} | {d: 4}>;
+//=> {a?: 1; readonly b: 2; d?: never} | {a?: never; b?: never; d: 4}
+```
+
+@category Object
+@category Union
+*/
+export type ExclusifyUnion<Union> = IfNotAnyOrNever<Union,
+	If<IsUnknown<Union>, Union,
+		Extract<Union, NonRecursiveType | MapsSetsOrArrays> extends infer SkippedMembers
+			? SkippedMembers | _ExclusifyUnion<Exclude<Union, SkippedMembers>>
+			: never
+	>
+>;
+
+type _ExclusifyUnion<Union, UnionCopy = Union> = Union extends unknown // For distributing `Union`
+	? Simplify<
+		Union & Partial<
+			Record<
+				Exclude<KeysOfUnion<UnionCopy>, keyof Union>,
+				never
+			>
+		>
+	>
+	: never; // Should never happen
+
+export {};

package/source/extract-rest-element.d.ts

@@ -21,7 +21,8 @@ type T4 = ExtractRestElement<[number, string]>;
 //=> never
 ```
 
-@see ExcludeRestElement, SplitOnRestElement
+@see {@link ExcludeRestElement}
+@see {@link SplitOnRestElement}
 @category Array
 */
 export type ExtractRestElement<T extends UnknownArray> = SplitOnRestElement<T>[1][number];

package/source/extract-strict.d.ts

@@ -1,7 +1,7 @@
 /**
 A stricter version of {@link Extract<T, U>} that ensures every member of `U` can successfully extract something from `T`.
 
-For example, `StrictExtract<string | number | boolean, number | bigint>` will error because `bigint` cannot extract anything from `string | number | boolean`.
+For example, `ExtractStrict<string | number | boolean, number | bigint>` will error because `bigint` cannot extract anything from `string | number | boolean`.
 
 @example
 ```

package/source/greater-than-or-equal.d.ts

@@ -19,6 +19,12 @@ GreaterThanOrEqual<1, 5>;
 */
 export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
 	? never
-	: A extends B ? true : GreaterThan<A, B>;
+	: A extends number // For distributing `A`
+		? B extends number // For distributing `B`
+			? A extends B
+				? true
+				: GreaterThan<A, B>
+			: never // Should never happen
+		: never; // Should never happen
 
 export {};

package/source/if.d.ts

@@ -54,6 +54,41 @@ type B = IfEqual<string, number, 'equal', 'not equal'>;
 //=> 'not equal'
 ```
 
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
 @category Type Guard
 @category Utilities
 */

package/source/int-closed-range.d.ts

@@ -30,7 +30,7 @@ type ZeroToNine = IntClosedRange<0, 9>;
 type Hundreds = IntClosedRange<100, 900, 100>;
 ```
 
-@see IntRange
+@see {@link IntRange}
 */
 export type IntClosedRange<Start extends number, End extends number, Skip extends number = 1> = IntRange<Start, Sum<End, 1>, Skip>;
 

package/source/int-range.d.ts

@@ -30,7 +30,7 @@ type ZeroToNine = IntRange<0, 10>;
 type Hundreds = IntRange<100, 901, 100>;
 ```
 
-@see IntClosedRange
+@see {@link IntClosedRange}
 */
 export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
 

package/source/internal/array.d.ts

@@ -24,15 +24,6 @@ export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray exten
 	? THead
 	: never;
 
-/**
-Extract the element of an array that also works for array union.
-
-Returns `never` if T is not an array.
-
-It creates a type-safe way to access the element type of `unknown` type.
-*/
-export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
-
 /**
 Returns the static, fixed-length portion of the given array, excluding variable-length parts.
 

package/source/internal/type.d.ts

@@ -2,6 +2,7 @@ import type {If} from '../if.d.ts';
 import type {IsAny} from '../is-any.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -13,6 +14,11 @@ Matches non-recursive types.
 */
 export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 
+/**
+Matches maps, sets, or arrays.
+*/
+export type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
+
 /**
 Returns a boolean for whether the two given types extends the base type.
 */
@@ -96,6 +102,32 @@ type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 //=> 'IS_NEVER'
 ```
+
+Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
+
+@example
+```ts
+import type {StringRepeat} from 'type-fest';
+
+type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
+
+// The following implementation is not tail recursive
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
+//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// To fix this, move the recursion into a helper type
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+
+type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
+
+type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
+//=> ''
+```
 */
 export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
 	If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;

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

@@ -8,8 +8,8 @@ Convert object properties to kebab case recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see KebabCase
-@see KebabCasedProperties
+@see {@link KebabCase}
+@see {@link KebabCasedProperties}
 
 @example
 ```

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

@@ -8,8 +8,8 @@ Convert object properties to kebab case but not recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see KebabCase
-@see KebabCasedPropertiesDeep
+@see {@link KebabCase}
+@see {@link KebabCasedPropertiesDeep}
 
 @example
 ```

package/source/literal-to-primitive-deep.d.ts

@@ -6,7 +6,7 @@ Like `LiteralToPrimitive` except it converts literal types inside an object or a
 
 For example, given a constant object, it returns a new object type with the same keys but with all the values converted to primitives.
 
-@see LiteralToPrimitive
+@see {@link LiteralToPrimitive}
 
 Use-case: Deal with data that is imported from a JSON file.
 

package/source/numeric.d.ts

@@ -10,7 +10,7 @@ Matches the hidden `Infinity` type.
 
 Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
 
-@see NegativeInfinity
+@see {@link NegativeInfinity}
 
 @category Numeric
 */
@@ -23,7 +23,7 @@ Matches the hidden `-Infinity` type.
 
 Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
 
-@see PositiveInfinity
+@see {@link PositiveInfinity}
 
 @category Numeric
 */
@@ -88,8 +88,8 @@ import type {Integer} from 'type-fest';
 declare function setYear<T extends number>(length: Integer<T>): void;
 ```
 
-@see NegativeInteger
-@see NonNegativeInteger
+@see {@link NegativeInteger}
+@see {@link NonNegativeInteger}
 
 @category Numeric
 */
@@ -114,7 +114,7 @@ import type {Float} from 'type-fest';
 declare function setPercentage<T extends number>(length: Float<T>): void;
 ```
 
-@see Integer
+@see {@link Integer}
 
 @category Numeric
 */
@@ -129,8 +129,8 @@ Equivalent to `Negative<Float<T>>`.
 
 Use-case: Validating and documenting parameters.
 
-@see Negative
-@see Float
+@see {@link Negative}
+@see {@link Float}
 
 @category Numeric
 */
@@ -141,8 +141,8 @@ A negative `number`/`bigint` (`-∞ < x < 0`)
 
 Use-case: Validating and documenting parameters.
 
-@see NegativeInteger
-@see NonNegative
+@see {@link NegativeInteger}
+@see {@link NonNegative}
 
 @category Numeric
 */
@@ -156,8 +156,8 @@ You can't pass a `bigint` as they are already guaranteed to be integers, instead
 
 Use-case: Validating and documenting parameters.
 
-@see Negative
-@see Integer
+@see {@link Negative}
+@see {@link Integer}
 
 @category Numeric
 */
@@ -168,8 +168,8 @@ A non-negative `number`/`bigint` (`0 <= x < ∞`).
 
 Use-case: Validating and documenting parameters.
 
-@see NonNegativeInteger
-@see Negative
+@see {@link NonNegativeInteger}
+@see {@link Negative}
 
 @example
 ```
@@ -190,8 +190,8 @@ You can't pass a `bigint` as they are already guaranteed to be integers, instead
 
 Use-case: Validating and documenting parameters.
 
-@see NonNegative
-@see Integer
+@see {@link NonNegative}
+@see {@link Integer}
 
 @example
 ```
@@ -207,7 +207,7 @@ export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
 /**
 Returns a boolean for whether the given number is a negative number.
 
-@see Negative
+@see {@link Negative}
 
 @example
 ```

package/source/omit-index-signature.d.ts

@@ -85,7 +85,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 // => { foo: 'bar'; qux?: 'baz' | undefined; }
 ```
 
-@see PickIndexSignature
+@see {@link PickIndexSignature}
 @category Object
 */
 export type OmitIndexSignature<ObjectType> = {

package/source/or.d.ts

@@ -2,15 +2,15 @@ import type {If} from './if.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Returns a boolean for whether either of two given types are true.
+Returns a boolean for whether either of two given types is true.
 
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+Use-case: Constructing complex conditional types where at least one condition must be satisfied.
 
 @example
 ```
 import type {Or} from 'type-fest';
 
-type TT = Or<true, false>;
+type TT = Or<true, true>;
 //=> true
 
 type TF = Or<true, false>;
@@ -24,10 +24,11 @@ type FF = Or<false, false>;
 ```
 
 Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
-For example, `And<false, boolean>` expands to `And<false, true> | And<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+For example, `Or<false, boolean>` expands to `Or<false, true> | Or<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
 @example
 ```
-import type {And} from 'type-fest';
+import type {Or} from 'type-fest';
 
 type A = Or<false, boolean>;
 //=> boolean
@@ -74,6 +75,7 @@ type G = Or<never, never>;
 ```
 
 @see {@link And}
+@see {@link Xor}
 */
 export type Or<A extends boolean, B extends boolean> =
 	_Or<If<IsNever<A>, false, A>, If<IsNever<B>, false, B>>; // `never` is treated as `false`

package/source/package-json.d.ts

@@ -208,6 +208,15 @@ export namespace PackageJson {
 	*/
 	type Dependency = Partial<Record<string, string>>;
 
+	/**
+	Specifies requirements for development environment components such as operating systems, runtimes, or package managers. Used to ensure consistent development environments across the team.
+	*/
+	type DevEngineDependency = {
+		name: string;
+		version?: string;
+		onFail?: 'ignore' | 'warn' | 'error' | 'download';
+	};
+
 	/**
 	A mapping of conditions and the paths to which they resolve.
 	*/
@@ -563,6 +572,17 @@ export namespace PackageJson {
 			string
 		>>;
 
+		/**
+		Define the runtime and package manager for developing the current project.
+		*/
+		devEngines?: {
+			os?: DevEngineDependency | DevEngineDependency[];
+			cpu?: DevEngineDependency | DevEngineDependency[];
+			libc?: DevEngineDependency | DevEngineDependency[];
+			runtime?: DevEngineDependency | DevEngineDependency[];
+			packageManager?: DevEngineDependency | DevEngineDependency[];
+		};
+
 		/**
 		If set to `true`, a warning will be shown if package is installed locally. Useful if the package is primarily a command-line application that should be installed globally.
 

package/source/partial-on-undefined-deep.d.ts

@@ -4,7 +4,7 @@ import type {IsUnknown} from './is-unknown.d.ts';
 import type {Merge} from './merge.d.ts';
 
 /**
-@see PartialOnUndefinedDeep
+@see {@link PartialOnUndefinedDeep}
 */
 export type PartialOnUndefinedDeepOptions = {
 	/**

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

@@ -7,8 +7,8 @@ Convert object properties to pascal case recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see PascalCase
-@see PascalCasedProperties
+@see {@link PascalCase}
+@see {@link PascalCasedProperties}
 
 @example
 ```

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

@@ -7,8 +7,8 @@ Convert object properties to pascal case but not recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see PascalCase
-@see PascalCasedPropertiesDeep
+@see {@link PascalCase}
+@see {@link PascalCasedPropertiesDeep}
 
 @example
 ```

package/source/pick-index-signature.d.ts

@@ -40,7 +40,7 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 // }
 ```
 
-@see OmitIndexSignature
+@see {@link OmitIndexSignature}
 @category Object
 */
 export type PickIndexSignature<ObjectType> = {

package/source/shared-union-fields-deep.d.ts

@@ -81,7 +81,7 @@ function displayPetInfo(petInfo: SharedUnionFieldsDeep<Cat | Dog>['info']) {
 }
 ```
 
-@see SharedUnionFields
+@see {@link SharedUnionFields}
 
 @category Object
 @category Union

package/source/shared-union-fields.d.ts

@@ -59,8 +59,8 @@ function displayPetInfo(petInfo: SharedUnionFields<Cat | Dog>) {
 }
 ```
 
-@see SharedUnionFieldsDeep
-@see AllUnionFields
+@see {@link SharedUnionFieldsDeep}
+@see {@link AllUnionFields}
 
 @category Object
 @category Union

package/source/simplify-deep.d.ts

@@ -104,7 +104,7 @@ type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexTyp
 // };
 ```
 
-@see Simplify
+@see {@link Simplify}
 @category Object
 */
 export type SimplifyDeep<Type, ExcludeType = never> =

package/source/simplify.d.ts

@@ -52,7 +52,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 ```
 
 @link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
+@see {@link SimplifyDeep}
 @category Object
 */
 export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};

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

@@ -8,8 +8,8 @@ Convert object properties to snake case recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see SnakeCase
-@see SnakeCasedProperties
+@see {@link SnakeCase}
+@see {@link SnakeCasedProperties}
 
 @example
 ```

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

@@ -8,8 +8,8 @@ Convert object properties to snake case but not recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
-@see SnakeCase
-@see SnakeCasedPropertiesDeep
+@see {@link SnakeCase}
+@see {@link SnakeCasedPropertiesDeep}
 
 @example
 ```

package/source/split-on-rest-element.d.ts

@@ -56,8 +56,8 @@ type T5 = SplitOnRestElement<readonly [string?, ...number[]], {preserveOptionalM
 //=> readonly [[string], number[], []] or readonly [[string | undefined], number[], []]
 ```
 
-@see ExtractRestElement
-@see ExcludeRestElement
+@see {@link ExtractRestElement}
+@see {@link ExcludeRestElement}
 @category Array
 */
 export type SplitOnRestElement<

package/source/writable-deep.d.ts

@@ -23,7 +23,7 @@ writableDeepFoo.b = ['something'];
 
 Note that types containing overloaded functions are not made deeply writable due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
 
-@see Writable
+@see {@link Writable}
 @category Object
 @category Array
 @category Set