type-fest 4.40.1 → 5.0.0

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

@@ -1,6 +1,6 @@
-import type {CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {PascalCase} from './pascal-case';
+import type {CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {PascalCase} from './pascal-case.d.ts';
 
 /**
 Convert object properties to pascal case but not recursively.
@@ -23,6 +23,10 @@ const result: PascalCasedProperties<User> = {
 	UserId: 1,
 	UserName: 'Tom',
 };
+
+const preserveConsecutiveUppercase: PascalCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
+	FooBAR: 'string',
+};
 ```
 
 @category Change case

package/source/paths.d.ts

@@ -1,9 +1,9 @@
-import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString, IsNumberLike, ApplyDefaultOptions} from './internal';
-import type {EmptyObject} from './empty-object';
-import type {IsAny} from './is-any';
-import type {UnknownArray} from './unknown-array';
-import type {Subtract} from './subtract';
-import type {GreaterThan} from './greater-than';
+import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString, IsNumberLike, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {Subtract} from './subtract.d.ts';
+import type {GreaterThan} from './greater-than.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Paths options.
@@ -12,9 +12,9 @@ Paths options.
 */
 export type PathsOptions = {
 	/**
-	The maximum depth to recurse when searching for paths.
+	The maximum depth to recurse when searching for paths. Range: 0 ~ 10.
 
-	@default 10
+	@default 5
 	*/
 	maxRecursionDepth?: number;
 
@@ -129,7 +129,7 @@ export type PathsOptions = {
 };
 
 type DefaultPathsOptions = {
-	maxRecursionDepth: 10;
+	maxRecursionDepth: 5;
 	bracketNotation: false;
 	leavesOnly: false;
 	depth: number;
@@ -186,8 +186,7 @@ type _Paths<T, Options extends Required<PathsOptions>> =
 			: T extends UnknownArray
 				? number extends T['length']
 					// We need to handle the fixed and non-fixed index part of the array separately.
-					? InternalPaths<StaticPartOfArray<T>, Options>
-					| InternalPaths<Array<VariablePartOfArray<T>[number]>, Options>
+					? InternalPaths<StaticPartOfArray<T>, Options> | InternalPaths<Array<VariablePartOfArray<T>[number]>, Options>
 					: InternalPaths<T, Options>
 				: T extends object
 					? InternalPaths<T, Options>
@@ -196,30 +195,34 @@ type _Paths<T, Options extends Required<PathsOptions>> =
 type InternalPaths<T, Options extends Required<PathsOptions>> =
 	Options['maxRecursionDepth'] extends infer MaxDepth extends number
 		? Required<T> extends infer T
-			? T extends EmptyObject | readonly []
+			? T extends readonly []
 				? never
-				: {
-					[Key in keyof T]:
-					Key extends string | number // Limit `Key` to string or number.
-						? (
-							Options['bracketNotation'] extends true
-								? IsNumberLike<Key> extends true
-									? `[${Key}]`
-									: (Key | ToString<Key>)
-								: never
-								|
-								Options['bracketNotation'] extends false
-								// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-									? (Key | ToString<Key>)
-									: never
-						) extends infer TranformedKey extends string | number ?
-						// 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
-						// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
+				: IsNever<keyof T> extends true // Check for empty object
+					? never
+					: {
+						[Key in keyof T]:
+						Key extends string | number // Limit `Key` to string or number.
+							? (
+								Options['bracketNotation'] extends true
+									? IsNumberLike<Key> extends true
+										? `[${Key}]`
+										: (Key | ToString<Key>)
+									: Options['bracketNotation'] extends false
+									// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
+										? (Key | ToString<Key>)
+										: never
+							) extends infer TranformedKey extends string | number ?
+							// 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
+							// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
 							| ((Options['leavesOnly'] extends true
 								? MaxDepth extends 0
 									? TranformedKey
-									: T[Key] extends EmptyObject | readonly [] | NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
-										? TranformedKey
+									: T[Key] extends infer Value
+										? (Value extends readonly [] | NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+											? TranformedKey
+											: IsNever<keyof Value> extends true // Check for empty object
+												? TranformedKey
+												: never)
 										: never
 								: TranformedKey
 							) extends infer _TransformedKey
@@ -233,12 +236,12 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 								// Recursively generate paths for the current key
 								GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
 									? _Paths<T[Key],
-									{
-										bracketNotation: Options['bracketNotation'];
-										maxRecursionDepth: Subtract<MaxDepth, 1>;
-										leavesOnly: Options['leavesOnly'];
-										depth: Subtract<Options['depth'], 1>;
-									}> extends infer SubPath
+										{
+											bracketNotation: Options['bracketNotation'];
+											maxRecursionDepth: Subtract<MaxDepth, 1>;
+											leavesOnly: Options['leavesOnly'];
+											depth: Subtract<Options['depth'], 1>;
+										}> extends infer SubPath
 										? SubPath extends string | number
 											? (
 												Options['bracketNotation'] extends true
@@ -255,8 +258,8 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 										: never
 									: never
 							)
+								: never
 							: never
-						: never
-				}[keyof T & (T extends UnknownArray ? number : unknown)]
+					}[keyof T & (T extends UnknownArray ? number : unknown)]
 			: never
 		: never;

package/source/pick-deep.d.ts

@@ -1,9 +1,9 @@
-import type {BuildObject, BuildTuple, NonRecursiveType, ObjectValue} from './internal';
-import type {IsNever} from './is-never';
-import type {Paths} from './paths';
-import type {Simplify} from './simplify.d';
-import type {UnionToIntersection} from './union-to-intersection.d';
-import type {UnknownArray} from './unknown-array';
+import type {BuildObject, BuildTuple, NonRecursiveType, ObjectValue} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Paths} from './paths.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnionToIntersection} from './union-to-intersection.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Pick properties from a deeply-nested object.

package/source/readonly-deep.d.ts

@@ -1,4 +1,4 @@
-import type {BuiltIns, HasMultipleCallSignatures} from './internal';
+import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
 
 /**
 Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
@@ -23,7 +23,7 @@ const data: ReadonlyDeep<typeof dataJson> = dataJson;
 export default data;
 
 // test.ts
-import data from './main';
+import data from './main.d.ts';
 
 data.foo.push('bar');
 //=> error TS2339: Property 'push' does not exist on type 'readonly string[]'

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

@@ -1,4 +1,4 @@
-import type {WritableKeysOf} from './writable-keys-of';
+import type {IsReadonlyKeyOf} from './is-readonly-key-of.d.ts';
 
 /**
 Extract all readonly keys from the given type.
@@ -12,6 +12,7 @@ import type {ReadonlyKeysOf} from 'type-fest';
 interface User {
 	name: string;
 	surname: string;
+
 	readonly id: number;
 }
 
@@ -24,7 +25,12 @@ const update1: UpdateResponse<User> = {
 
 @category Utilities
 */
-export type ReadonlyKeysOf<T> =
-	T extends unknown // For distributing `T`
-		? Exclude<keyof T, WritableKeysOf<T>>
+export type ReadonlyKeysOf<Type extends object> =
+	Type extends unknown // For distributing `Type`
+		? (keyof {[Key in keyof Type as
+			IsReadonlyKeyOf<Type, Key> extends false
+				? never
+				: Key
+			]: never
+		}) & keyof Type // Intersect with `keyof Type` to ensure result of `ReadonlyKeysOf<Type>` is always assignable to `keyof Type`
 		: never; // Should never happen

package/source/remove-prefix.d.ts

@@ -0,0 +1,128 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+@see {@link RemovePrefix}
+*/
+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.
+
+	Note: Disabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, ``RemovePrefix<'on-change', `${string}-`, {strict: false}>`` returns `'change'`, but at runtime, prefix could be `'handle-'` (which satisfies `` `${string}-` ``) and removing `'handle-'` from `'on-change'` would not result in `'change'`.
+
+	So, it is recommended to not disable this option unless you are aware of the implications.
+
+	@default true
+
+	@example
+	```
+	type A = RemovePrefix<'on-change', `${string}-`, {strict: true}>;
+	//=> string
+
+	type B = RemovePrefix<'on-change', `${string}-`, {strict: false}>;
+	//=> 'change'
+
+	type C = RemovePrefix<'on-change', string, {strict: true}>;
+	//=> string
+
+	type D = RemovePrefix<'on-change', string, {strict: false}>;
+	//=> 'n-change'
+
+	type E = RemovePrefix<`${string}/${number}`, `${string}/`, {strict: true}>;
+	//=> string
+
+	type F = RemovePrefix<`${string}/${number}`, `${string}/`, {strict: false}>;
+	//=> `${number}`
+	```
+
+	Note: This option has no effect when only the input string type is non-literal. For example, ``RemovePrefix<`on-${string}`, 'on-'>`` will always return `string`.
+
+	@example
+	```
+	import type {RemovePrefix} from 'type-fest';
+
+	type A = RemovePrefix<`on-${string}`, 'on-', {strict: true}>;
+	//=> string
+
+	type B = RemovePrefix<`on-${string}`, 'on-', {strict: false}>;
+	//=> string
+
+	type C = RemovePrefix<`id-${number}`, 'id-', {strict: true}>;
+	//=> `${number}`
+
+	type D = RemovePrefix<`id-${number}`, 'id-', {strict: false}>;
+	//=> `${number}`
+	```
+
+	Note: If it can be statically determined that the input string can never start with the specified non-literal prefix, then the input string is returned as-is, regardless of the value of this option.
+	For example, ``RemovePrefix<`${string}/${number}`, `${string}:`>`` returns `` `${string}/${number}` ``, since a string of type `` `${string}/${number}` `` can never start with a prefix of type `` `${string}:` ``.
+	```
+	import type {RemovePrefix} from 'type-fest';
+
+	type A = RemovePrefix<`${string}/${number}`, `${string}:`, {strict: true}>;
+	//=> `${string}/${number}`
+
+	type B = RemovePrefix<`${string}/${number}`, `${string}:`, {strict: false}>;
+	//=> `${string}/${number}`
+
+	type C = RemovePrefix<'on-change', `${number}-`, {strict: true}>;
+	//=> 'on-change'
+
+	type D = RemovePrefix<'on-change', `${number}-`, {strict: false}>;
+	//=> 'on-change'
+	```
+	*/
+	strict?: boolean;
+};
+
+type DefaultRemovePrefixOptions = {
+	strict: true;
+};
+
+/**
+Removes the specified prefix from the start of a string.
+
+@example
+```
+import type {RemovePrefix} from 'type-fest';
+
+type A = RemovePrefix<'on-change', 'on-'>;
+//=> 'change'
+
+type B = RemovePrefix<'sm:flex' | 'sm:p-4' | 'sm:gap-2', 'sm:'>;
+//=> 'flex' | 'p-4' | 'gap-2'
+
+type C = RemovePrefix<'on-change', 'off-'>;
+//=> 'on-change'
+
+type D = RemovePrefix<`handle${Capitalize<string>}`, 'handle'>;
+//=> Capitalize<string>
+```
+
+@see {@link RemovePrefixOptions}
+
+@category String
+@category Template literal
+*/
+export type RemovePrefix<S extends string, Prefix extends string, Options extends RemovePrefixOptions = {}> =
+IfNotAnyOrNever<
+	S,
+	IfNotAnyOrNever<
+		Prefix,
+		_RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>,
+		string,
+		S
+	>
+>;
+
+type _RemovePrefix<S extends string, Prefix extends string, Options extends Required<RemovePrefixOptions>> =
+Prefix extends string // For distributing `Prefix`
+	? S extends `${Prefix}${infer Rest}`
+		? Or<IsStringLiteral<Prefix>, Not<Options['strict']>> extends true
+			? Rest
+			: 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;

package/source/replace.d.ts

@@ -1,4 +1,4 @@
-import type {ApplyDefaultOptions} from './internal';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
 
 type ReplaceOptions = {
 	all?: boolean;

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

@@ -1,4 +1,7 @@
-import type {RequireNone} from './internal';
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, RequireNone} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Requires all of the keys in the given object.
@@ -36,7 +39,14 @@ const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
 
 @category Object
 */
-export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = (
+export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType,
+		If<IsNever<KeysType>,
+			ObjectType,
+			_RequireAllOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
+		>>;
+
+type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireAll<ObjectType, KeysType>
 	| RequireNone<KeysType>
 ) & Omit<ObjectType, KeysType>; // The rest of the keys.

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

@@ -1,4 +1,8 @@
-import type {Except} from './except';
+import type {Except} from './except.d.ts';
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Create a type that requires at least one of the given keys. The remaining keys are kept as is.
@@ -24,11 +28,21 @@ const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 export type RequireAtLeastOne<
 	ObjectType,
 	KeysType extends keyof ObjectType = keyof ObjectType,
+> =
+	IfNotAnyOrNever<ObjectType,
+		If<IsNever<KeysType>,
+			never,
+			_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
+		>>;
+
+type _RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType,
 > = {
 	// For each `Key` in `KeysType` make a mapped type:
 	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
 	// 2. Make all other keys in `KeysType` optional
-	Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+		Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
 }[KeysType] &
 // 3. Add the remaining keys not in `KeysType`
 Except<ObjectType, KeysType>;

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

@@ -1,3 +1,8 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
 /**
 Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
 
@@ -28,6 +33,13 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 @category Object
 */
 export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType,
+		If<IsNever<KeysType>,
+			never,
+			_RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
+		>>;
+
+type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
 	{[Key in KeysType]: (
 		Required<Pick<ObjectType, Key>> &
 		Partial<Record<Exclude<KeysType, Key>, never>>

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

@@ -1,5 +1,8 @@
-import type {RequireExactlyOne} from './require-exactly-one';
-import type {RequireNone} from './internal';
+import type {RequireExactlyOne} from './require-exactly-one.d.ts';
+import type {IfNotAnyOrNever, RequireNone} from './internal/index.d.ts';
+import type {If} from './if.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Create a type that requires exactly one of the given keys and disallows more, or none of the given keys. The remaining keys are kept as is.
@@ -31,7 +34,14 @@ const responder3: Responder = {
 
 @category Object
 */
-export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = (
+export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType,
+		If<IsNever<KeysType>,
+			ObjectType,
+			_RequireOneOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
+		>>;
+
+type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireExactlyOne<ObjectType, KeysType>
 	| RequireNone<KeysType>
 ) & Omit<ObjectType, KeysType>; // Ignore unspecified keys.

package/source/required-deep.d.ts

@@ -1,6 +1,4 @@
-import type {BuiltIns, HasMultipleCallSignatures} from './internal';
-
-type ExcludeUndefined<T> = Exclude<T, undefined>;
+import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
 
 /**
 Create a type from another type with all keys and nested keys set to required.
@@ -15,23 +13,23 @@ import type {RequiredDeep} from 'type-fest';
 
 type Settings = {
 	textEditor?: {
-		fontSize?: number | undefined;
-		fontColor?: string | undefined;
+		fontSize?: number;
+		fontColor?: string;
 		fontWeight?: number | undefined;
-	}
-	autocomplete?: boolean | undefined;
+	};
+	autocomplete?: boolean;
 	autosave?: boolean | undefined;
 };
 
 type RequiredSettings = RequiredDeep<Settings>;
-// type RequiredSettings = {
+//=> {
 // 	textEditor: {
 // 		fontSize: number;
 // 		fontColor: string;
-// 		fontWeight: number;
-// 	}
+// 		fontWeight: number | undefined;
+// 	};
 // 	autocomplete: boolean;
-// 	autosave: boolean;
+// 	autosave: boolean | undefined;
 // }
 ```
 
@@ -43,34 +41,30 @@ Note that types containing overloaded functions are not made deeply required due
 @category Set
 @category Map
 */
-export type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns
-	? E
-	: E extends Map<infer KeyType, infer ValueType>
+export type RequiredDeep<T> = T extends BuiltIns
+	? T
+	: T extends Map<infer KeyType, infer ValueType>
 		? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
-		: E extends Set<infer ItemType>
+		: T extends Set<infer ItemType>
 			? Set<RequiredDeep<ItemType>>
-			: E extends ReadonlyMap<infer KeyType, infer ValueType>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
 				? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
-				: E extends ReadonlySet<infer ItemType>
+				: T extends ReadonlySet<infer ItemType>
 					? ReadonlySet<RequiredDeep<ItemType>>
-					: E extends WeakMap<infer KeyType, infer ValueType>
+					: T extends WeakMap<infer KeyType, infer ValueType>
 						? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
-						: E extends WeakSet<infer ItemType>
+						: T extends WeakSet<infer ItemType>
 							? WeakSet<RequiredDeep<ItemType>>
-							: E extends Promise<infer ValueType>
+							: T extends Promise<infer ValueType>
 								? Promise<RequiredDeep<ValueType>>
-								: E extends (...arguments_: any[]) => unknown
-									? {} extends RequiredObjectDeep<E>
-										? E
-										: HasMultipleCallSignatures<E> extends true
-											? E
-											: ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
-									: E extends object
-										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-											? ItemType[] extends E // Test for arrays (non-tuples) specifically
-												? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
-												: RequiredObjectDeep<E> // Tuples behave properly
-											: RequiredObjectDeep<E>
+								: T extends (...arguments_: any[]) => unknown
+									? {} extends RequiredObjectDeep<T>
+										? T
+										: HasMultipleCallSignatures<T> extends true
+											? T
+											: ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T>
+									: T extends object
+										? RequiredObjectDeep<T>
 										: unknown;
 
 type RequiredObjectDeep<ObjectType extends object> = {

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

@@ -1,4 +1,4 @@
-import type {OptionalKeysOf} from './optional-keys-of';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 
 /**
 Extract all required keys from the given type.
@@ -24,7 +24,7 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-export type RequiredKeysOf<BaseType extends object> =
-	BaseType extends unknown // For distributing `BaseType`
-		? Exclude<keyof BaseType, OptionalKeysOf<BaseType>>
+export type RequiredKeysOf<Type extends object> =
+	Type extends unknown // For distributing `Type`
+		? Exclude<keyof Type, OptionalKeysOf<Type>>
 		: never; // Should never happen