type-fest 4.40.1 → 5.0.0

package/source/internal/keys.d.ts

@@ -1,6 +1,7 @@
-import type {IsAny} from '../is-any';
-import type {IsLiteral} from '../is-literal';
-import type {ToString} from './string';
+import type {IsAny} from '../is-any.d.ts';
+import type {IsLiteral} from '../is-literal.d.ts';
+import type {IsUnknown} from '../is-unknown.d.ts';
+import type {ToString} from './string.d.ts';
 
 // Returns `never` if the key or property is not jsonable without testing whether the property is required or optional otherwise return the key.
 type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
@@ -22,32 +23,32 @@ type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
 Returns the required keys.
 */
 export type FilterDefinedKeys<T extends object> = Exclude<
-{
-	[Key in keyof T]: IsAny<T[Key]> extends true
-		? Key
-		: undefined extends T[Key]
-			? never
-			: T[Key] extends undefined
+	{
+		[Key in keyof T]: IsAny<T[Key]> extends true
+			? Key
+			: IsUnknown<T[Key]> extends true ? Key : undefined extends T[Key]
 				? never
-				: BaseKeyFilter<T, Key>;
-}[keyof T],
-undefined
+				: T[Key] extends undefined
+					? never
+					: BaseKeyFilter<T, Key>;
+	}[keyof T],
+	undefined
 >;
 
 /**
 Returns the optional keys.
 */
 export type FilterOptionalKeys<T extends object> = Exclude<
-{
-	[Key in keyof T]: IsAny<T[Key]> extends true
-		? never
-		: undefined extends T[Key]
-			? T[Key] extends undefined
-				? never
-				: BaseKeyFilter<T, Key>
-			: never;
-}[keyof T],
-undefined
+	{
+		[Key in keyof T]: IsAny<T[Key]> extends true
+			? never
+			: undefined extends T[Key]
+				? T[Key] extends undefined
+					? never
+					: BaseKeyFilter<T, Key>
+				: never;
+	}[keyof T],
+	undefined
 >;
 
 /**
@@ -63,7 +64,7 @@ export type LiteralKeyOf<T> = keyof {[K in keyof T as IsLiteral<K> extends true
 /**
 Get the exact version of the given `Key` in the given object `T`.
 
-Use-case: You known that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
+Use-case: You know that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
 
 @example
 ```

package/source/internal/numeric.d.ts

@@ -1,7 +1,8 @@
-import type {IsNever} from '../is-never';
-import type {NegativeInfinity, PositiveInfinity} from '../numeric';
-import type {UnknownArray} from '../unknown-array';
-import type {StringToNumber} from './string';
+import type {IsNever} from '../is-never.d.ts';
+import type {Finite, NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
+import type {StringToNumber} from './string.d.ts';
+import type {IsAnyOrNever} from './type.d.ts';
 
 /**
 Returns the absolute value of a given value.
@@ -33,19 +34,20 @@ type A = IsNumberLike<'1'>;
 type B = IsNumberLike<'-1.1'>;
 //=> true
 
-type C = IsNumberLike<1>;
+type C = IsNumberLike<'5e-20'>;
 //=> true
 
-type D = IsNumberLike<'a'>;
+type D = IsNumberLike<1>;
+//=> true
+
+type E = IsNumberLike<'a'>;
 //=> false
 */
 export type IsNumberLike<N> =
-	N extends number ? true
-		:	N extends `${number}`
+	IsAnyOrNever<N> extends true ? N
+		: N extends number | `${number}`
 			? true
-			: N extends `${number}.${number}`
-				? true
-				: false;
+			: false;
 
 /**
 Returns the minimum number in the given union of numbers.
@@ -54,11 +56,25 @@ Note: Just supports numbers from 0 to 999.
 
 @example
 ```
-type A = UnionMin<3 | 1 | 2>;
+type A = UnionMin<1 | 3 | 2>;
 //=> 1
+
+type B = UnionMin<number>;
+//=> number
+
+type C = UnionMin<any>;
+//=> any
+
+type D = UnionMin<never>;
+//=> never
 ```
 */
