type-fest 5.0.1 → 5.2.0

package/index.d.ts

@@ -111,6 +111,9 @@ export type {WritableKeysOf} from './source/writable-keys-of.d.ts';
 export type {IsWritableKeyOf} from './source/is-writable-key-of.d.ts';
 export type {HasWritableKeys} from './source/has-writable-keys.d.ts';
 export type {Spread} from './source/spread.d.ts';
+export type {SplitOnRestElement} from './source/split-on-rest-element.d.ts';
+export type {ExtractRestElement} from './source/extract-rest-element.d.ts';
+export type {ExcludeRestElement} from './source/exclude-rest-element.d.ts';
 export type {IsInteger} from './source/is-integer.d.ts';
 export type {IsFloat} from './source/is-float.d.ts';
 export type {TupleToObject} from './source/tuple-to-object.d.ts';
@@ -138,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';
@@ -148,6 +152,7 @@ export type {IfNull} from './source/if-null.d.ts';
 export type {IsUndefined} from './source/is-undefined.d.ts';
 export type {And} from './source/and.d.ts';
 export type {Or} from './source/or.d.ts';
+export type {Xor} from './source/xor.d.ts';
 export type {AllExtend, AllExtendOptions} from './source/all-extend.d.ts';
 export type {NonEmptyTuple} from './source/non-empty-tuple.d.ts';
 export type {FindGlobalInstanceType, FindGlobalType} from './source/find-global-type.d.ts';
@@ -157,6 +162,8 @@ export type {IsLowercase} from './source/is-lowercase.d.ts';
 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';
@@ -197,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.0.1",
+	"version": "5.2.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -28,6 +28,7 @@
 		"test:tsc": "tsc",
 		"test:tsd": "tsd",
 		"test:xo": "xo",
