type-fest 5.0.0 → 5.1.0

package/source/readonly-deep.d.ts

@@ -41,11 +41,11 @@ export type ReadonlyDeep<T> = T extends BuiltIns
 	: T extends new (...arguments_: any[]) => unknown
 		? T // Skip class constructors
 		: T extends (...arguments_: any[]) => unknown
-			? {} extends ReadonlyObjectDeep<T>
+			? {} extends _ReadonlyObjectDeep<T>
 				? T
 				: HasMultipleCallSignatures<T> extends true
 					? T
-					: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
+					: ((...arguments_: Parameters<T>) => ReturnType<T>) & _ReadonlyObjectDeep<T>
 			: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
 				? ReadonlyMapDeep<KeyType, ValueType>
 				: T extends Readonly<ReadonlySet<infer ItemType>>
@@ -60,7 +60,7 @@ export type ReadonlyDeep<T> = T extends BuiltIns
 								: T extends ReadonlyArray<infer ItemType>
 									? ReadonlyArray<ReadonlyDeep<ItemType>>
 									: T extends object
-										? ReadonlyObjectDeep<T>
+										? _ReadonlyObjectDeep<T>
 										: unknown;
 
 /**
@@ -76,6 +76,8 @@ type ReadonlySetDeep<ItemType> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType
 /**
 Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
 */
-type ReadonlyObjectDeep<ObjectType extends object> = {
+export type _ReadonlyObjectDeep<ObjectType extends object> = {
 	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
 };
+
+export {};

package/source/readonly-keys-of.d.ts

@@ -34,3 +34,5 @@ export type ReadonlyKeysOf<Type extends object> =
 			]: never
 		}) & keyof Type // Intersect with `keyof Type` to ensure result of `ReadonlyKeysOf<Type>` is always assignable to `keyof Type`
 		: never; // Should never happen
+
+export {};

package/source/readonly-tuple.d.ts

@@ -1,13 +1,4 @@
-/**
-Creates a read-only tuple of type `Element` and with the length of `Length`.
-
-@private
-@see `ReadonlyTuple` which is safer because it tests if `Length` is a specific finite number.
-*/
-type BuildTupleHelper<Element, Length extends number, Rest extends Element[]> =
-	Rest['length'] extends Length ?
-		readonly [...Rest] : // Terminate with readonly array (aka tuple)
-		BuildTupleHelper<Element, Length, [Element, ...Rest]>;
+import type {TupleOf} from './tuple-of.d.ts';
 
 /**
 Create a type that represents a read-only tuple of the given type and length.
@@ -32,10 +23,10 @@ guestFencingTeam.push('Sam');
 //=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
 ```
 
+@deprecated This type will be removed in the next major version. Use the built-in `Readonly` type in combination with the {@link TupleOf} type instead, like `Readonly<TupleOf<Length, Element>>`.
+
 @category Utilities
 */
-export type ReadonlyTuple<Element, Length extends number> =
-	number extends Length
-		// Because `Length extends number` and `number extends Length`, then `Length` is not a specific finite number.
-		? readonly Element[] // It's not fixed length.
-		: BuildTupleHelper<Element, Length, []>; // Otherwise it is a fixed length tuple.
+export type ReadonlyTuple<Element, Length extends number> = Readonly<TupleOf<Length, Element>>;
+
+export {};

package/source/remove-prefix.d.ts

@@ -6,7 +6,7 @@ import type {Or} from './or.d.ts';
 /**
 @see {@link RemovePrefix}
 */