-export type UnionMin<N extends number> = InternalUnionMin<N>;
+export type UnionMin<N extends number> =
+	IsAnyOrNever<N> extends true ? N
+		: number extends N ? number
+			: NegativeInfinity extends N ? NegativeInfinity
+				: [N] extends [PositiveInfinity] ? PositiveInfinity
+					: InternalUnionMin<Finite<N>>;
 
 /**
 The actual implementation of `UnionMin`. It's private because it has some arguments that don't need to be exposed.
@@ -77,9 +93,23 @@ Note: Just supports numbers from 0 to 999.
 ```
 type A = UnionMax<1 | 3 | 2>;
 //=> 3
+
+type B = UnionMax<number>;
+//=> number
+
+type C = UnionMax<any>;
+//=> any
+
+type D = UnionMax<never>;
+//=> never
 ```
 */
-export type UnionMax<N extends number> = InternalUnionMax<N>;
+export type UnionMax<N extends number> =
+	IsAnyOrNever<N> extends true ? N
+		: number extends N ? number
+			: PositiveInfinity extends N ? PositiveInfinity
+				: [N] extends [NegativeInfinity] ? NegativeInfinity
+					: InternalUnionMax<Finite<N>>;
 
 /**
 The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
@@ -87,7 +117,7 @@ The actual implementation of `UnionMax`. It's private because it has some argume
 type InternalUnionMax<N extends number, T extends UnknownArray = []> =
 	IsNever<N> extends true
 		? T['length']
-		:	T['length'] extends N
+		: T['length'] extends N
 			? InternalUnionMax<Exclude<N, T['length']>, T>
 			: InternalUnionMax<N, [...T, unknown]>;
 

package/source/internal/object.d.ts

@@ -1,15 +1,16 @@
-import type {Simplify} from '../simplify';
-import type {UnknownArray} from '../unknown-array';
-import type {IsEqual} from '../is-equal';
-import type {KeysOfUnion} from '../keys-of-union';
-import type {RequiredKeysOf} from '../required-keys-of';
-import type {Merge} from '../merge';
-import type {IfAny} from '../if-any';
-import type {IfNever} from '../if-never';
-import type {OptionalKeysOf} from '../optional-keys-of';
-import type {FilterDefinedKeys, FilterOptionalKeys} from './keys';
-import type {NonRecursiveType} from './type';
-import type {ToString} from './string';
+import type {Simplify} from '../simplify.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
+import type {IsEqual} from '../is-equal.d.ts';
+import type {KeysOfUnion} from '../keys-of-union.d.ts';
+import type {RequiredKeysOf} from '../required-keys-of.d.ts';
+import type {Merge} from '../merge.d.ts';
+import type {OptionalKeysOf} from '../optional-keys-of.d.ts';
+import type {IsAny} from '../is-any.d.ts';
+import type {If} from '../if.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';
+import type {NonRecursiveType} from './type.d.ts';
+import type {ToString} from './string.d.ts';
 
 /**
 Create an object type with the given key `<Key>` and value `<Value>`.
@@ -79,13 +80,13 @@ type OptionalizedUser = UndefinedToOptional<User>;
 ```
 */
 export type UndefinedToOptional<T extends object> = Simplify<
