type-fest 5.0.0 → 5.1.0

package/index.d.ts

@@ -17,7 +17,7 @@ export type {UnknownRecord} from './source/unknown-record.d.ts';
 export type {UnknownArray} from './source/unknown-array.d.ts';
 export type {UnknownSet} from './source/unknown-set.d.ts';
 export type {UnknownMap} from './source/unknown-map.d.ts';
-export type {Except} from './source/except.d.ts';
+export type {Except, ExceptOptions} from './source/except.d.ts';
 export type {TaggedUnion} from './source/tagged-union.d.ts';
 export type {Writable} from './source/writable.d.ts';
 export type {WritableDeep} from './source/writable-deep.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';
@@ -132,23 +135,24 @@ export type {IsNever} from './source/is-never.d.ts';
 export type {IfNever} from './source/if-never.d.ts';
 export type {IsUnknown} from './source/is-unknown.d.ts';
 export type {IfUnknown} from './source/if-unknown.d.ts';
-export type {IsTuple} from './source/is-tuple.d.ts';
+export type {IsTuple, IsTupleOptions} from './source/is-tuple.d.ts';
 export type {ArrayIndices} from './source/array-indices.d.ts';
 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 {SetFieldType} from './source/set-field-type.d.ts';
-export type {Paths} from './source/paths.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';
 export type {SharedUnionFields} from './source/shared-union-fields.d.ts';
-export type {SharedUnionFieldsDeep} from './source/shared-union-fields-deep.d.ts';
+export type {SharedUnionFieldsDeep, SharedUnionFieldsDeepOptions} from './source/shared-union-fields-deep.d.ts';
 export type {IsNull} from './source/is-null.d.ts';
 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 {AllExtend} from './source/all-extend.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';
 export type {If} from './source/if.d.ts';
@@ -157,9 +161,10 @@ 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';
 
 // Template literal types
-export type {CamelCase} from './source/camel-case.d.ts';
+export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';
 export type {CamelCasedProperties} from './source/camel-cased-properties.d.ts';
 export type {CamelCasedPropertiesDeep} from './source/camel-cased-properties-deep.d.ts';
 export type {KebabCase} from './source/kebab-case.d.ts';
@@ -176,17 +181,17 @@ export type {DelimiterCase} from './source/delimiter-case.d.ts';
 export type {DelimiterCasedProperties} from './source/delimiter-cased-properties.d.ts';
 export type {DelimiterCasedPropertiesDeep} from './source/delimiter-cased-properties-deep.d.ts';
 export type {Join} from './source/join.d.ts';
-export type {Split} from './source/split.d.ts';
-export type {Words} from './source/words.d.ts';
+export type {Split, SplitOptions} from './source/split.d.ts';
+export type {Words, WordsOptions} from './source/words.d.ts';
 export type {Trim} from './source/trim.d.ts';
-export type {Replace} from './source/replace.d.ts';
+export type {Replace, ReplaceOptions} from './source/replace.d.ts';
 export type {StringRepeat} from './source/string-repeat.d.ts';
 export type {Includes} from './source/includes.d.ts';
-export type {Get} from './source/get.d.ts';
+export type {Get, GetOptions} from './source/get.d.ts';
 export type {LastArrayElement} from './source/last-array-element.d.ts';
 export type {ConditionalSimplify} from './source/conditional-simplify.d.ts';
 export type {ConditionalSimplifyDeep} from './source/conditional-simplify-deep.d.ts';
-export type {RemovePrefix} from './source/remove-prefix.d.ts';
+export type {RemovePrefix, RemovePrefixOptions} from './source/remove-prefix.d.ts';
 
 // Miscellaneous
 export type {GlobalThis} from './source/global-this.d.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.0.0",
