type-fest 5.0.1 → 5.1.0

package/source/fixed-length-array.d.ts

@@ -1,43 +1,89 @@
+import type {Except} from './except.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
+
 /**
 Methods to exclude.
 */
 type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift';
 
 /**
-Create a type that represents an array of the given type and length. The array's length and the `Array` prototype methods that manipulate its length are excluded in the resulting type.
+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.
+
+The problem with the built-in tuple type is that it allows mutating methods like `push`, `pop` etc, which can cause issues, like in the following example:
+
+@example
+```
+const color: [number, number, number] = [255, 128, 64];
+
+function toHex([r, g, b]: readonly [number, number, number]) {
+	return `#${r.toString(16)}${g.toString(16)}${b.toString(16)}`;
+}
+
+color.pop(); // Allowed
+
+console.log(toHex(color)); // Compiles fine, but fails at runtime since index `2` no longer contains a `number`.
+```
+
+`ArrayLengthMutationKeys` solves this problem by excluding methods like `push`, `pop` etc from the resulting type.
+
+@example
+```
+import type {FixedLengthArray} from 'type-fest';
+
+const color: FixedLengthArray<number, 3> = [255, 128, 64];
 
-Please participate in [this issue](https://github.com/microsoft/TypeScript/issues/26223) if you want to have a similar type built into TypeScript.
+color.pop();
+//=> Error: Property 'pop' does not exist on type 'FixedLengthArray<number, 3>'.
+```
 
 Use-cases:
 - Declaring fixed-length tuples or arrays with a large number of items.
-- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types.
 - Creating an array of coordinates with a static length, for example, length of 3 for a 3D vector.
 
-Note: This type does not prevent out-of-bounds access. Prefer `ReadonlyTuple` unless you need mutability.
-
 @example
 ```
-import type {FixedLengthArray} from 'type-fest';
+let color: FixedLengthArray<number, 3> = [255, 128, 64];
 
-type FencingTeam = FixedLengthArray<string, 3>;
+const red = color[0];
+//=> number
+const green = color[1];
+//=> number
+const blue = color[2];
+//=> number
 
-const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
+const alpha = color[3];
+//=> Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
 
-const homeFencingTeam: FencingTeam = ['George', 'John'];
-//=> error TS2322: Type string[] is not assignable to type 'FencingTeam'
+// You can write to valid indices.
+color[0] = 128;
+color[1] = 64;
+color[2] = 32;
 
-guestFencingTeam.push('Sam');
-//=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
+// But you cannot write to out-of-bounds indices.
+color[3] = 0.5;
+//=> Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
+
+color.push(0.5);
+//=> Error: Property 'push' does not exist on type 'FixedLengthArray<number, 3>'.
+
+color = [0, 128, 255, 0.5];
+//=> Error: Type '[number, number, number, number]' is not assignable to type 'FixedLengthArray<number, 3>'. Types of property 'length' are incompatible.
+
+color.length = 4;
+//=> Error: Cannot assign to 'length' because it is a read-only property.
+
+function toHex([r, g, b]: readonly [number, number, number]) {
+	return `#${r.toString(16)}${g.toString(16)}${b.toString(16)}`;
+}
+
+console.log(toHex(color)); // `FixedLengthArray<number, 3>` is assignable to `readonly [number, number, number]`.
 ```
 
 @category Array
-@see ReadonlyTuple
 */
-export type FixedLengthArray<Element, Length extends number, ArrayPrototype = [Element, ...Element[]]> = Pick<
-	ArrayPrototype,
-	Exclude<keyof ArrayPrototype, ArrayLengthMutationKeys>
-> & {
-	[index: number]: Element;
-	[Symbol.iterator]: () => IterableIterator<Element>;
-	readonly length: Length;
-};
+export type FixedLengthArray<Element, Length extends number> =
+	Except<TupleOf<Length, Element>, ArrayLengthMutationKeys | number | 'length'>
+	& {readonly length: Length}
+	& (number extends Length ? {[n: number]: Element} : {}); // Add `number` index signature only for non-tuple arrays.
+
+export {};

package/source/get.d.ts

@@ -1,11 +1,11 @@
 import type {ApplyDefaultOptions, ToString} from './internal/index.d.ts';
-import type {LiteralStringUnion} from './literal-union.d.ts';
+import type {_LiteralStringUnion} from './literal-union.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {Split} from './split.d.ts';
 import type {KeyAsString} from './key-as-string.d.ts';
 import type {DigitCharacter} from './characters.d.ts';
 