-{
+	{
 	// Property is not a union with `undefined`, keep it as-is.
-	[Key in keyof Pick<T, FilterDefinedKeys<T>>]: T[Key];
-} & {
+		[Key in keyof Pick<T, FilterDefinedKeys<T>>]: T[Key];
+	} & {
 	// Property _is_ a union with defined value. Set as optional (via `?`) and remove `undefined` from the union.
-	[Key in keyof Pick<T, FilterOptionalKeys<T>>]?: Exclude<T[Key], undefined>;
-}
+		[Key in keyof Pick<T, FilterOptionalKeys<T>>]?: Exclude<T[Key], undefined>;
+	}
 >;
 
 /**
@@ -222,15 +223,43 @@ export type ApplyDefaultOptions<
 	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
 	SpecifiedOptions extends Options,
 > =
-	IfAny<SpecifiedOptions, Defaults,
-	IfNever<SpecifiedOptions, Defaults,
-	Simplify<Merge<Defaults, {
-		[Key in keyof SpecifiedOptions
-		as Key extends OptionalKeysOf<Options>
-			? Extract<SpecifiedOptions[Key], undefined> extends never
-				? Key
-				: never
-			: Key
-		]: SpecifiedOptions[Key]
-	}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-	>>;
+	If<IsAny<SpecifiedOptions>, Defaults,
+		If<IsNever<SpecifiedOptions>, Defaults,
+			Simplify<Merge<Defaults, {
+				[Key in keyof SpecifiedOptions
+				as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key
+				]: SpecifiedOptions[Key]
+			}> & Required<Options>>>>; // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+
+/**
+Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
+
+Note: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `("foo" & Tag<"Tag", never>) | (string & Tag<"Tag", never>)` and not `string & Tag<"Tag", never>`.
+
+Use-case: For collapsing unions created using {@link LiteralUnion}.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+type A = CollapseLiterals<'foo' | 'bar' | (string & {})>;
+//=> string
+
+type B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;
+//=> number
+
+type C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;
+//=> `on${string}`
+
+type D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;
+//=> 'click' | 'change' | `on${string}`
+
+type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
+//=> string | null | undefined
+```
+*/
+export type CollapseLiterals<T> = {} extends T
+	? T
+	: T extends infer U & {}
+		? U
+		: T;

package/source/internal/string.d.ts

@@ -1,7 +1,7 @@
-import type {NegativeInfinity, PositiveInfinity} from '../numeric';
-import type {Trim} from '../trim';
-import type {Whitespace} from './characters';
-import type {BuildTuple} from './tuple';
+import type {NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
+import type {Trim} from '../trim.d.ts';
+import type {Whitespace} from './characters.d.ts';
+import type {BuildTuple} from './tuple.d.ts';
 
 /**
 Return a string representation of the given string or number.
@@ -112,16 +112,6 @@ export type StringLength<S extends string> = string extends S
 	? never
 	: StringToArray<S>['length'];
 
-/**
-Returns a boolean for whether the string is lowercased.
-*/
-export type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
-
-/**
-Returns a boolean for whether the string is uppercased.
-*/
-export type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
-
 /**
 Returns a boolean for whether a string is whitespace.
 */

package/source/internal/tuple.d.ts

@@ -1,7 +1,7 @@
-import type {GreaterThan} from '../greater-than';
-import type {LessThan} from '../less-than';
-import type {NegativeInfinity, PositiveInfinity} from '../numeric';
-import type {UnknownArray} from '../unknown-array';
+import type {GreaterThan} from '../greater-than.d.ts';
+import type {LessThan} from '../less-than.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
 
 /**
 Infer the length of the given tuple `<T>`.

package/source/internal/type.d.ts

@@ -1,5 +1,7 @@
-import type {IsNever} from '../is-never';
-import type {Primitive} from '../primitive';
+import type {If} from '../if.d.ts';
+import type {IsAny} from '../is-any.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {Primitive} from '../primitive.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -78,36 +80,51 @@ export type Not<A extends boolean> = A extends true
 		: never;
 
 /**
-Returns a boolean for whether the given type is a union type.
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
 @example
 ```
-type A = IsUnion<string | number>;
-//=> true
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
+
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
+
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
+*/
+export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
+	If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
 
-type B = IsUnion<string>;
+/**
+Returns a boolean for whether the given type is `any` or `never`.
+
+This type can be better to use than {@link IfNotAnyOrNever `IfNotAnyOrNever`} in recursive types because it does not evaluate any branches.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `false`
+type A = IsAnyOrNever<string>;
 //=> false
+
+// When `T` is `any` => Returns `true`
+type B = IsAnyOrNever<any>;
+//=> true
+
+// When `T` is `never` => Returns `true`
+type C = IsAnyOrNever<never>;
+//=> true
 ```
 */
-export type IsUnion<T> = InternalIsUnion<T>;
+export type IsAnyOrNever<T> = IsNotFalse<IsAny<T> | IsNever<T>>;
 
 /**
-The actual implementation of `IsUnion`.
+Indicates the value of `exactOptionalPropertyTypes` compiler option.
 */
-type InternalIsUnion<T, U = T> =
-(
-	// @link https://ghaiklor.github.io/type-challenges-solutions/en/medium-isunion.html
-	IsNever<T> extends true
-		? false
-		: T extends any
-			? [U] extends [T]
-				? false
-				: true
-			: never
-) extends infer Result
-	// In some cases `Result` will return `false | true` which is `boolean`,
-	// that means `T` has at least two types and it's a union type,
-	// so we will return `true` instead of `boolean`.
-	? boolean extends Result ? true
-		: Result
-	: never; // Should never happen
+export type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?]
+	? false
+	: true;