+		"test:linter": "node --test",
 		"test": "run-p test:*"
 	},
 	"files": [
@@ -53,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

@@ -60,6 +60,8 @@ npm install type-fest
 > [!NOTE]
 > This readme shows the current development version. For docs about the latest version, see the [npm page](https://www.npmjs.com/package/type-fest).
 
+*You may also like my [`ts-extras`](https://github.com/sindresorhus/ts-extras) package which provides runtime functions for some of these types.*
+
 ## Usage
 
 ```ts
@@ -167,8 +169,8 @@ Click the type names for complete docs.
 - [`IntClosedRange`](source/int-closed-range.d.ts) - Generate a union of numbers (includes the start and the end).
 - [`ArrayIndices`](source/array-indices.d.ts) - Provides valid indices for a constant array or tuple.
 - [`ArrayValues`](source/array-values.d.ts) - Provides all values for a constant array or tuple.
-- [`ArraySplice`](source/array-splice.d.ts) - Creates a new array type by adding or removing elements at a specified index range in the original array.
-- [`ArrayTail`](source/array-tail.d.ts) - Extracts the type of an array or tuple minus the first element.
+- [`ArraySplice`](source/array-splice.d.ts) - Create a new array type by adding or removing elements at a specified index range in the original array.
+- [`ArrayTail`](source/array-tail.d.ts) - Extract the type of an array or tuple minus the first element.
 - [`SetFieldType`](source/set-field-type.d.ts) - Create a type that changes the type of the given keys.
 - [`Paths`](source/paths.d.ts) - Generate a union of all possible paths to properties in the given object.
 - [`SharedUnionFields`](source/shared-union-fields.d.ts) - Create a type with shared fields from a union of object types.
@@ -177,7 +179,8 @@ 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.
 - [`NonEmptyString`](source/non-empty-string.d.ts) - Matches any non-empty string.
@@ -185,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
 
@@ -238,7 +242,7 @@ Click the type names for complete docs.
 - [`Replace`](source/replace.d.ts) - Represents a string with some or all matches replaced by a replacement.
 - [`StringSlice`](source/string-slice.d.ts) - Returns a string slice of a given range, just like `String#slice()`.
 - [`StringRepeat`](source/string-repeat.d.ts) - Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
-- [`RemovePrefix`](source/remove-prefix.d.ts) - Removes the specified prefix from the start of a string.
+- [`RemovePrefix`](source/remove-prefix.d.ts) - Remove the specified prefix from the start of a string.
 
 ### Array
 
@@ -246,14 +250,19 @@ 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()`.
-- [`LastArrayElement`](source/last-array-element.d.ts) - Extracts 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.
+- [`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.
 - [`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/array into a union type of its elements.
 - [`UnionToTuple`](source/union-to-tuple.d.ts) - Convert a union type into an unordered tuple type of its elements.
 - [`TupleToObject`](source/tuple-to-object.d.ts) - Transforms a tuple into an object, mapping each tuple index to its corresponding type as a key-value pair.
+- [`TupleOf`](source/tuple-of.d.ts) - Create a tuple type of the specified length with elements of the specified type.
+- [`SplitOnRestElement`](source/split-on-rest-element.d.ts) - Splits an array into three parts, where the first contains all elements before the rest element, the second is the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element itself, and the third contains all elements after the rest element.
+- [`ExtractRestElement`](source/extract-rest-element.d.ts) - Extract the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element type from an array.
+- [`ExcludeRestElement`](source/exclude-rest-element.d.ts) - Create a tuple with the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element removed.
 
 ### Numeric
 
@@ -283,11 +292,11 @@ Click the type names for complete docs.
 - [`CamelCasedProperties`](source/camel-cased-properties.d.ts) - Convert object properties to camel-case (`fooBar`).
 - [`CamelCasedPropertiesDeep`](source/camel-cased-properties-deep.d.ts) - Convert object properties to camel-case recursively (`fooBar`).
 - [`KebabCase`](source/kebab-case.d.ts) - Convert a string literal to kebab-case (`foo-bar`).
-- [`KebabCasedProperties`](source/kebab-cased-properties.d.ts) - Convert a object properties to kebab-case recursively (`foo-bar`).
-- [`KebabCasedPropertiesDeep`](source/kebab-cased-properties-deep.d.ts) - Convert object properties to kebab-case (`foo-bar`).
-- [`PascalCase`](source/pascal-case.d.ts) - Converts a string literal to pascal-case (`FooBar`)
-- [`PascalCasedProperties`](source/pascal-cased-properties.d.ts) - Converts object properties to pascal-case (`FooBar`)
-- [`PascalCasedPropertiesDeep`](source/pascal-cased-properties-deep.d.ts) - Converts object properties to pascal-case (`FooBar`)
+- [`KebabCasedProperties`](source/kebab-cased-properties.d.ts) - Convert object properties to kebab-case (`foo-bar`).
+- [`KebabCasedPropertiesDeep`](source/kebab-cased-properties-deep.d.ts) - Convert object properties to kebab-case recursively (`foo-bar`).
+- [`PascalCase`](source/pascal-case.d.ts) - Convert a string literal to pascal-case (`FooBar`).
+- [`PascalCasedProperties`](source/pascal-cased-properties.d.ts) - Convert object properties to pascal-case (`FooBar`).
+- [`PascalCasedPropertiesDeep`](source/pascal-cased-properties-deep.d.ts) - Convert object properties to pascal-case recursively (`FooBar`).
 - [`SnakeCase`](source/snake-case.d.ts) - Convert a string literal to snake-case (`foo_bar`).
 - [`SnakeCasedProperties`](source/snake-cased-properties.d.ts) - Convert object properties to snake-case (`foo_bar`).
 - [`SnakeCasedPropertiesDeep`](source/snake-cased-properties-deep.d.ts) - Convert object properties to snake-case recursively (`foo_bar`).
@@ -342,6 +351,7 @@ Click the type names for complete docs.
 - `HomomorphicOmit` - See [`Except`](source/except.d.ts)
 - `IfAny`, `IfNever`, `If*` - See [`If`](source/if.d.ts)
 - `MaybePromise` - See [`Promisable`](source/promisable.d.ts)
+- `ReadonlyTuple` - See [`TupleOf`](source/tuple-of.d.ts)
 
 ## Tips
 

package/source/all-extend.d.ts

@@ -10,7 +10,7 @@ import type {UnknownArray} from './unknown-array.d.ts';
 /**
 @see {@link AllExtend}
 */
-type AllExtendOptions = {
+export type AllExtendOptions = {
 	/**
 	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
 
@@ -113,3 +113,5 @@ type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllE
 				: false
 		: true
 >, false, false>;
+
+export {};

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
@@ -86,3 +86,5 @@ Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<un
 		>
 		: never
 	: never;
+
+export {};

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,5 +74,8 @@ type G = And<never, never>;
 ```
 
 @see {@link Or}
+@see {@link Xor}
 */
 export type And<A extends boolean, B extends boolean> = AllExtend<[A, B], true>;
+
+export {};

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/array-indices.d.ts

@@ -21,3 +21,5 @@ const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
 */
 export type ArrayIndices<Element extends readonly unknown[]> =
 	Exclude<Partial<Element>['length'], Element['length']>;
+
+export {};

package/source/array-slice.d.ts

@@ -107,3 +107,5 @@ type ArraySliceByPositiveIndex<
 > = Start extends End
 	? Result
 	: ArraySliceByPositiveIndex<Array_, Sum<Start, 1>, End, [...Result, Array_[Start]]>;
+
+export {};

package/source/array-splice.d.ts

@@ -1,7 +1,8 @@
-import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal/index.d.ts';
+import type {StaticPartOfArray, VariablePartOfArray} from './internal/index.d.ts';
 import type {GreaterThanOrEqual} from './greater-than-or-equal.d.ts';
 import type {Subtract} from './subtract.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 
 /**
 The implementation of `SplitArrayByIndex` for fixed length arrays.
@@ -9,7 +10,7 @@ The implementation of `SplitArrayByIndex` for fixed length arrays.
 type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
 SplitIndex extends 0
 	? [[], T]
-	: T extends readonly [...BuildTuple<SplitIndex>, ...infer V]
+	: T extends readonly [...TupleOf<SplitIndex>, ...infer V]
 		? T extends readonly [...infer U, ...V]
 			? [U, V]
 			: [never, never]
@@ -22,7 +23,7 @@ type SplitVariableArrayByIndex<T extends UnknownArray,
 	SplitIndex extends number,
 	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
 	T2 = T1 extends number
-		? BuildTuple<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
+		? TupleOf<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
 		: [],
 > =
 SplitIndex extends 0
@@ -63,7 +64,7 @@ type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
 			: SplitFixedArrayByIndex<T, SplitIndex>;
 
 /**
-Creates a new array type by adding or removing elements at a specified index range in the original array.
+Create a new array type by adding or removing elements at a specified index range in the original array.
 
 Use-case: Replace or insert items in an array type.
 
@@ -97,3 +98,5 @@ export type ArraySplice<
 			? [...U, ...Items, ...X]
 			: never // Should never happen
 		: never; // Should never happen
+
+export {};

package/source/array-tail.d.ts

@@ -3,7 +3,7 @@ import type {IfNotAnyOrNever, IsArrayReadonly} from './internal/index.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
-Extracts the type of an array or tuple minus the first element.
+Extract the type of an array or tuple minus the first element.
 
 @example
 ```
@@ -66,3 +66,5 @@ type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?
 			: TArray // Happens when `TArray` is a non-tuple array (e.g., `string[]`) or has a leading rest element (e.g., `[...string[], number]`)
 		: Tail
 	: [];
+
+export {};

package/source/array-values.d.ts

@@ -20,3 +20,5 @@ const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
 @category Array
 */
 export type ArrayValues<T extends readonly unknown[]> = T[number];
+
+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
 ```
@@ -27,3 +27,5 @@ export type Arrayable<T> =
 	T
 // TODO: Use `readonly T[]` when this issue is resolved: https://github.com/microsoft/TypeScript/issues/17002
 	| T[];
+
+export {};

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

@@ -21,3 +21,5 @@ asyncFunction().then(value => doSomething(value));
 @category Async
 */
 export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
+
+export {};

package/source/asyncify.d.ts

@@ -30,3 +30,5 @@ const getFooAsync: AsyncifiedFooGetter = (someArg) => {
 @category Async
 */
 export type Asyncify<Function_ extends (...arguments_: any[]) => any> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;
+
+export {};

package/source/basic.d.ts

@@ -34,3 +34,5 @@ Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/relea
 @category Class
 */
 export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;
+
+export {};

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.
 
@@ -15,7 +15,8 @@ export type CamelCaseOptions = {
 	preserveConsecutiveUppercase?: boolean;
 };
 
-export type DefaultCamelCaseOptions = {
+export type _DefaultCamelCaseOptions = {
+	splitOnNumbers: true;
 	preserveConsecutiveUppercase: false;
 };
 
@@ -83,7 +84,9 @@ export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extend
 	? string extends Type
 		? Type
 		: Uncapitalize<CamelCaseFromArray<
-			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
-			ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>
+			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type, Options>,
+			ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>
 		>>
 	: Type;
+
+export {};

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

@@ -1,4 +1,4 @@
-import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './camel-case.d.ts';
 import type {ApplyDefaultOptions, NonRecursiveType} from './internal/index.d.ts';
 import type {UnknownArray} from './unknown-array.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
 ```
@@ -57,7 +57,7 @@ const preserveConsecutiveUppercase: CamelCasedPropertiesDeep<{fooBAR: {fooBARBiz
 export type CamelCasedPropertiesDeep<
 	Value,
 	Options extends CamelCaseOptions = {},
-> = _CamelCasedPropertiesDeep<Value, ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>>;
+> = _CamelCasedPropertiesDeep<Value, ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>>;
 
 type _CamelCasedPropertiesDeep<
 	Value,
@@ -95,3 +95,5 @@ type CamelCasedPropertiesArrayDeep<
 					: Value extends ReadonlyArray<infer U>
 						? ReadonlyArray<_CamelCasedPropertiesDeep<U, Options>>
 						: never;
+
+export {};

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

@@ -1,4 +1,4 @@
-import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './camel-case.d.ts';
 import type {ApplyDefaultOptions} from './internal/index.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
 ```
@@ -38,6 +38,8 @@ export type CamelCasedProperties<Value, Options extends CamelCaseOptions = {}> =
 		? Value
 		: {
 			[K in keyof Value as
-			CamelCase<K, ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>>
+			CamelCase<K, ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>>
 			]: Value[K];
 		};
+
+export {};

package/source/characters.d.ts

@@ -58,3 +58,5 @@ const b: Alphanumeric = '#'; // Invalid
 @category Type
 */
 export type Alphanumeric = LowercaseLetter | UppercaseLetter | DigitCharacter;
+
+export {};

package/source/conditional-except.d.ts

@@ -43,3 +43,5 @@ export type ConditionalExcept<Base, Condition> = Except<
 	Base,
 	ConditionalKeys<Base, Condition>
 >;
+
+export {};

package/source/conditional-keys.d.ts

@@ -59,3 +59,5 @@ type _ConditionalKeys<Base, Condition> = keyof {
 	ExtendsStrict<Base[Key], Condition> extends true ? Key : never
 	]: never
 };
+
+export {};

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
 ```
@@ -116,3 +116,5 @@ type _ConditionalPickDeep<
 			? _ConditionalPickDeep<Type[Key], Condition, Options>
 			: typeof conditionalPickDeepSymbol;
 }, (typeof conditionalPickDeepSymbol | undefined) | EmptyObject>, never, UnknownRecord>;
+
+export {};

package/source/conditional-pick.d.ts

@@ -42,3 +42,5 @@ export type ConditionalPick<Base, Condition> = Pick<
 	Base,
 	ConditionalKeys<Base, Condition>
 >;
+
+export {};

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
@@ -69,3 +69,5 @@ export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unk
 	: Type extends IncludeType
 		? {[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>}
 		: Type;
+
+export {};

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
@@ -46,3 +46,5 @@ export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown
 	: Type extends IncludeType
 		? {[TypeKey in keyof Type]: Type[TypeKey]}
 		: Type;
+
+export {};

package/source/delimiter-case.d.ts

@@ -2,9 +2,9 @@ import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal
 import type {IsStringLiteral} from './is-literal.d.ts';
 import type {Merge} from './merge.d.ts';
 import type {RemovePrefix} from './remove-prefix.d.ts';
-import type {DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
+import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 
-export type DefaultDelimiterCaseOptions = Merge<DefaultWordsOptions, {splitOnNumbers: false}>;
+export type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {splitOnNumbers: false}>;
 
 /**
 Convert an array of words to delimiter case starting with a delimiter with input capitalization.
@@ -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
 ```
@@ -69,7 +69,9 @@ export type DelimiterCase<
 	? IsStringLiteral<Value> extends false
 		? Value
 		: Lowercase<RemovePrefix<DelimiterCaseFromArray<
-			Words<Value, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>,
+			Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>,
 			Delimiter
 		>, string, {strict: false}>>
 	: Value;
+
+export {};

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

@@ -1,4 +1,4 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
+import type {_DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
 import type {ApplyDefaultOptions, NonRecursiveType} from './internal/index.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 import type {WordsOptions} from './words.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
 ```
@@ -61,7 +61,7 @@ export type DelimiterCasedPropertiesDeep<
 	Value,
 	Delimiter extends string,
 	Options extends WordsOptions = {},
-> = _DelimiterCasedPropertiesDeep<Value, Delimiter, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;
+> = _DelimiterCasedPropertiesDeep<Value, Delimiter, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
 
 type _DelimiterCasedPropertiesDeep<
 	Value,
@@ -104,3 +104,5 @@ type DelimiterCasedPropertiesArrayDeep<
 						: Value extends ReadonlyArray<infer U>
 							? ReadonlyArray<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>>
 							: never;
+
+export {};

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

@@ -1,4 +1,4 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
+import type {_DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.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
 ```
@@ -42,5 +42,7 @@ export type DelimiterCasedProperties<
 	: Value extends Array<infer U>
 		? Value
 		: {[K in keyof Value as
-			DelimiterCase<K, Delimiter, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>
+			DelimiterCase<K, Delimiter, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>
 			]: Value[K]};
+
+export {};