-type GetOptions = {
+export type GetOptions = {
 	/**
 	Include `undefined` in the return type when accessing properties.
 
@@ -210,7 +210,7 @@ export type Get<
 	BaseType,
 	Path extends
 	| readonly string[]
-	| LiteralStringUnion<ToString<Paths<BaseType, {bracketNotation: false; maxRecursionDepth: 2}> | Paths<BaseType, {bracketNotation: true; maxRecursionDepth: 2}>>>,
+	| _LiteralStringUnion<ToString<Paths<BaseType, {bracketNotation: false; maxRecursionDepth: 2}> | Paths<BaseType, {bracketNotation: true; maxRecursionDepth: 2}>>>,
 	Options extends GetOptions = {},
 > =
 	GetWithPath<
@@ -218,3 +218,5 @@ export type Get<
 		Path extends string ? ToPath<Path> : Path,
 		ApplyDefaultOptions<GetOptions, DefaultGetOptions, Options>
 	>;
+
+export {};

package/source/global-this.d.ts

@@ -19,3 +19,5 @@ type ExtraGlobals = GlobalThis & {
 @category Type
 */
 export type GlobalThis = typeof globalThis;
+
+export {};

package/source/globals/index.d.ts

@@ -1 +1,3 @@
 export type * from './observable-like.d.ts';
+
+export {};

package/source/globals/observable-like.d.ts

@@ -16,6 +16,7 @@ As well, some guidance on making an `Observable` to not include `closed` propert
 
 @category Observable
 */
+// eslint-disable-next-line type-fest/require-exported-types
 export type Unsubscribable = {
 	unsubscribe(): void;
 };
@@ -38,6 +39,7 @@ type OnComplete = () => void;
 /**
 @category Observable
 */
+// eslint-disable-next-line type-fest/require-exported-types
 export type Observer<ValueType> = {
 	next: OnNext<ValueType>;
 	error: OnError;
@@ -67,7 +69,10 @@ But `Observable` implementations have evolved to preferring case 2 and some impl
 
 @category Observable
 */
+// eslint-disable-next-line type-fest/require-exported-types
 export type ObservableLike<ValueType = unknown> = {
 	subscribe(observer?: Partial<Observer<ValueType>>): Unsubscribable;
 	[Symbol.observable](): ObservableLike<ValueType>;
 };
+
+export {};

package/source/greater-than-or-equal.d.ts

@@ -20,3 +20,5 @@ GreaterThanOrEqual<1, 5>;
 export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
 	? never
 	: A extends B ? true : GreaterThan<A, B>;
+
+export {};

package/source/greater-than.d.ts

@@ -54,3 +54,5 @@ export type GreaterThan<A extends number, B extends number> =
 					: never
 			: never // Should never happen
 		: never; // Should never happen
+
+export {};

package/source/has-optional-keys.d.ts

@@ -19,3 +19,5 @@ type UpdateService<Entity extends object> = {
 @category Utilities
 */
 export type HasOptionalKeys<BaseType extends object> = OptionalKeysOf<BaseType> extends never ? false : true;
+
+export {};

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

@@ -19,3 +19,5 @@ type UpdateService<Entity extends object> = {
 @category Utilities
 */
 export type HasReadonlyKeys<BaseType extends object> = ReadonlyKeysOf<BaseType> extends never ? false : true;
+
+export {};

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

@@ -57,3 +57,5 @@ const optD: Options2 = {
 @category Utilities
 */
 export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+
+export {};

package/source/has-writable-keys.d.ts

@@ -19,3 +19,5 @@ type UpdateService<Entity extends object> = {
 @category Utilities
 */
 export type HasWritableKeys<BaseType extends object> = WritableKeysOf<BaseType> extends never ? false : true;
+
+export {};

package/source/if-any.d.ts

@@ -24,3 +24,5 @@ type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
 export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
 	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
 );
+
+export {};

package/source/if-empty-object.d.ts

@@ -26,3 +26,5 @@ export type IfEmptyObject<
 	TypeIfEmptyObject = true,
 	TypeIfNotEmptyObject = false,
 > = IsEmptyObject<T> extends true ? TypeIfEmptyObject : TypeIfNotEmptyObject;
+
+export {};

package/source/if-never.d.ts

@@ -24,3 +24,5 @@ type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
 export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
 	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
 );
+
+export {};

package/source/if-null.d.ts

@@ -24,3 +24,5 @@ type ShouldBeBar = IfNull<'not null', 'foo', 'bar'>;
 export type IfNull<T, TypeIfNull = true, TypeIfNotNull = false> = (
 	IsNull<T> extends true ? TypeIfNull : TypeIfNotNull
 );
+
+export {};

package/source/if-unknown.d.ts

@@ -24,3 +24,5 @@ type ShouldBeBar = IfUnknown<'not unknown', 'foo', 'bar'>;
 export type IfUnknown<T, TypeIfUnknown = true, TypeIfNotUnknown = false> = (
 	IsUnknown<T> extends true ? TypeIfUnknown : TypeIfNotUnknown
 );
+
+export {};

package/source/if.d.ts

@@ -63,3 +63,5 @@ export type If<Type extends boolean, IfBranch, ElseBranch> =
 		: Type extends true
 			? IfBranch
 			: ElseBranch;
+
+export {};

package/source/includes.d.ts

@@ -20,3 +20,5 @@ export type Includes<Value extends readonly any[], Item> =
 			? true
 			: Includes<rest, Item>
 		: false;
+
+export {};

package/source/int-closed-range.d.ts

@@ -33,3 +33,5 @@ type Hundreds = IntClosedRange<100, 900, 100>;
 @see IntRange
 */
 export type IntClosedRange<Start extends number, End extends number, Skip extends number = 1> = IntRange<Start, Sum<End, 1>, Skip>;
+
+export {};

package/source/int-range.d.ts

@@ -1,4 +1,4 @@
-import type {BuildTuple} from './internal/index.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
 
 /**
@@ -44,14 +44,16 @@ type PrivateIntRange<
 	// The gap between each number, gap = step - 1
 	Gap extends number = Subtract<Step, 1>,
 	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
-	List extends unknown[] = BuildTuple<Start, never>,
-	EndLengthTuple extends unknown[] = BuildTuple<End>,
+	List extends unknown[] = TupleOf<Start, never>,
+	EndLengthTuple extends unknown[] = TupleOf<End>,
 > = Gap extends 0 ?
 	// Handle the case that without `Step`
 	List['length'] extends End // The result of "List[length] === End"
 		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
 		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
 	// Handle the case that with `Step`
-	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...BuildTuple<Gap, never>` maybe make `List` too long.
+	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
 		? Exclude<List[number], never>
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...BuildTuple<Gap, never>]>;
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>]>;
+
+export {};

package/source/internal/array.d.ts

@@ -156,3 +156,5 @@ type _CollapseRestElement<
 				>
 				: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
 		: never; // Should never happen
+
+export {};

package/source/internal/characters.d.ts

@@ -61,3 +61,5 @@ export type AsciiPunctuation =
 	| '|'
 	| '}'
 	| '~';
+
+export {};

package/source/{enforce-optional.d.ts → internal/enforce-optional.d.ts}

@@ -1,4 +1,4 @@
-import type {Simplify} from './simplify.d.ts';
+import type {Simplify} from '../simplify.d.ts';
 
 // Returns `never` if the key is optional otherwise return the key type.
 type RequiredFilter<Type, Key extends keyof Type> = undefined extends Type[Key]
@@ -45,3 +45,5 @@ export type EnforceOptional<ObjectType> = Simplify<{
 } & {
 	[Key in keyof ObjectType as OptionalFilter<ObjectType, Key>]?: Exclude<ObjectType[Key], undefined>
 }>;
+
+export {};

package/source/internal/index.d.ts

@@ -6,3 +6,6 @@ export type * from './object.d.ts';
 export type * from './string.d.ts';
 export type * from './tuple.d.ts';
 export type * from './type.d.ts';
+export type * from './enforce-optional.d.ts';
+
+export {};

package/source/internal/keys.d.ts

@@ -96,3 +96,5 @@ Key extends keyof T
 				? NumberKey
 				: never
 			: never;
+
+export {};

package/source/internal/numeric.d.ts

@@ -146,3 +146,5 @@ export type ReverseSign<N extends number> =
 	`${N}` extends `-${infer P extends number}` ? P
 		// Handle positive numbers
 		: `-${N}` extends `${infer R extends number}` ? R : never;
+
+export {};

package/source/internal/object.d.ts

@@ -263,3 +263,5 @@ export type CollapseLiterals<T> = {} extends T
 	: T extends infer U & {}
 		? U
 		: T;
+
+export {};

package/source/internal/string.d.ts

@@ -1,7 +1,7 @@
+import type {TupleOf} from '../tuple-of.d.ts';
 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.
@@ -171,7 +171,7 @@ PositiveNumericStringGt<'1', '500'>;
 */
 export type PositiveNumericStringGt<A extends string, B extends string> = A extends B
 	? false
-	: [BuildTuple<StringLength<A>, 0>, BuildTuple<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]]
+	: [TupleOf<StringLength<A>, 0>, TupleOf<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]]
 		? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]]
 			? 0 extends Remain['length']
 				? SameLengthPositiveNumericStringGt<A, B>
@@ -198,3 +198,5 @@ type PositiveNumericCharacterGt<A extends string, B extends string> = NumericStr
 			: false
 		: never
 	: never;
+
+export {};

package/source/internal/tuple.d.ts

@@ -30,19 +30,6 @@ export type TupleLength<T extends UnknownArray> =
 			: T['length']
 		: never; // Should never happen
 
-/**
-Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
-
-If `<Fill>` is not provided, it will default to `unknown`.
-
-@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
-*/
-export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = number extends L
-	? Fill[]
-	: L extends T['length']
-		? T
-		: BuildTuple<L, Fill, [...T, Fill]>;
-
 /**
 Returns the maximum value from a tuple of integers.
 
@@ -88,3 +75,5 @@ export type TupleMin<A extends number[], Result extends number = PositiveInfinit
 			? TupleMin<R, F>
 			: TupleMin<R, Result>
 		: Result;
+
+export {};

package/source/internal/type.d.ts

@@ -128,3 +128,5 @@ Indicates the value of `exactOptionalPropertyTypes` compiler option.
 export type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?]
 	? false
 	: true;
+
+export {};

package/source/invariant-of.d.ts

@@ -74,3 +74,5 @@ keyOfInvariantFooBar(invariantOf(fooBarBaz)); // Error: Argument of type 'Invari
 @category Type
 */
 export type InvariantOf<Type> = Type & {[invariantBrand]: (_: Type) => Type};
+
+export {};

package/source/is-any.d.ts

@@ -27,3 +27,5 @@ const anyA = get(anyObject, 'a');
 @category Utilities
 */
 export type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+
+export {};

package/source/is-equal.d.ts

@@ -1,3 +1,4 @@
+import type {IsNever} from './is-never.d.ts';
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -25,7 +26,21 @@ type Includes<Value extends readonly any[], Item> =
 @category Utilities
 */
 export type IsEqual<A, B> =
+	[A, B] extends [infer AA, infer BB]
+		? [AA] extends [never]
+			? [BB] extends [never]
+				? true
+				: false
+			: [BB] extends [never]
+				? false
+				: _IsEqual<AA, BB>
+		: false;
+
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> =
 	(<G>() => G extends A & G | G ? 1 : 2) extends
 	(<G>() => G extends B & G | G ? 1 : 2)
 		? true
 		: false;
+
+export {};

package/source/is-float.d.ts

@@ -39,3 +39,5 @@ export type IsFloat<T> = T extends number
 			? true
 			: false
 	: false;
+
+export {};

package/source/is-integer.d.ts

@@ -56,3 +56,5 @@ T extends bigint
 				? false
 				: Not<IsFloat<T>>
 		: false;
+
+export {};

package/source/is-literal.d.ts

@@ -1,5 +1,5 @@
 import type {Primitive} from './primitive.d.ts';
-import type {Numeric} from './numeric.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';
@@ -173,7 +173,7 @@ endsWith('abc123', end);
 @category Type Guard
 @category Utilities
 */
-export type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
+export type IsNumericLiteral<T> = LiteralChecks<T, _Numeric>;
 
 /**
 Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
@@ -310,3 +310,5 @@ export type IsLiteral<T> =
 	IsPrimitive<T> extends true
 		? IsNotFalse<IsLiteralUnion<T>>
 		: false;
+
+export {};

package/source/is-lowercase.d.ts

@@ -34,3 +34,5 @@ type IsLowercaseHelper<S extends string> = S extends Lowercase<string>
 	: S extends Uppercase<string> | Capitalize<string> | `${string}${Uppercase<string>}${string}`
 		? false
 		: boolean;
+
+export {};

package/source/is-never.d.ts

@@ -40,3 +40,5 @@ endIfEqual('abc', '123');
 @category Utilities
 */
 export type IsNever<T> = [T] extends [never] ? true : false;
+
+export {};

package/source/is-null.d.ts

@@ -18,3 +18,5 @@ type Example2 = NonNullFallback<number, string>;
 @category Utilities
 */
 export type IsNull<T> = [T] extends [null] ? true : false;
+
+export {};

package/source/is-nullable.d.ts

@@ -26,3 +26,5 @@ type D = IsNullable<string | null | undefined>;
 @category Utilities
 */
 export type IsNullable<T> = IsAny<T> extends true ? true : Extract<T, null> extends never ? false : true;
+
+export {};

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

@@ -47,3 +47,5 @@ export type IsOptionalKeyOf<Type extends object, Key extends keyof Type> =
 				? false
 				: true
 			: false;
+
+export {};

package/source/is-optional.d.ts

@@ -24,3 +24,5 @@ type D = IsOptional<string | null | undefined>;
 @category Utilities
 */
 export type IsOptional<T> = IsAny<T> extends true ? true : Extract<T, undefined> extends never ? false : true;
+
+export {};

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

@@ -51,3 +51,5 @@ export type IsReadonlyKeyOf<Type extends object, Key extends keyof Type> =
 				>
 				: never // Should never happen
 			: never; // Should never happen
+
+export {};

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

@@ -47,3 +47,5 @@ export type IsRequiredKeyOf<Type extends object, Key extends keyof Type> =
 		: Key extends keyof Type
 			? Not<IsOptionalKeyOf<Type, Key>>
 			: false;
+
+export {};

package/source/is-tuple.d.ts

@@ -88,3 +88,5 @@ type _IsTuple<
 				: true
 			: false
 	>>;
+
+export {};

package/source/is-undefined.d.ts

@@ -18,3 +18,5 @@ type Example2 = UndefinedFallback<number, string>;
 @category Utilities
 */
 export type IsUndefined<T> = [T] extends [undefined] ? true : false;
+
+export {};

package/source/is-union.d.ts

@@ -35,3 +35,5 @@ type InternalIsUnion<T, U = T> =
 	? boolean extends Result ? true
 		: Result
 	: never; // Should never happen
+
+export {};

package/source/is-unknown.d.ts

@@ -50,3 +50,5 @@ export type IsUnknown<T> = (
 			: false
 		: false
 );
+
+export {};

package/source/is-uppercase.d.ts

@@ -34,3 +34,5 @@ type IsUppercaseHelper<S extends string> = S extends Uppercase<string>
 	: S extends Lowercase<string> | Uncapitalize<string> | `${string}${Lowercase<string>}${string}`
 		? false
 		: boolean;
+
+export {};

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

@@ -47,3 +47,5 @@ export type IsWritableKeyOf<Type extends object, Key extends keyof Type> =
 		: Key extends keyof Type
 			? Not<IsReadonlyKeyOf<Type, Key>>
 			: false;
+
+export {};

package/source/iterable-element.d.ts

@@ -62,3 +62,5 @@ export type IterableElement<TargetIterable> =
 		TargetIterable extends AsyncIterable<infer ElementType> ?
 			ElementType :
 			never;
+
+export {};

package/source/join.d.ts

@@ -66,3 +66,5 @@ export type Join<
 			]
 				? `${Join<Head, Delimiter>}${Delimiter}${NullishCoalesce<Last, ''>}`
 				: string;
+
+export {};

package/source/json-value.d.ts

@@ -5,7 +5,7 @@ This type can be useful to enforce some input to be JSON-compatible or as a supe
 
 @category JSON
 */
-export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
+export type JsonObject = {[Key in string]: JsonValue};
 
 /**
 Matches a JSON array.
@@ -29,3 +29,5 @@ Matches any valid JSON value.
 @category JSON
 */
 export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+
+export {};

package/source/jsonifiable.d.ts

@@ -35,3 +35,5 @@ JSON.stringify(good);
 @category JSON
 */
 export type Jsonifiable = JsonPrimitive | JsonifiableObject | JsonifiableArray;
+
+export {};

package/source/jsonify.d.ts

@@ -124,3 +124,5 @@ export type Jsonify<T> = IsAny<T> extends true
 												: IsUnknown<T> extends true
 													? JsonValue
 													: never; // Otherwise any other non-object is removed
+
+export {};