package/source/is-any.d.ts

@@ -1,7 +1,3 @@
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
-
 /**
 Returns a boolean for whether the given type is `any`.
 

package/source/is-float.d.ts

@@ -1,5 +1,3 @@
-import type {Zero} from './numeric';
-
 /**
 Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
 
@@ -8,7 +6,7 @@ Use-case:
 
 @example
 ```
-import type {IsFloat, PositiveInfinity} from "type-fest";
+import type {IsFloat, PositiveInfinity} from 'type-fest';
 
 type A = IsFloat<1.5>;
 //=> true

package/source/is-integer.d.ts

@@ -1,6 +1,6 @@
-import type {Not} from './internal';
-import type {IsFloat} from './is-float';
-import type {PositiveInfinity, NegativeInfinity} from './numeric';
+import type {Not} from './internal/index.d.ts';
+import type {IsFloat} from './is-float.d.ts';
+import type {PositiveInfinity, NegativeInfinity} from './numeric.d.ts';
 
 /**
 Returns a boolean for whether the given number is an integer, like `-5`, `1.0`, or `100`.
@@ -10,7 +10,7 @@ Use-case:
 
 @example
 ```
-import type {IsInteger, PositiveInfinity} from "type-fest";
+import type {IsInteger, PositiveInfinity} from 'type-fest';
 
 type A = IsInteger<1>;
 //=> true

package/source/is-literal.d.ts

@@ -1,8 +1,8 @@
-import type {Primitive} from './primitive';
-import type {Numeric} from './numeric';
-import type {IsNotFalse, IsPrimitive} from './internal';
-import type {IsNever} from './is-never';
-import type {IfNever} from './if-never';
+import type {Primitive} from './primitive.d.ts';
+import type {Numeric} from './numeric.d.ts';
+import type {CollapseLiterals, IfNotAnyOrNever, IsNotFalse, IsPrimitive} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {TagContainer, UnwrapTagged} from './tagged.d.ts';
 
 /**
 Returns a boolean for whether the given type `T` is the specified `LiteralType`.
@@ -114,14 +114,18 @@ type L2 = Length<`${number}`>;
 @category Type Guard
 @category Utilities
 */
-export type IsStringLiteral<T> = IfNever<T, false,
+export type IsStringLiteral<S> = IfNotAnyOrNever<S,
+	_IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>,
+	false, false>;
+
+export type _IsStringLiteral<S> =
 // If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
 // and since `{}` extends index signatures, the result becomes `false`.
-T extends string
-	? {} extends Record<T, never>
+S extends string
+	? {} extends Record<S, never>
 		? false
 		: true