-type RemovePrefixOptions = {
+export type RemovePrefixOptions = {
 	/**
 	When enabled, instantiations with non-literal prefixes (e.g., `string`, `Uppercase<string>`, `` `on${string}` ``) simply return `string`, since their precise structure cannot be statically determined.
 
@@ -83,7 +83,7 @@ type DefaultRemovePrefixOptions = {
 };
 
 /**
-Removes the specified prefix from the start of a string.
+Remove the specified prefix from the start of a string.
 
 @example
 ```
@@ -126,3 +126,5 @@ Prefix extends string // For distributing `Prefix`
 			: string // Fallback to `string` when `Prefix` is non-literal and `strict` is disabled
 		: S // Return back `S` when `Prefix` is not present at the start of `S`
 	: never;
+
+export {};

package/source/replace.d.ts

@@ -1,6 +1,6 @@
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 
-type ReplaceOptions = {
+export type ReplaceOptions = {
 	all?: boolean;
 };
 
@@ -83,3 +83,5 @@ type _Replace<
 			: `${Accumulator}${Input}`
 		: never
 	: never;
+
+export {};

package/source/require-all-or-none.d.ts

@@ -50,3 +50,5 @@ type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireAll<ObjectType, KeysType>
 	| RequireNone<KeysType>
 ) & Omit<ObjectType, KeysType>; // The rest of the keys.
+
+export {};

package/source/require-at-least-one.d.ts

@@ -46,3 +46,5 @@ type _RequireAtLeastOne<
 }[KeysType] &
 // 3. Add the remaining keys not in `KeysType`
 Except<ObjectType, KeysType>;
+
+export {};

package/source/require-exactly-one.d.ts

@@ -44,3 +44,5 @@ type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
 		Required<Pick<ObjectType, Key>> &
 		Partial<Record<Exclude<KeysType, Key>, never>>
 	)}[KeysType] & Omit<ObjectType, KeysType>;
+
+export {};

package/source/require-one-or-none.d.ts

@@ -45,3 +45,5 @@ type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireExactlyOne<ObjectType, KeysType>
 	| RequireNone<KeysType>
 ) & Omit<ObjectType, KeysType>; // Ignore unspecified keys.
+
+export {};

package/source/required-deep.d.ts

@@ -1,4 +1,5 @@
 import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Create a type from another type with all keys and nested keys set to required.
@@ -58,7 +59,7 @@ export type RequiredDeep<T> = T extends BuiltIns
 							: T extends Promise<infer ValueType>
 								? Promise<RequiredDeep<ValueType>>
 								: T extends (...arguments_: any[]) => unknown
-									? {} extends RequiredObjectDeep<T>
+									? IsNever<keyof T> extends true
 										? T
 										: HasMultipleCallSignatures<T> extends true
 											? T
@@ -70,3 +71,5 @@ export type RequiredDeep<T> = T extends BuiltIns
 type RequiredObjectDeep<ObjectType extends object> = {
 	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
 };
+
+export {};

package/source/required-keys-of.d.ts

@@ -28,3 +28,5 @@ export type RequiredKeysOf<Type extends object> =
 	Type extends unknown // For distributing `Type`
 		? Exclude<keyof Type, OptionalKeysOf<Type>>
 		: never; // Should never happen
+
+export {};

package/source/schema.d.ts

@@ -112,3 +112,5 @@ type SchemaHelper<Type, Value, Options extends Required<SchemaOptions>> = Simpli
 		Value,
 		Options>
 }>;
+
+export {};

package/source/screaming-snake-case.d.ts

@@ -1,4 +1,4 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {SnakeCase} from './snake-case.d.ts';
 import type {WordsOptions} from './words.d.ts';
@@ -24,5 +24,7 @@ export type ScreamingSnakeCase<
 	Value,
 	Options extends WordsOptions = {},
 > = Value extends string
-	? Uppercase<SnakeCase<Value, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>>
+	? Uppercase<SnakeCase<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>>
 	: Value;
+
+export {};

package/source/set-field-type.d.ts

@@ -1,7 +1,7 @@
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {Simplify} from './simplify.d.ts';
 
-type SetFieldTypeOptions = {
+export type SetFieldTypeOptions = {
 	/**
 	Preserve optional and readonly modifiers for properties being updated.
 
@@ -63,3 +63,5 @@ type _SetFieldType<BaseType, Keys extends keyof BaseType, NewType, Options exten
 		// `Record` is used to remove property modifiers
 		Options['preservePropertyModifiers'] extends false ? Record<Keys, NewType> : unknown
 	)>;
+
+export {};

package/source/set-non-nullable-deep.d.ts

@@ -81,3 +81,5 @@ type SetNonNullableDeepSinglePath<BaseType, KeyPath> =
 					: BaseType[Key];
 			}
 			: Simplify<SetNonNullable<BaseType, (KeyPath | StringToNumber<KeyPath & string>) & keyof BaseType>>;
+
+export {};

package/source/set-non-nullable.d.ts

@@ -37,3 +37,5 @@ export type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseTyp
 		? NonNullable<BaseType[Key]>
 		: BaseType[Key];
 };
+
+export {};

package/source/set-optional.d.ts

@@ -42,3 +42,5 @@ type _SetOptional<BaseType, Keys extends keyof BaseType> =
 			Partial<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;
+
+export {};

package/source/set-parameter-type.d.ts

@@ -115,3 +115,5 @@ export type SetParameterType<Function_ extends (...arguments_: any[]) => unknown
 				: (this: ThisArgument, ...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
 		)
 		: Function_;	// This part should be unreachable
+
+export {};

package/source/set-readonly.d.ts

@@ -40,3 +40,5 @@ export type _SetReadonly<BaseType, Keys extends keyof BaseType> =
 			Readonly<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;
+
+export {};

package/source/set-required-deep.d.ts

@@ -66,3 +66,5 @@ type SetRequiredDeepSinglePath<BaseType, KeyPath> = BaseType extends NonRecursiv
 				: BaseType[Key];
 		}
 		: SetRequired<BaseType, (KeyPath | StringToNumber<KeyPath & string>) & keyof BaseType>;
+
+export {};

package/source/set-required.d.ts

@@ -75,3 +75,5 @@ type SetArrayRequired<
 				: SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]>
 			: never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
 	: never; // Should never happen
+
+export {};

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

@@ -27,3 +27,5 @@ export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeT
 		// This part should be unreachable, but we make it meaningful just in case…
 		(...arguments_: Parameters<Function_>) => TypeToReturn
 	);
+
+export {};

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

@@ -176,3 +176,5 @@ type InternalSharedArrayUnionFieldsDeep<
 				Union, Options,
 				[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
 			>;
+
+export {};

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

@@ -75,3 +75,5 @@ Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<un
 			: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
 		: never
 	: never;
+
+export {};

package/source/simplify-deep.d.ts

@@ -113,3 +113,5 @@ export type SimplifyDeep<Type, ExcludeType = never> =
 	ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>,
 	object
 	>;
+
+export {};

package/source/simplify.d.ts

@@ -56,3 +56,5 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @category Object
 */
 export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+export {};

package/source/single-key-object.d.ts

@@ -28,3 +28,5 @@ export type SingleKeyObject<ObjectType> =
 	IsUnion<keyof ObjectType> extends true
 		? never
 		: If<IsEmptyObject<ObjectType>, never, ObjectType>;
+
+export {};

package/source/snake-case.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,4 +42,6 @@ const dbResult: SnakeCasedProperties<ModelProps> = {
 export type SnakeCase<
 	Value,
 	Options extends WordsOptions = {},
-> = DelimiterCase<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;
+> = DelimiterCase<Value, '_', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

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

@@ -1,4 +1,4 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
 import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep.d.ts';
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
@@ -60,4 +60,6 @@ const splitOnNumbers: SnakeCasedPropertiesDeep<{line1: { line2: [{ line3: string
 export type SnakeCasedPropertiesDeep<
 	Value,
 	Options extends WordsOptions = {},
-> = DelimiterCasedPropertiesDeep<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;
+> = DelimiterCasedPropertiesDeep<Value, '_', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

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

@@ -1,4 +1,4 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
 import type {DelimiterCasedProperties} from './delimiter-cased-properties.d.ts';
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
@@ -37,4 +37,6 @@ const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: tru
 export type SnakeCasedProperties<
 	Value,
 	Options extends WordsOptions = {},
-> = DelimiterCasedProperties<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;
+> = DelimiterCasedProperties<Value, '_', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

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

@@ -0,0 +1,106 @@
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
+import type {IsArrayReadonly} from './internal/array.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {If} from './if.d.ts';
+
+/**
+{@link SplitOnRestElement} options.
+*/
+type SplitOnRestElementOptions = {
+	/**
+	Whether to preserve the optional modifier (`?`).
+
+	- When set to `true`, the optional modifiers are preserved as-is. For example:
+		`SplitOnRestElement<[number, string?, ...boolean[]], {preserveOptionalModifier: true}>` returns `[[number, string?], boolean[], []]`.
+
+	- When set to `false`, optional elements like `T?` are transformed to `T | undefined` or simply `T` depending on the `exactOptionalPropertyTypes` compiler option. For example:
+		- With `exactOptionalPropertyTypes` enabled: `SplitOnRestElement<[number, string?, ...boolean[]], {preserveOptionalModifier: false}>` returns `[[number, string], boolean[], []]`
+		- And, with it disabled, the result is: `[[number, string | undefined], boolean[], []]`
+
+	@default true
+	*/
+	preserveOptionalModifier?: boolean;
+};
+
+type DefaultSplitOnRestElementOptions = {
+	preserveOptionalModifier: true;
+};
+
+/**
+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.
+
+Note: If any of the parts are missing, then they will be represented as empty arrays. For example, `SplitOnRestElement<[string, number]>` returns `[[string, number], [], []]`, where parts corresponding to the rest element and elements after it are empty.
+
+By default, the optional modifier (`?`) is preserved.
+See {@link SplitOnRestElementOptions `SplitOnRestElementOptions`}.
+
+@example
+```ts
+import type {SplitOnRestElement} from 'type-fest';
+
+type T1 = SplitOnRestElement<[number, ...string[], boolean]>;
+//=> [[number], string[], [boolean]]
+
+type T2 = SplitOnRestElement<readonly [...boolean[], string]>;
+//=> readonly [[], boolean[], [string]]
+
+type T3 = SplitOnRestElement<[number, string?]>;
+//=> [[number, string?], [], []]
+
+type T4 = SplitOnRestElement<[number, string?], {preserveOptionalModifier: false}>;
+//=> [[number, string], [], []] or [[number, string | undefined], [], []]
+
+type T5 = SplitOnRestElement<readonly [string?, ...number[]], {preserveOptionalModifier: false}>;
+//=> readonly [[string], number[], []] or readonly [[string | undefined], number[], []]
+```
+
+@see ExtractRestElement
+@see ExcludeRestElement
+@category Array
+*/
+export type SplitOnRestElement<
+	Array_ extends UnknownArray,
+	Options extends SplitOnRestElementOptions = {},
+> =
+	Array_ extends unknown // For distributing `Array_`
+		? IfNotAnyOrNever<Array_, _SplitOnRestElement<
+			Array_,
+			ApplyDefaultOptions<SplitOnRestElementOptions, DefaultSplitOnRestElementOptions, Options>
+		>> extends infer Result extends UnknownArray
+			? If<IsArrayReadonly<Array_>, Readonly<Result>, Result>
+			: never // Should never happen
+		: never; // Should never happen
+
+/**
+Deconstructs an array on its rest element and returns the split portions.
+*/
+export type _SplitOnRestElement<
+	Array_ extends UnknownArray,
+	Options extends Required<SplitOnRestElementOptions>,
+	HeadAcc extends UnknownArray = [],
+	TailAcc extends UnknownArray = [],
+> =
+	keyof Array_ & `${number}` extends never
+		// Enters this branch, if `Array_` is empty (e.g., []),
+		// or `Array_` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		? Array_ extends readonly [...infer Rest, infer Last]
+			? _SplitOnRestElement<Rest, Options, HeadAcc, [Last, ...TailAcc]> // Accumulate elements that are present after the rest element.
+			: [HeadAcc, Array_ extends readonly [] ? [] : Array_, TailAcc] // Add the rest element between the accumulated elements.
+		: Array_ extends readonly [(infer First)?, ...infer Rest]
+			? _SplitOnRestElement<
+				Rest, Options,
+				[
+					...HeadAcc,
+					...IsOptionalKeyOf<Array_, '0'> extends true
+						? Options['preserveOptionalModifier'] extends false
+							? [If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>] // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+							: [First?]
+						: [First],
+				],
+				TailAcc
+			> // Accumulate elements that are present before the rest element.
+			: never; // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+
+export {};

package/source/split.d.ts

@@ -8,7 +8,7 @@ Split options.
 
 @see {@link Split}
 */
-type SplitOptions = {
+export type SplitOptions = {
 	/**
 	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
 
@@ -86,3 +86,5 @@ type SplitHelper<
 			: string[]
 		: never // Should never happen
 	: never; // Should never happen
+
+export {};

package/source/spread.d.ts

@@ -82,3 +82,5 @@ export type Spread<
 		? SpreadTupleOrArray<FirstType, SecondType>
 		: Simplify<SpreadObject<FirstType, SecondType>>
 	: Simplify<SpreadObject<FirstType, SecondType>>;
+
+export {};

package/source/string-repeat.d.ts

@@ -45,3 +45,5 @@ type StringRepeatHelper<
 				: IsNumericLiteral<Count> extends false
 					? string
 					: StringRepeatHelper<Input, Count, [...Counter, never], `${Accumulator}${Input}`>;
+
+export {};

package/source/string-slice.d.ts

@@ -35,3 +35,5 @@ export type StringSlice<
 	: ArraySlice<StringToArray<S>, Start, End> extends infer R extends readonly string[]
 		? Join<R, ''>
 		: never;
+
+export {};

package/source/stringified.d.ts

@@ -21,3 +21,5 @@ const carForm: Stringified<Car> = {
 @category Object
 */
 export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};
+
+export {};

package/source/structured-cloneable.d.ts

@@ -90,3 +90,5 @@ structuredClone(good);
 @category Structured clone
 */
 export type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;
+
+export {};

package/source/subtract.d.ts

@@ -1,6 +1,7 @@
-import type {NumberAbsolute, BuildTuple, ReverseSign} from './internal/index.d.ts';
+import type {NumberAbsolute, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {LessThan} from './less-than.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 
 /**
 Returns the difference between two numbers.
@@ -60,7 +61,7 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNeg
 			// When both numbers are negative we subtract the absolute values and then reverse the sign
 			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
 			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
+			: [...TupleOf<NumberAbsolute<A>>, ...TupleOf<NumberAbsolute<B>>] extends infer R extends unknown[]
 				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
 				: never;
 
@@ -78,6 +79,8 @@ Subtracts two positive numbers A and B such that A > B.
 */
 type SubtractIfAGreaterThanB<A extends number, B extends number> =
 	// This is where we always want to end up and do the actual subtraction
-	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
+	TupleOf<A> extends [...TupleOf<B>, ...infer R]
 		? R['length']
 		: never;
+
+export {};

package/source/sum.d.ts

@@ -1,4 +1,5 @@
-import type {NumberAbsolute, BuildTuple, TupleMax, ReverseSign} from './internal/index.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
+import type {NumberAbsolute, TupleMax, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {Subtract} from './subtract.d.ts';
 
@@ -73,6 +74,8 @@ type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative
 Adds two positive numbers.
 */
 type SumPositives<A extends number, B extends number> =
-	[...BuildTuple<A>, ...BuildTuple<B>]['length'] extends infer Result extends number
+	[...TupleOf<A>, ...TupleOf<B>]['length'] extends infer Result extends number
 		? Result
 		: never;
+
+export {};

package/source/tagged-union.d.ts

@@ -49,3 +49,5 @@ export type TaggedUnion<
 > = {
 	[Name in keyof UnionMembers]: {[Key in TagKey]: Name} & UnionMembers[Name];
 }[keyof UnionMembers];
+
+export {};

package/source/tagged.d.ts

@@ -1,5 +1,6 @@
 import type tag from 'tagged-tag';
 
+// eslint-disable-next-line type-fest/require-exported-types
 export type TagContainer<Token> = {
 	readonly [tag]: Token;
 };
@@ -256,3 +257,5 @@ export type UnwrapOpaque<OpaqueType extends TagContainer<unknown>> =
 			: OpaqueType;
 
 export {type default as tag} from 'tagged-tag';
+
+export {};

package/source/trim.d.ts

@@ -25,3 +25,5 @@ Trim<' foo '>
 @category Template literal
 */
 export type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+
+export {};