+	"version": "5.1.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": [

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.
@@ -178,6 +180,7 @@ Click the type names for complete docs.
 - [`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.
+- [`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.
@@ -238,7 +241,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 +249,18 @@ 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.
+- [`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 +290,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 +349,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

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

package/source/and.d.ts

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

@@ -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

@@ -15,7 +15,7 @@ export type CamelCaseOptions = {
 	preserveConsecutiveUppercase?: boolean;
 };
 
-export type DefaultCamelCaseOptions = {
+export type _DefaultCamelCaseOptions = {
 	preserveConsecutiveUppercase: false;
 };
 
@@ -84,6 +84,8 @@ export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extend
 		? Type
 		: Uncapitalize<CamelCaseFromArray<
 			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
-			ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, 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';
 
@@ -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';
 
 /**
@@ -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

@@ -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

@@ -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

@@ -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.
@@ -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';
@@ -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';
 
@@ -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 {};

package/source/distributed-omit.d.ts

@@ -87,3 +87,5 @@ export type DistributedOmit<ObjectType, KeyType extends KeysOfUnion<ObjectType>>
 	ObjectType extends unknown
 		? Omit<ObjectType, KeyType>
 		: never;
+
+export {};

package/source/distributed-pick.d.ts

@@ -83,3 +83,5 @@ export type DistributedPick<ObjectType, KeyType extends KeysOfUnion<ObjectType>>
 	ObjectType extends unknown
 		? Pick<ObjectType, Extract<KeyType, keyof ObjectType>>
 		: never;
+
+export {};

package/source/empty-object.d.ts

@@ -44,3 +44,5 @@ type Fail = IsEmptyObject<null>; //=> false
 @category Object
 */
 export type IsEmptyObject<T> = T extends EmptyObject ? true : false;
+
+export {};

package/source/entries.d.ts

@@ -1,9 +1,9 @@
-import type {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry.d.ts';
+import type {_ArrayEntry, _MapEntry, _ObjectEntry, _SetEntry} from './entry.d.ts';
 
-type ArrayEntries<BaseType extends readonly unknown[]> = Array<ArrayEntry<BaseType>>;
-type MapEntries<BaseType> = Array<MapEntry<BaseType>>;
-type ObjectEntries<BaseType> = Array<ObjectEntry<BaseType>>;
-type SetEntries<BaseType extends Set<unknown>> = Array<SetEntry<BaseType>>;
+type ArrayEntries<BaseType extends readonly unknown[]> = Array<_ArrayEntry<BaseType>>;
+type MapEntries<BaseType> = Array<_MapEntry<BaseType>>;
+type ObjectEntries<BaseType> = Array<_ObjectEntry<BaseType>>;
+type SetEntries<BaseType extends Set<unknown>> = Array<_SetEntry<BaseType>>;
 
 /**
 Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entries` type will return the type of that collection's entries.
@@ -60,3 +60,5 @@ export type Entries<BaseType> =
 			: BaseType extends readonly unknown[] ? ArrayEntries<BaseType>
 				: BaseType extends object ? ObjectEntries<BaseType>
 					: never;
+
+export {};

package/source/entry.d.ts

@@ -1,10 +1,10 @@
 type MapKey<BaseType> = BaseType extends Map<infer KeyType, unknown> ? KeyType : never;
 type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
 
-export type ArrayEntry<BaseType extends readonly unknown[]> = [number, BaseType[number]];
-export type MapEntry<BaseType> = [MapKey<BaseType>, MapValue<BaseType>];
-export type ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
-export type SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
+export type _ArrayEntry<BaseType extends readonly unknown[]> = [number, BaseType[number]];
+export type _MapEntry<BaseType> = [MapKey<BaseType>, MapValue<BaseType>];
+export type _ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
+export type _SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
 
 /**
 Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry.
@@ -58,8 +58,10 @@ const setEntryNumber: Entry<typeof setExample> = [1, 1];
 @category Set
 */
 export type Entry<BaseType> =
-	BaseType extends Map<unknown, unknown> ? MapEntry<BaseType>
-		: BaseType extends Set<unknown> ? SetEntry<BaseType>
-			: BaseType extends readonly unknown[] ? ArrayEntry<BaseType>
-				: BaseType extends object ? ObjectEntry<BaseType>
+	BaseType extends Map<unknown, unknown> ? _MapEntry<BaseType>
+		: BaseType extends Set<unknown> ? _SetEntry<BaseType>
+			: BaseType extends readonly unknown[] ? _ArrayEntry<BaseType>
+				: BaseType extends object ? _ObjectEntry<BaseType>
 					: never;
+
+export {};

package/source/exact.d.ts

@@ -66,3 +66,5 @@ export type Exact<ParameterType, InputType> =
 						// In TypeScript, Array is a subtype of ReadonlyArray, so always test Array before ReadonlyArray.
 						: ParameterType extends readonly unknown[] ? ReadonlyArray<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
 							: ExactObject<ParameterType, InputType>;
+
+export {};

package/source/except.d.ts

@@ -30,7 +30,7 @@ type Filtered = Filter<'bar', 'foo'>;
 */
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 
-type ExceptOptions = {
+export type ExceptOptions = {
 	/**
 	Disallow assigning non-specified properties.
 
@@ -106,3 +106,5 @@ type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Requ
 } & (Options['requireExactProps'] extends true
 	? Partial<Record<KeysType, never>>
 	: {});
+
+export {};

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

@@ -0,0 +1,37 @@
+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';
+
+/**
+Create a tuple with the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element removed.
+
+@example
+```
+import type {ExcludeRestElement} from 'type-fest';
+
+type T1 = ExcludeRestElement<[number, ...string[], string, 'foo']>;
+//=> [number, string, 'foo']
+
+type T2 = ExcludeRestElement<[...boolean[], string]>;
+//=> [string]
+
+type T3 = ExcludeRestElement<[...'foo'[], true]>;
+//=> [true]
+
+type T4 = ExcludeRestElement<[number, string]>;
+//=> [number, string]
+```
+
+@see ExtractRestElement, SplitOnRestElement
+@category Array
+*/
+export type ExcludeRestElement<Array_ extends UnknownArray> =
+	SplitOnRestElement<Array_> extends infer Result
+		? Result extends readonly UnknownArray[]
+			? IsArrayReadonly<Array_> extends true
+				? Readonly<[...Result[0], ...Result[2]]>
+				: [...Result[0], ...Result[2]]
+			: Result
+		: never;
+
+export {};

package/source/exclude-strict.d.ts

@@ -43,3 +43,5 @@ export type ExcludeStrict<
 		? unknown
 		: never,
 > = Exclude<T, U>;
+
+export {};