-	: false>;
+	: false;
 
 /**
 Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
@@ -134,7 +138,7 @@ Useful for:
 ```
 import type {IsNumericLiteral} from 'type-fest';
 
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
+// https://github.com/inocan-group/inferred-types/blob/master/modules/types/src/boolean-logic/operators/EndsWith.ts
 type EndsWith<TValue, TEndsWith extends string> =
 	TValue extends string
 		? IsStringLiteral<TEndsWith> extends true
@@ -264,27 +268,39 @@ Useful for:
 ```
 import type {IsLiteral} from 'type-fest';
 
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/string-literals/StripLeading.ts
-export type StripLeading<A, B> =
-	A extends string
-		? B extends string
-			? IsLiteral<A> extends true
-				? string extends B ? never : A extends `${B & string}${infer After}` ? After : A
-				: string
-			: A
-		: A;
-
-function stripLeading<Input extends string, Strip extends string>(input: Input, strip: Strip) {
-	return input.replace(`^${strip}`, '') as StripLeading<Input, Strip>;
-}
+type A = IsLiteral<1>;
+//=> true
 
-stripLeading('abc123', 'abc');
-//=> '123'
+type B = IsLiteral<number>;
+//=> false
 
-const str = 'abc123' as string;
+type C = IsLiteral<1n>;
+//=> true
 
-stripLeading(str, 'abc');
-//=> string
+type D = IsLiteral<bigint>;
+//=> false
+
+type E = IsLiteral<'type-fest'>;
+//=> true
+
+type F = IsLiteral<string>;
+//=> false
+
+type G = IsLiteral<`on${string}`>;
+//=> false
+
+declare const symbolLiteral: unique symbol;
+type H = IsLiteral<typeof symbolLiteral>;
+//=> true
+
+type I = IsLiteral<symbol>;
+//=> false
+
+type J = IsLiteral<true>;
+//=> true
+
+type K = IsLiteral<boolean>;
+//=> false
 ```
 
 @category Type Guard

package/source/is-lowercase.d.ts

@@ -0,0 +1,36 @@
+import type {AllExtend} from './all-extend.d.ts';
+
+/**
+Returns a boolean for whether the given string literal is lowercase.
+
+@example
+```
+import type {IsLowercase} from 'type-fest';
+
+IsLowercase<'abc'>;
+//=> true
+
+IsLowercase<'Abc'>;
+//=> false
+
+IsLowercase<string>;
+//=> boolean
+```
+*/
+export type IsLowercase<S extends string> = AllExtend<_IsLowercase<S>, true>;
+
+/**
+Loops through each part in the string and returns a boolean array indicating whether each part is lowercase.
+*/
+type _IsLowercase<S extends string, Accumulator extends boolean[] = []> = S extends `${infer First}${infer Rest}`
+	? _IsLowercase<Rest, [...Accumulator, IsLowercaseHelper<First>]>
+	: [...Accumulator, IsLowercaseHelper<S>];
+
+/**
+Returns a boolean for whether an individual part of the string is lowercase.
+*/
+type IsLowercaseHelper<S extends string> = S extends Lowercase<string>
+	? true
+	: S extends Uppercase<string> | Capitalize<string> | `${string}${Uppercase<string>}${string}`
+		? false
+		: boolean;

package/source/is-nullable.d.ts

@@ -0,0 +1,28 @@
+import type {IsAny} from './is-any.d.ts';
+
+/**
+Returns a boolean for whether the given type includes `null`.
+
+Note: The built-in `NonNullable` type removes both `null` and `undefined`, which is not accurate for the name.
+
+@example
+```ts
+import type {IsNullable} from 'type-fest';
+
+type A = IsNullable<string>;
+//=> false
+
+type B = IsNullable<string | null>;
+//=> true
+
+type C = IsNullable<string | undefined>;
+//=> false
+
+type D = IsNullable<string | null | undefined>;
+//=> true
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNullable<T> = IsAny<T> extends true ? true : Extract<T, null> extends never ? false : true;

package/source/is-optional-key-of.d.ts

@@ -0,0 +1,49 @@
+import type {IsAny} from './is-any.d.ts';
+
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+interface Admin {
+	name: string;
+	surname?: string;
+}
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsOptionalKeyOf<Type extends object, Key extends keyof Type> =
+	IsAny<Type | Key> extends true ? never
+		: Key extends keyof Type
+			? Type extends Record<Key, Type[Key]>
+				? false
+				: true
+			: false;