@visulima/object 1.0.9 → 1.0.11

package/dist/index.d.cts

@@ -1,2464 +1,7 @@
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;
-
-declare global {
-	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-	interface SymbolConstructor {
-		readonly observable: symbol;
-	}
-}
-
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
-```
-
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
-@category Type
-*/
-type UnionToIntersection<Union> = (
-	// `extends unknown` is always going to be the case and is used to convert the
-	// `Union` into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	Union extends unknown
-		// The union type is used as the only argument to a function since the union
-		// of function arguments is an intersection.
-		? (distributedUnion: Union) => void
-		// This won't happen.
-		: never
-		// Infer the `Intersection` type since TypeScript represents the positional
-		// arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void)
-	// The `& Union` is to allow indexing by the resulting type
-	? Intersection & Union
-	: never;
-
-declare const emptyObjectSymbol: unique symbol;
-
-/**
-Represents a strictly empty plain object, the `{}` value.
-
-When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
-
-@example
-```
-import type {EmptyObject} from 'type-fest';
-
-// The following illustrates the problem with `{}`.
-const foo1: {} = {}; // Pass
-const foo2: {} = []; // Pass
-const foo3: {} = 42; // Pass
-const foo4: {} = {a: 1}; // Pass
-
-// With `EmptyObject` only the first case is valid.
-const bar1: EmptyObject = {}; // Pass
-const bar2: EmptyObject = 42; // Fail
-const bar3: EmptyObject = []; // Fail
-const bar4: EmptyObject = {a: 1}; // Fail
-```
-
-Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
-
-@category Object
-*/
-type EmptyObject = {[emptyObjectSymbol]?: never};
-
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsEqual<A, B> =
-	(<G>() => G extends A & G | G ? 1 : 2) extends
-	(<G>() => G extends B & G | G ? 1 : 2)
-		? true
-		: false;
-
-/**
-Represents an array with `unknown` value.
-
-Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
-
-@example
-```
-import type {UnknownArray} from 'type-fest';
-
-type IsArray<T> = T extends UnknownArray ? true : false;
-
-type A = IsArray<['foo']>;
-//=> true
-
-type B = IsArray<readonly number[]>;
-//=> true
-
-type C = IsArray<string>;
-//=> false
-```
-
-@category Type
-@category Array
-*/
-type UnknownArray = readonly unknown[];
-
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
-@category Object
-*/
-type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
-
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-
-/**
-An if-else-like type that resolves depending on whether the given type is `never`.
-
-@see {@link IsNever}
-
-@example
-```
-import type {IfNever} from 'type-fest';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
-
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
-	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
-);
-
-/**
-Returns the static, fixed-length portion of the given array, excluding variable-length parts.
-
-@example
-```
-type A = [string, number, boolean, ...string[]];
-type B = StaticPartOfArray<A>;
-//=> [string, number, boolean]
-```
-*/
-type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> =
-	T extends unknown
-		? number extends T['length'] ?
-			T extends readonly [infer U, ...infer V]
-				? StaticPartOfArray<V, [...Result, U]>
-				: Result
-			: T
-		: never; // Should never happen
-
-/**
-Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
-
-@example
-```
-type A = [string, number, boolean, ...string[]];
-type B = VariablePartOfArray<A>;
-//=> string[]
-```
-*/
-type VariablePartOfArray<T extends UnknownArray> =
-	T extends unknown
-		? T extends readonly [...StaticPartOfArray<T>, ...infer U]
-			? U
-			: []
-		: never; // Should never happen
-
-/**
-Set the given array to readonly if `IsReadonly` is `true`, otherwise set the given array to normal, then return the result.
-
-@example
-```
-type ReadonlyArray = readonly string[];
-type NormalArray = string[];
-
-type ReadonlyResult = SetArrayAccess<NormalArray, true>;
-//=> readonly string[]
-
-type NormalResult = SetArrayAccess<ReadonlyArray, false>;
-//=> string[]
-```
-*/
-type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
-T extends readonly [...infer U] ?
-	IsReadonly extends true
-		? readonly [...U]
-		: [...U]
-	: T;
-
-/**
-Returns whether the given array `T` is readonly.
-*/
-type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unknown[] ? false : true>;
-
-type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
-
-// 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`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-
-type Numeric = number | bigint;
-
-type Zero = 0 | 0n;
-
-/**
-Matches the hidden `Infinity` type.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
-
-@see NegativeInfinity
-
-@category Numeric
-*/
-// See https://github.com/microsoft/TypeScript/issues/31752
-// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-type PositiveInfinity = 1e999;
-
-/**
-Matches the hidden `-Infinity` type.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
-
-@see PositiveInfinity
-
-@category Numeric
-*/
-// See https://github.com/microsoft/TypeScript/issues/31752
-// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-type NegativeInfinity = -1e999;
-
-/**
-A negative `number`/`bigint` (`-∞ < x < 0`)
-
-Use-case: Validating and documenting parameters.
-
-@see NegativeInteger
-@see NonNegative
-
-@category Numeric
-*/
-type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
-
-/**
-Returns a boolean for whether the given number is a negative number.
-
-@see Negative
-
-@example
-```
-import type {IsNegative} from 'type-fest';
-
-type ShouldBeFalse = IsNegative<1>;
-type ShouldBeTrue = IsNegative<-1>;
-```
-
-@category Numeric
-*/
-type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
-
-/**
-Returns a boolean for whether two given types are both true.
-
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
-
-@example
-```
-import type {And} from 'type-fest';
-
-And<true, true>;
-//=> true
-
-And<true, false>;
-//=> false
-```
-
-@see {@link Or}
-*/
-type And<A extends boolean, B extends boolean> = [A, B][number] extends true
-	? true
-	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
-		? false
-		: never;
-
-/**
-Returns a boolean for whether either of two given types are true.
-
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
-
-@example
-```
-import type {Or} from 'type-fest';
-
-Or<true, false>;
-//=> true
-
-Or<false, false>;
-//=> false
-```
-
-@see {@link And}
-*/
-type Or<A extends boolean, B extends boolean> = [A, B][number] extends false
-	? false
-	: true extends [IsEqual<A, true>, IsEqual<B, true>][number]
-		? true
-		: never;
-
-/**
-Returns a boolean for whether a given number is greater than another number.
-
-@example
-```
-import type {GreaterThan} from 'type-fest';
-
-GreaterThan<1, -5>;
-//=> true
-
-GreaterThan<1, 1>;
-//=> false
-
-GreaterThan<1, 5>;
-//=> false
-```
-*/
-type GreaterThan<A extends number, B extends number> = number extends A | B
-	? never
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-		And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-		> extends true
-			? true
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-			> extends true
-				? false
-				: true extends R[number]
-					? false
-					: [IsNegative<A>, IsNegative<B>] extends infer R extends [boolean, boolean]
-						? [true, false] extends R
-							? false
-							: [false, true] extends R
-								? true
-								: [false, false] extends R
-									? PositiveNumericStringGt<`${A}`, `${B}`>
-									: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
-						: never
-		: never;
-
-/**
-Returns a boolean for whether a given number is greater than or equal to another number.
-
-@example
-```
-import type {GreaterThanOrEqual} from 'type-fest';
-
-GreaterThanOrEqual<1, -5>;
-//=> true
-
-GreaterThanOrEqual<1, 1>;
-//=> true
-
-GreaterThanOrEqual<1, 5>;
-//=> false
-```
-*/
-type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
-	: A extends B ? true : GreaterThan<A, B>;
-
-/**
-Returns a boolean for whether a given number is less than another number.
-
-@example
-```
-import type {LessThan} from 'type-fest';
-
-LessThan<1, -5>;
-//=> false
-
-LessThan<1, 1>;
-//=> false
-
-LessThan<1, 5>;
-//=> true
-```
-*/
-type LessThan<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThanOrEqual<A, B> extends true ? false : true;
-
-/**
-Infer the length of the given tuple `<T>`.
-
-Returns `never` if the given type is an non-fixed-length array like `Array<string>`.
-
-@example
-```
-type Tuple = TupleLength<[string, number, boolean]>;
-//=> 3
-
-type Array = TupleLength<string[]>;
-//=> never
-
-// Supports union types.
-type Union = TupleLength<[] | [1, 2, 3] | Array<number>>;
-//=> 1 | 3
-```
-*/
-type TupleLength<T extends UnknownArray> =
-	// `extends unknown` is used to convert `T` (if `T` is a union type) to
-	// a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types))
-	T extends unknown
-		? number extends T['length']
-			? never // Return never if the given type is an non-flexed-length array like `Array<string>`
-			: 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
-*/
-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.
-
-Note:
-- Float numbers are not supported.
-
-@example
-```
-ArrayMax<[1, 2, 5, 3]>;
-//=> 5
-
-ArrayMax<[1, 2, 5, 3, 99, -1]>;
-//=> 99
-```
-*/
-type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number]
-	? never :
-	A extends [infer F extends number, ...infer R extends number[]]
-		? GreaterThan<F, Result> extends true
-			? TupleMax<R, F>
-			: TupleMax<R, Result>
-		: Result;
-
-/**
-Returns the minimum value from a tuple of integers.
-
-Note:
-- Float numbers are not supported.
-
-@example
-```
-ArrayMin<[1, 2, 5, 3]>;
-//=> 1
-
-ArrayMin<[1, 2, 5, 3, -5]>;
-//=> -5
-```
-*/
-type TupleMin<A extends number[], Result extends number = PositiveInfinity> = number extends A[number]
-	? never
-	: A extends [infer F extends number, ...infer R extends number[]]
-		? LessThan<F, Result> extends true
-			? TupleMin<R, F>
-			: TupleMin<R, Result>
-		: Result;
-
-/**
-Return a string representation of the given string or number.
-
-Note: This type is not the return type of the `.toString()` function.
-*/
-type ToString<T> = T extends string | number ? `${T}` : never;
-
-/**
-Converts a numeric string to a number.
-
-@example
-```
-type PositiveInt = StringToNumber<'1234'>;
-//=> 1234
-
-type NegativeInt = StringToNumber<'-1234'>;
-//=> -1234
-
-type PositiveFloat = StringToNumber<'1234.56'>;
-//=> 1234.56
-
-type NegativeFloat = StringToNumber<'-1234.56'>;
-//=> -1234.56
-
-type PositiveInfinity = StringToNumber<'Infinity'>;
-//=> Infinity
-
-type NegativeInfinity = StringToNumber<'-Infinity'>;
-//=> -Infinity
-```
-
-@category String
-@category Numeric
-@category Template literal
-*/
-type StringToNumber<S extends string> = S extends `${infer N extends number}`
-	? N
-	: S extends 'Infinity'
-		? PositiveInfinity
-		: S extends '-Infinity'
-			? NegativeInfinity
-			: never;
-
-/**
-Returns an array of the characters of the string.
-
-@example
-```
-StringToArray<'abcde'>;
-//=> ['a', 'b', 'c', 'd', 'e']
-
-StringToArray<string>;
-//=> never
-```
-
-@category String
-*/
-type StringToArray<S extends string, Result extends string[] = []> = string extends S
-	? never
-	: S extends `${infer F}${infer R}`
-		? StringToArray<R, [...Result, F]>
-		: Result;
-
-/**
-Returns the length of the given string.
-
-@example
-```
-StringLength<'abcde'>;
-//=> 5
-
-StringLength<string>;
-//=> never
-```
-
-@category String
-@category Template literal
-*/
-type StringLength<S extends string> = string extends S
-	? never
-	: StringToArray<S>['length'];
-
-/**
-Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both numeric strings and have the same length.
-
-@example
-```
-SameLengthPositiveNumericStringGt<'50', '10'>;
-//=> true
-
-SameLengthPositiveNumericStringGt<'10', '10'>;
-//=> false
-```
-*/
-type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}`
-	? B extends `${infer FirstB}${infer RestB}`
-		? FirstA extends FirstB
-			? SameLengthPositiveNumericStringGt<RestA, RestB>
-			: PositiveNumericCharacterGt<FirstA, FirstB>
-		: never
-	: false;
-
-type NumericString = '0123456789';
-
-/**
-Returns a boolean for whether `A` is greater than `B`, where `A` and `B` are both positive numeric strings.
-
-@example
-```
-PositiveNumericStringGt<'500', '1'>;
-//=> true
-
-PositiveNumericStringGt<'1', '1'>;
-//=> false
-
-PositiveNumericStringGt<'1', '500'>;
-//=> false
-```
-*/
-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[]]
-		? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]]
-			? 0 extends Remain['length']
-				? SameLengthPositiveNumericStringGt<A, B>
-				: true
-			: false
-		: never;
-
-/**
-Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both positive numeric characters.
-
-@example
-```
-PositiveNumericCharacterGt<'5', '1'>;
-//=> true
-
-PositiveNumericCharacterGt<'1', '1'>;
-//=> false
-```
-*/
-type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}`
-	? NumericString extends `${infer HeadB}${B}${infer TailB}`
-		? HeadA extends `${HeadB}${infer _}${infer __}`
-			? true
-			: false
-		: never
-	: never;
-
-/**
-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.
-
-@example
-```
-type Object = {
-	0: number;
-	'1': string;
-};
-
-type Key1 = ExactKey<Object, '0'>;
-//=> 0
-type Key2 = ExactKey<Object, 0>;
-//=> 0
-
-type Key3 = ExactKey<Object, '1'>;
-//=> '1'
-type Key4 = ExactKey<Object, 1>;
-//=> '1'
-```
-
-@category Object
-*/
-type ExactKey<T extends object, Key extends PropertyKey> =
-Key extends keyof T
-	? Key
-	: ToString<Key> extends keyof T
-		? ToString<Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof T
-				? NumberKey
-				: never
-			: never;
-
-/**
-Returns the absolute value of a given value.
-
-@example
-```
-NumberAbsolute<-1>;
-//=> 1
-
-NumberAbsolute<1>;
-//=> 1
-
-NumberAbsolute<NegativeInfinity>
-//=> PositiveInfinity
-```
-*/
-type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
-
-/**
-Check whether the given type is a number or a number string.
-
-Supports floating-point as a string.
-
-@example
-```
-type A = IsNumberLike<'1'>;
-//=> true
-
-type B = IsNumberLike<'-1.1'>;
-//=> true
-
-type C = IsNumberLike<1>;
-//=> true
-
-type D = IsNumberLike<'a'>;
-//=> false
-*/
-type IsNumberLike<N> =
-	N extends number ? true
-		:	N extends `${number}`
-			? true
-			: N extends `${number}.${number}`
-				? true
-				: false;
-
-/**
-Returns the minimum number in the given union of numbers.
-
-Note: Just supports numbers from 0 to 999.
-
-@example
-```
-type A = UnionMin<3 | 1 | 2>;
-//=> 1
-```
-*/
-type UnionMin<N extends number> = InternalUnionMin<N>;
-
-/**
-The actual implementation of `UnionMin`. It's private because it has some arguments that don't need to be exposed.
-*/
-type InternalUnionMin<N extends number, T extends UnknownArray = []> =
-	T['length'] extends N
-		? T['length']
-		: InternalUnionMin<N, [...T, unknown]>;
-
-/**
-Returns the maximum number in the given union of numbers.
-
-Note: Just supports numbers from 0 to 999.
-
-@example
-```
-type A = UnionMax<1 | 3 | 2>;
-//=> 3
-```
-*/
-type UnionMax<N extends number> = InternalUnionMax<N>;
-
-/**
-The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
-*/
-type InternalUnionMax<N extends number, T extends UnknownArray = []> =
-	IsNever<N> extends true
-		? T['length']
-		:	T['length'] extends N
-			? InternalUnionMax<Exclude<N, T['length']>, T>
-			: InternalUnionMax<N, [...T, unknown]>;
-
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-
-/**
-Matches non-recursive types.
-*/
-type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-
-/**
-Create an object type with the given key `<Key>` and value `<Value>`.
-
-It will copy the prefix and optional status of the same key from the given object `CopiedFrom` into the result.
-
-@example
-```
-type A = BuildObject<'a', string>;
-//=> {a: string}
-
-// Copy `readonly` and `?` from the key `a` of `{readonly a?: any}`
-type B = BuildObject<'a', string, {readonly a?: any}>;
-//=> {readonly a?: string}
-```
-*/
-type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends object = {}> =
-	Key extends keyof CopiedFrom
-		? Pick<{[_ in keyof CopiedFrom]: Value}, Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof CopiedFrom
-				? Pick<{[_ in keyof CopiedFrom]: Value}, NumberKey>
-				: {[_ in Key]: Value}
-			: {[_ in Key]: Value};
-
-/**
-Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
-
-It creates a type-safe way to access the member type of `unknown` type.
-*/
-type ObjectValue<T, K> =
-	K extends keyof T
-		? T[K]
-		: ToString<K> extends keyof T
-			? T[ToString<K>]
-			: K extends `${infer NumberK extends number}`
-				? NumberK extends keyof T
-					? T[NumberK]
-					: never
-				: never;
-
-/**
-Deeply simplifies an object type.
-
-You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.
-
-Useful to flatten the type output to improve type hints shown in editors.
-
-@example
-```
-import type {SimplifyDeep} from 'type-fest';
-
-type PositionX = {
-	left: number;
-	right: number;
-};
-
-type PositionY = {
-	top: number;
-	bottom: number;
-};
-
-type Properties1 = {
-	height: number;
-	position: PositionY;
-};
-
-type Properties2 = {
-	width: number;
-	position: PositionX;
-};
-
-type Properties = Properties1 & Properties2;
-// In your editor, hovering over `Props` will show the following:
-//
-// type Properties = Properties1 & Properties2;
-
-type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
-// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
-//
-// SimplifyDeepProperties = {
-// 	height: number;
-// 	width: number;
-// 	position: {
-// 		top: number;
-// 		bottom: number;
-// 		left: number;
-// 		right: number;
-// 	};
-// };
-```
-
-@example
-```
-import type {SimplifyDeep} from 'type-fest';
-
-// A complex type that you don't want or need to simplify
-type ComplexType = {
-	a: string;
-	b: 'b';
-	c: number;
-	...
-};
-
-type PositionX = {
-	left: number;
-	right: number;
-};
-
-type PositionY = {
-	top: number;
-	bottom: number;
-};
-
-// You want to simplify all other types
-type Properties1 = {
-	height: number;
-	position: PositionY;
-	foo: ComplexType;
-};
-
-type Properties2 = {
-	width: number;
-	position: PositionX;
-	foo: ComplexType;
-};
-
-type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
-// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
-// show a flattened object with all the properties except `ComplexType`:
-//
-// SimplifyDeepProperties = {
-// 	height: number;
-// 	width: number;
-// 	position: {
-// 		top: number;
-// 		bottom: number;
-// 		left: number;
-// 		right: number;
-// 	};
-//	foo: ComplexType;
-// };
-```
-
-@see Simplify
-@category Object
-*/
-type SimplifyDeep<Type, ExcludeType = never> =
-	ConditionalSimplifyDeep<
-	Type,
-	ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>,
-	object
-	>;
-
-/**
-Returns the sum of two numbers.
-
-Note:
-- A or B can only support `-999` ~ `999`.
-- A and B can only be small integers, less than 1000.
-- If the result is negative, you can only get `number`.
-
-@example
-```
-import type {Sum} from 'type-fest';
-
-Sum<111, 222>;
-//=> 333
-
-Sum<-111, 222>;
-//=> 111
-
-Sum<111, -222>;
-//=> number
-
-Sum<PositiveInfinity, -9999>;
-//=> PositiveInfinity
-
-Sum<PositiveInfinity, NegativeInfinity>;
-//=> number
-```
-
-@category Numeric
-*/
-// TODO: Support big integer and negative number.
-type Sum<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[3], false>>,
-		And<IsEqual<R[2], true>, IsEqual<R[1], false>>
-		> extends true
-			? PositiveInfinity
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[2], false>>,
-			And<IsEqual<R[3], true>, IsEqual<R[0], false>>
-			> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: ([IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? [...BuildTuple<A>, ...BuildTuple<B>]['length']
-							: [true, true] extends R
-								? number
-								: TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_
-									? TupleMin<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Min_ extends number
-										? Max_ extends A | B
-											? Subtract<Max_, Min_>
-											: number
-										: never
-									: never
-						: never) & number
-		: never;
-
-/**
-Returns the difference between two numbers.
-
-Note:
-- A or B can only support `-999` ~ `999`.
-- If the result is negative, you can only get `number`.
-
-@example
-```
-import type {Subtract} from 'type-fest';
-
-Subtract<333, 222>;
-//=> 111
-
-Subtract<111, -222>;
-//=> 333
-
-Subtract<-111, 222>;
-//=> number
-
-Subtract<PositiveInfinity, 9999>;
-//=> PositiveInfinity
-
-Subtract<PositiveInfinity, PositiveInfinity>;
-//=> number
-```
-
-@category Numeric
-*/
-// TODO: Support big integer and negative number.
-type Subtract<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-		And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-		> extends true
-			? PositiveInfinity
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-			> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: [IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? BuildTuple<A> extends infer R
-								? R extends [...BuildTuple<B>, ...infer R]
-									? R['length']
-									: number
-								: never
-							: LessThan<A, B> extends true
-								? number
-								: [false, true] extends R
-									? Sum<A, NumberAbsolute<B>>
-									: Subtract<NumberAbsolute<B>, NumberAbsolute<A>>
-						: never
-		: never;
-
-/**
-Paths options.
-
-@see {@link Paths}
-*/
-type PathsOptions = {
-	/**
-	The maximum depth to recurse when searching for paths.
-
-	@default 10
-	*/
-	maxRecursionDepth?: number;
-
-	/**
-	Use bracket notation for array indices and numeric object keys.
-
-	@default false
-
-	@example
-	```
-	type ArrayExample = {
-		array: ['foo'];
-	};
-
-	type A = Paths<ArrayExample, {bracketNotation: false}>;
-	//=> 'array' | 'array.0'
-
-	type B = Paths<ArrayExample, {bracketNotation: true}>;
-	//=> 'array' | 'array[0]'
-	```
-
-	@example
-	```
-	type NumberKeyExample = {
-		1: ['foo'];
-	};
-
-	type A = Paths<NumberKeyExample, {bracketNotation: false}>;
-	//=> 1 | '1' | '1.0'
-
-	type B = Paths<NumberKeyExample, {bracketNotation: true}>;
-	//=> '[1]' | '[1][0]'
-	```
-	*/
-	bracketNotation?: boolean;
-};
-
-type DefaultPathsOptions = {
-	maxRecursionDepth: 10;
-	bracketNotation: false;
-};
-
-/**
-Generate a union of all possible paths to properties in the given object.
-
-It also works with arrays.
-
-Use-case: You want a type-safe way to access deeply nested properties in an object.
-
-@example
-```
-import type {Paths} from 'type-fest';
-
-type Project = {
-	filename: string;
-	listA: string[];
-	listB: [{filename: string}];
-	folder: {
-		subfolder: {
-			filename: string;
-		};
-	};
-};
-
-type ProjectPaths = Paths<Project>;
-//=> 'filename' | 'listA' | 'listB' | 'folder' | `listA.${number}` | 'listB.0' | 'listB.0.filename' | 'folder.subfolder' | 'folder.subfolder.filename'
-
-declare function open<Path extends ProjectPaths>(path: Path): void;
-
-open('filename'); // Pass
-open('folder.subfolder'); // Pass
-open('folder.subfolder.filename'); // Pass
-open('foo'); // TypeError
-
-// Also works with arrays
-open('listA.1'); // Pass
-open('listB.0'); // Pass
-open('listB.1'); // TypeError. Because listB only has one element.
-```
-
-@category Object
-@category Array
-*/
-type Paths<T, Options extends PathsOptions = {}> = _Paths<T, {
-	// Set default maxRecursionDepth to 10
-	maxRecursionDepth: Options['maxRecursionDepth'] extends number ? Options['maxRecursionDepth'] : DefaultPathsOptions['maxRecursionDepth'];
-	// Set default bracketNotation to false
-	bracketNotation: Options['bracketNotation'] extends boolean ? Options['bracketNotation'] : DefaultPathsOptions['bracketNotation'];
-}>;
-
-type _Paths<T, Options extends Required<PathsOptions>> =
-	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
-		? never
-		: IsAny<T> extends true
-			? never
-			: 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<T, Options>
-				: T extends object
-					? InternalPaths<T, Options>
-					: never;
-
-type InternalPaths<T, Options extends Required<PathsOptions>> =
-	Options['maxRecursionDepth'] extends infer MaxDepth extends number
-		? Required<T> extends infer T
-			? T extends EmptyObject | 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
-							| TranformedKey
-							| (
-								// 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>}> extends infer SubPath
-										? SubPath extends string | number
-											? (
-												Options['bracketNotation'] extends true
-													? SubPath extends `[${any}]` | `[${any}]${string}`
-														? `${TranformedKey}${SubPath}` // If next node is number key like `[3]`, no need to add `.` before it.
-														: `${TranformedKey}.${SubPath}`
-													: never
-											) | (
-												Options['bracketNotation'] extends false
-													? `${TranformedKey}.${SubPath}`
-													: never
-											)
-											: never
-										: never
-									: never
-							)
-							: never
-						: never
-				}[keyof T & (T extends UnknownArray ? number : unknown)]
-			: never
-		: never;
-
-/**
-Pick properties from a deeply-nested object.
-
-It supports recursing into arrays.
-
-Use-case: Distill complex objects down to the components you need to target.
-
-@example
-```
-import type {PickDeep, PartialDeep} from 'type-fest';
-
-type Configuration = {
-	userConfig: {
-		name: string;
-		age: number;
-		address: [
-			{
-				city1: string;
-				street1: string;
-			},
-			{
-				city2: string;
-				street2: string;
-			}
-		]
-	};
-	otherConfig: any;
-};
-
-type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
-// type NameConfig = {
-// 	userConfig: {
-// 		name: string;
-// 	}
-// };
-
-// Supports optional properties
-type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig.age'>;
-// type User = {
-// 	userConfig?: {
-// 		name?: string;
-// 		age?: number;
-// 	};
-// };
-
-// Supports array
-type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
-// type AddressConfig = {
-// 	userConfig: {
-// 		address: [{
-// 			city1: string;
-// 			street1: string;
-// 		}];
-// 	};
-// }
-
-// Supports recurse into array
-type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
-// type Street = {
-// 	userConfig: {
-// 		address: [
-// 			unknown,
-// 			{street2: string}
-// 		];
-// 	};
-// }
-```
-
-@category Object
-@category Array
-*/
-type PickDeep<T, PathUnion extends Paths<T>> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray
-			? UnionToIntersection<{
-				[P in PathUnion]: InternalPickDeep<T, P>;
-			}[PathUnion]
-			>
-			: T extends object
-				? Simplify<UnionToIntersection<{
-					[P in PathUnion]: InternalPickDeep<T, P>;
-				}[PathUnion]>>
-				: never;
-
-/**
-Pick an object/array from the given object/array by one path.
-*/
-type InternalPickDeep<T, Path extends string | number> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray ? PickDeepArray<T, Path>
-			: T extends object ? Simplify<PickDeepObject<T, Path>>
-				: never;
-
-/**
-Pick an object from the given object by one path.
-*/
-type PickDeepObject<RecordType extends object, P extends string | number> =
-	P extends `${infer RecordKeyInPath}.${infer SubPath}`
-		? ObjectValue<RecordType, RecordKeyInPath> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<ObjectV>, SubPath>, RecordType>
-				: never
-			: never
-		: ObjectValue<RecordType, P> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<P, ObjectV, RecordType>
-				: never
-			: never;
-
-/**
-Pick an array from the given array by one path.
-*/
-type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
-	// Handle paths that are `${number}.${string}`
-	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
-		// When `ArrayIndex` is equal to `number`
-		? number extends ArrayIndex
-			? ArrayType extends unknown[]
-				? Array<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-				: ArrayType extends readonly unknown[]
-					? ReadonlyArray<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-					: never
-			// When `ArrayIndex` is a number literal
-			: ArrayType extends unknown[]
-				? [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-				: ArrayType extends readonly unknown[]
-					? readonly [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-					: never
-		// When the path is equal to `number`
-		: P extends `${infer ArrayIndex extends number}`
-			// When `ArrayIndex` is `number`
-			? number extends ArrayIndex
-				? ArrayType
-				// When `ArrayIndex` is a number literal
-				: ArrayType extends unknown[]
-					? [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
-					: ArrayType extends readonly unknown[]
-						? readonly [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
-						: never
-			: never;
-
-/**
-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 [...infer U, ...V]
-			? [U, V]
-			: [never, never]
-		: [never, never];
-
-/**
-The implementation of `SplitArrayByIndex` for variable length arrays.
-*/
-type SplitVariableArrayByIndex<T extends UnknownArray,
-	SplitIndex extends number,
-	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
-	T2 = T1 extends number ? BuildTuple<T1, VariablePartOfArray<T>[number]> : [],
-> =
-SplitIndex extends 0
-	? [[], T]
-	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
-		? [
-			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
-			[
-				...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
-				...VariablePartOfArray<T>,
-			],
-		]
-		: [
-			[
-				...StaticPartOfArray<T>,
-				...(T2 extends UnknownArray ? T2 : []),
-			],
-			VariablePartOfArray<T>,
-		];
-
-/**
-Split the given array `T` by the given `SplitIndex`.
-
-@example
-```
-type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
-// type A = [[1, 2], [3, 4]];
-
-type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
-// type B = [[], [1, 2, 3, 4]];
-```
-*/
-type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-	SplitIndex extends 0
-		? [[], T]
-		: number extends T['length']
-			? SplitVariableArrayByIndex<T, SplitIndex>
-			: SplitFixedArrayByIndex<T, SplitIndex>;
-
-/**
-Creates 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.
-
-Like [`Array#splice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) but for types.
-
-@example
-```
-type SomeMonths0 = ['January', 'April', 'June'];
-type Mouths0 = ArraySplice<SomeMonths0, 1, 0, ['Feb', 'March']>;
-//=> type Mouths0 = ['January', 'Feb', 'March', 'April', 'June'];
-
-type SomeMonths1 = ['January', 'April', 'June'];
-type Mouths1 = ArraySplice<SomeMonths1, 1, 1>;
-//=> type Mouths1 = ['January', 'June'];
-
-type SomeMonths2 = ['January', 'Foo', 'April'];
-type Mouths2 = ArraySplice<SomeMonths2, 1, 1, ['Feb', 'March']>;
-//=> type Mouths2 = ['January', 'Feb', 'March', 'April'];
-```
-
-@category Array
-*/
-type ArraySplice<
-	T extends UnknownArray,
-	Start extends number,
-	DeleteCount extends number,
-	Items extends UnknownArray = [],
-> =
-	SplitArrayByIndex<T, Start> extends [infer U extends UnknownArray, infer V extends UnknownArray]
-		? SplitArrayByIndex<V, DeleteCount> extends [infer _Deleted extends UnknownArray, infer X extends UnknownArray]
-			? [...U, ...Items, ...X]
-			: never // Should never happen
-		: never; // Should never happen
-
-type LiteralStringUnion<T> = LiteralUnion<T, string>;
-
-/**
-Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
-
-Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
-
-This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
-
-@example
-```
-import type {LiteralUnion} from 'type-fest';
-
-// Before
-
-type Pet = 'dog' | 'cat' | string;
-
-const pet: Pet = '';
-// Start typing in your TypeScript-enabled IDE.
-// You **will not** get auto-completion for `dog` and `cat` literals.
-
-// After
-
-type Pet2 = LiteralUnion<'dog' | 'cat', string>;
-
-const pet: Pet2 = '';
-// You **will** get auto-completion for `dog` and `cat` literals.
-```
-
-@category Type
-*/
-type LiteralUnion<
-	LiteralType,
-	BaseType extends Primitive,
-> = LiteralType | (BaseType & Record<never, never>);
-
-/**
-SharedUnionFieldsDeep options.
-
-@see {@link SharedUnionFieldsDeep}
-*/
-type SharedUnionFieldsDeepOptions = {
-	/**
-	When set to true, this option impacts each element within arrays or tuples. If all union values are arrays or tuples, it constructs an array of the shortest possible length, ensuring every element exists in the union array.
-
-	@default false
- 	*/
-	recurseIntoArrays?: boolean;
-};
-
-/**
-Create a type with shared fields from a union of object types, deeply traversing nested structures.
-
-Use the {@link SharedUnionFieldsDeepOptions `Options`} to specify the behavior for arrays.
-
-Use-cases:
-- You want a safe object type where each key exists in the union object.
-- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
-
-@example
-```
-import type {SharedUnionFieldsDeep} from 'type-fest';
-
-type Cat = {
-	info: {
-		name: string;
-		type: 'cat';
-		catType: string;
-	};
-};
-
-type Dog = {
-	info: {
-		name: string;
-		type: 'dog';
-		dogType: string;
-	};
-};
-
-function displayPetInfo(petInfo: (Cat | Dog)['info']) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat';
-	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
-	// } | {
-	// 	name: string;
-	// 	type: 'dog';
-	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
-	// }
-
-	// petInfo type is complex and have some needless fields
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-}
-
-function displayPetInfo(petInfo: SharedUnionFieldsDeep<Cat | Dog>['info']) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat' | 'dog';
-	// }
-
-	// petInfo type is simple and clear
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-}
-```
-
-@see SharedUnionFields
-
-@category Object
-@category Union
-*/
-type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOptions = {recurseIntoArrays: false}> =
-	// `Union extends` will convert `Union`
-	// to a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	// But this is not what we want, so we need to wrap `Union` with `[]` to prevent it.
-	[Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>]
-		? Union
-		: [Union] extends [UnknownArray]
-			? Options['recurseIntoArrays'] extends true
-				? SetArrayAccess<SharedArrayUnionFieldsDeep<Union, Options>, IsArrayReadonly<Union>>
-				: Union
-			: [Union] extends [object]
-				? SharedObjectUnionFieldsDeep<Union, Options>
-				: Union;
-
-/**
-Same as `SharedUnionFieldsDeep`, but accepts only `object`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
-*/
-type SharedObjectUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOptions> =
-	// `keyof Union` can extract the same key in union type, if there is no same key, return never.
-	keyof Union extends infer Keys
-		? IsNever<Keys> extends false
-			? {
-				[Key in keyof Union]:
-				Union[Key] extends NonRecursiveType
-					? Union[Key]
-					// Remove `undefined` from the union to support optional
-					// fields, then recover `undefined` if union was already undefined.
-					: SharedUnionFieldsDeep<Exclude<Union[Key], undefined>, Options> | (
-						undefined extends Required<Union>[Key] ? undefined : never
-					)
-			}
-			: {}
-		: Union;
-
-/**
-Same as `SharedUnionFieldsDeep`, but accepts only `UnknownArray`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
-*/
-type SharedArrayUnionFieldsDeep<Union extends UnknownArray, Options extends SharedUnionFieldsDeepOptions> =
-	// Restore the readonly modifier of the array.
-	SetArrayAccess<
-	InternalSharedArrayUnionFieldsDeep<Union, Options>,
-	IsArrayReadonly<Union>
-	>;
-
-/**
-Internal helper for `SharedArrayUnionFieldsDeep`. Needn't care the `readonly` modifier of arrays.
-*/
-type InternalSharedArrayUnionFieldsDeep<
-	Union extends UnknownArray,
-	Options extends SharedUnionFieldsDeepOptions,
-	ResultTuple extends UnknownArray = [],
-> =
-	// We should build a minimum possible length tuple where each element in the tuple exists in the union tuple.
-	IsNever<TupleLength<Union>> extends true
-		// Rule 1: If all the arrays in the union have non-fixed lengths,
-		// like `Array<string> | [number, ...string[]]`
-		// we should build a tuple that is [the_fixed_parts_of_union, ...the_rest_of_union[]].
-		// For example: `InternalSharedArrayUnionFieldsDeep<Array<string> | [number, ...string[]]>`
-		// => `[string | number, ...string[]]`.
-		? ResultTuple['length'] extends UnionMax<StaticPartOfArray<Union>['length']>
-			? [
-				// The fixed-length part of the tuple.
-				...ResultTuple,
-				// The rest of the union.
-				// Due to `ResultTuple` is the maximum possible fixed-length part of the tuple,
-				// so we can use `StaticPartOfArray` to get the rest of the union.
-				...Array<
-				SharedUnionFieldsDeep<VariablePartOfArray<Union>[number], Options>
-				>,
-			]
-			// Build the fixed-length tuple recursively.
-			: InternalSharedArrayUnionFieldsDeep<
-			Union, Options,
-			[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
-			>
-		// Rule 2: If at least one of the arrays in the union have fixed lengths,
-		// like `Array<string> | [number, string]`,
-		// we should build a tuple of the smallest possible length to ensure any
-		// item in the result tuple exists in the union tuple.
-		// For example: `InternalSharedArrayUnionFieldsDeep<Array<string> | [number, string]>`
-		// => `[string | number, string]`.
-		: ResultTuple['length'] extends UnionMin<TupleLength<Union>>
-			? ResultTuple
-			// As above, build tuple recursively.
-			: InternalSharedArrayUnionFieldsDeep<
-			Union, Options,
-			[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
-			>;
-
-/**
-Omit properties from a deeply-nested object.
-
-It supports recursing into arrays.
-
-It supports removing specific items from an array, replacing each removed item with unknown at the specified index.
-
-Use-case: Remove unneeded parts of complex objects.
-
-Use [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
-
-@example
-```
-import type {OmitDeep} from 'type-fest';
-
-type Info = {
-	userInfo: {
-		name: string;
-		uselessInfo: {
-			foo: string;
-		};
-	};
-};
-
-type UsefulInfo = OmitDeep<Info, 'userInfo.uselessInfo'>;
-// type UsefulInfo = {
-// 	userInfo: {
-// 		name: string;
-// 	};
-// };
-
-// Supports removing multiple paths
-type Info1 = {
-	userInfo: {
-		name: string;
-		uselessField: string;
-		uselessInfo: {
-			foo: string;
-		};
-	};
-};
-
-type UsefulInfo1 = OmitDeep<Info1, 'userInfo.uselessInfo' | 'userInfo.uselessField'>;
-// type UsefulInfo1 = {
-// 	userInfo: {
-// 		name: string;
-// 	};
-// };
-
-// Supports array
-type A = OmitDeep<[1, 'foo', 2], 1>;
-// type A = [1, unknown, 2];
-
-// Supports recursing into array
-
-type Info1 = {
-	address: [
-		{
-			street: string
-		},
-		{
-			street2: string,
-			foo: string
-		};
-	];
-}
-type AddressInfo = OmitDeep<Info1, 'address.1.foo'>;
-// type AddressInfo = {
-// 	address: [
-// 		{
-// 			street: string;
-// 		},
-// 		{
-// 			street2: string;
-// 		};
-// 	];
-// };
-```
-
-@category Object
-@category Array
-*/
-type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> =
-	SimplifyDeep<
-	SharedUnionFieldsDeep<
-	{[P in PathUnion]: OmitDeepWithOnePath<T, P>}[PathUnion]
-	>,
-	UnknownArray>;
-
-/**
-Omit one path from the given object/array.
-*/
-type OmitDeepWithOnePath<T, Path extends string | number> =
-T extends NonRecursiveType
-	? T
-	: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
-		: T extends object ? OmitDeepObjectWithOnePath<T, Path>
-			: T;
-
-/**
-Omit one path from the given object.
-*/
-type OmitDeepObjectWithOnePath<ObjectT extends object, P extends string | number> =
-P extends `${infer RecordKeyInPath}.${infer SubPath}`
-	? {
-		[Key in keyof ObjectT]:
-		IsEqual<RecordKeyInPath, ToString<Key>> extends true
-			? ExactKey<ObjectT, Key> extends infer RealKey
-				? RealKey extends keyof ObjectT
-					? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
-					: ObjectT[Key]
-				: ObjectT[Key]
-			: ObjectT[Key]
-	}
-	: ExactKey<ObjectT, P> extends infer Key
-		? IsNever<Key> extends true
-			? ObjectT
-			: Key extends PropertyKey
-				? Omit<ObjectT, Key>
-				: ObjectT
-		: ObjectT;
-
-/**
-Omit one path from from the given array.
-
-It replaces the item to `unknown` at the given index.
-
-@example
-```
-type A = OmitDeepArrayWithOnePath<[10, 20, 30, 40], 2>;
-//=> type A = [10, 20, unknown, 40];
-```
-*/
-type OmitDeepArrayWithOnePath<ArrayType extends UnknownArray, P extends string | number> =
-	// Handle paths that are `${number}.${string}`
-	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
-		// If `ArrayIndex` is equal to `number`
-		? number extends ArrayIndex
-			? Array<OmitDeepWithOnePath<NonNullable<ArrayType[number]>, SubPath>>
-			// If `ArrayIndex` is a number literal
-			: ArraySplice<ArrayType, ArrayIndex, 1, [OmitDeepWithOnePath<NonNullable<ArrayType[ArrayIndex]>, SubPath>]>
-		// If the path is equal to `number`
-		: P extends `${infer ArrayIndex extends number}`
-			// If `ArrayIndex` is `number`
-			? number extends ArrayIndex
-				? []
-				// If `ArrayIndex` is a number literal
-				: ArraySplice<ArrayType, ArrayIndex, 1, [unknown]>
-			: ArrayType;
-
-/**
-Get keys of the given type as strings.
-
-Number keys are converted to strings.
-
-Use-cases:
-- Get string keys from a type which may have number keys.
-- Makes it possible to index using strings retrieved from template types.
-
-@example
-```
-import type {StringKeyOf} from 'type-fest';
-
-type Foo = {
-	1: number,
-	stringKey: string,
-};
-
-type StringKeysOfFoo = StringKeyOf<Foo>;
-//=> '1' | 'stringKey'
-```
-
-@category Object
-*/
-type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;
-
-/**
-Represents an array of strings split using a given character or character set.
-
-Use-case: Defining the return type of a method like `String.prototype.split`.
-
-@example
-```
-import type {Split} from 'type-fest';
-
-declare function split<S extends string, D extends string>(string: S, separator: D): Split<S, D>;
-
-type Item = 'foo' | 'bar' | 'baz' | 'waldo';
-const items = 'foo,bar,baz,waldo';
-let array: Item[];
-
-array = split(items, ',');
-```
-
-@category String
-@category Template literal
-*/
-type Split<
-	S extends string,
-	Delimiter extends string,
-> = SplitHelper<S, Delimiter>;
-
-type SplitHelper<
-	S extends string,
-	Delimiter extends string,
-	Accumulator extends string[] = [],
-> = S extends `${infer Head}${Delimiter}${infer Tail}`
-	? SplitHelper<Tail, Delimiter, [...Accumulator, Head]>
-	: Delimiter extends ''
-		? Accumulator
-		: [...Accumulator, S];
-
-type GetOptions = {
-	/**
-	Include `undefined` in the return type when accessing properties.
-
-	Setting this to `false` is not recommended.
-
-	@default true
-	*/
-	strict?: boolean;
-};
-
-/**
-Like the `Get` type but receives an array of strings as a path parameter.
-*/
-type GetWithPath<BaseType, Keys, Options extends GetOptions = {}> =
-	Keys extends readonly []
-		? BaseType
-		: Keys extends readonly [infer Head, ...infer Tail]
-			? GetWithPath<
-			PropertyOf<BaseType, Extract<Head, string>, Options>,
-			Extract<Tail, string[]>,
-			Options
-			>
-			: never;
-
-/**
-Adds `undefined` to `Type` if `strict` is enabled.
-*/
-type Strictify<Type, Options extends GetOptions> =
-	Options['strict'] extends false ? Type : (Type | undefined);
-
-/**
-If `Options['strict']` is `true`, includes `undefined` in the returned type when accessing properties on `Record<string, any>`.
-
-Known limitations:
-- Does not include `undefined` in the type on object types with an index signature (for example, `{a: string; [key: string]: string}`).
-*/
-type StrictPropertyOf<BaseType, Key extends keyof BaseType, Options extends GetOptions> =
-	Record<string, any> extends BaseType
-		? string extends keyof BaseType
-			? Strictify<BaseType[Key], Options> // Record<string, any>
-			: BaseType[Key] // Record<'a' | 'b', any> (Records with a string union as keys have required properties)
-		: BaseType[Key];
-
-/**
-Splits a dot-prop style path into a tuple comprised of the properties in the path. Handles square-bracket notation.
-
-@example
-```
-ToPath<'foo.bar.baz'>
-//=> ['foo', 'bar', 'baz']
-
-ToPath<'foo[0].bar.baz'>
-//=> ['foo', '0', 'bar', 'baz']
-```
-*/
-type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
-
-/**
-Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
-*/
-type FixPathSquareBrackets<Path extends string> =
-	Path extends `[${infer Head}]${infer Tail}`
-		? Tail extends `[${string}`
-			? `${Head}.${FixPathSquareBrackets<Tail>}`
-			: `${Head}${FixPathSquareBrackets<Tail>}`
-		: Path extends `${infer Head}[${infer Middle}]${infer Tail}`
-			? `${Head}.${FixPathSquareBrackets<`[${Middle}]${Tail}`>}`
-			: Path;
-
-/**
-Returns true if `LongString` is made up out of `Substring` repeated 0 or more times.
-
-@example
-```
-ConsistsOnlyOf<'aaa', 'a'> //=> true
-ConsistsOnlyOf<'ababab', 'ab'> //=> true
-ConsistsOnlyOf<'aBa', 'a'> //=> false
-ConsistsOnlyOf<'', 'a'> //=> true
-```
-*/
-type ConsistsOnlyOf<LongString extends string, Substring extends string> =
-	LongString extends ''
-		? true
-		: LongString extends `${Substring}${infer Tail}`
-			? ConsistsOnlyOf<Tail, Substring>
-			: false;
-
-/**
-Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types.
-
-@example
-```
-type WithNumbers = {foo: string; 0: boolean};
-type WithStrings = WithStringKeys<WithNumbers>;
-
-type WithNumbersKeys = keyof WithNumbers;
-//=> 'foo' | 0
-type WithStringsKeys = keyof WithStrings;
-//=> 'foo' | '0'
-```
-*/
-type WithStringKeys<BaseType> = {
-	[Key in StringKeyOf<BaseType>]: UncheckedIndex<BaseType, Key>
-};
-
-/**
-Perform a `T[U]` operation if `T` supports indexing.
-*/
-type UncheckedIndex<T, U extends string | number> = [T] extends [Record<string | number, any>] ? T[U] : never;
-
-/**
-Get a property of an object or array. Works when indexing arrays using number-literal-strings, for example, `PropertyOf<number[], '0'> = number`, and when indexing objects with number keys.
-
-Note:
-- Returns `unknown` if `Key` is not a property of `BaseType`, since TypeScript uses structural typing, and it cannot be guaranteed that extra properties unknown to the type system will exist at runtime.
-- Returns `undefined` from nullish values, to match the behaviour of most deep-key libraries like `lodash`, `dot-prop`, etc.
-*/
-type PropertyOf<BaseType, Key extends string, Options extends GetOptions = {}> =
-	BaseType extends null | undefined
-		? undefined
-		: Key extends keyof BaseType
-			? StrictPropertyOf<BaseType, Key, Options>
-			// Handle arrays and tuples
-			: BaseType extends readonly unknown[]
-				? Key extends `${number}`
-					// For arrays with unknown length (regular arrays)
-					? number extends BaseType['length']
-						? Strictify<BaseType[number], Options>
-						// For tuples: check if the index is valid
-						: Key extends keyof BaseType
-							? Strictify<BaseType[Key & keyof BaseType], Options>
-							// Out-of-bounds access for tuples
-							: unknown
-					// Non-numeric string key for arrays/tuples
-					: unknown
-				// Handle array-like objects
-				: BaseType extends {
-					[n: number]: infer Item;
-					length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
-				}
-					? (
-						ConsistsOnlyOf<Key, StringDigit> extends true
-							? Strictify<Item, Options>
-							: unknown
-					)
-					: Key extends keyof WithStringKeys<BaseType>
-						? StrictPropertyOf<WithStringKeys<BaseType>, Key, Options>
-						: unknown;
-
-// This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
-/**
-Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
-
-Use-case: Retrieve a property from deep inside an API response or some other complex object.
-
-@example
-```
-import type {Get} from 'type-fest';
-import * as lodash from 'lodash';
-
-const get = <BaseType, Path extends string | readonly string[]>(object: BaseType, path: Path): Get<BaseType, Path> =>
-	lodash.get(object, path);
-
-interface ApiResponse {
-	hits: {
-		hits: Array<{
-			_id: string
-			_source: {
-				name: Array<{
-					given: string[]
-					family: string
-				}>
-				birthDate: string
-			}
-		}>
-	}
-}
-
-const getName = (apiResponse: ApiResponse) =>
-	get(apiResponse, 'hits.hits[0]._source.name');
-	//=> Array<{given: string[]; family: string}> | undefined
-
-// Path also supports a readonly array of strings
-const getNameWithPathArray = (apiResponse: ApiResponse) =>
-	get(apiResponse, ['hits','hits', '0', '_source', 'name'] as const);
-	//=> Array<{given: string[]; family: string}> | undefined
-
-// Non-strict mode:
-Get<string[], '3', {strict: false}> //=> string
-Get<Record<string, string>, 'foo', {strict: true}> // => string
-```
-
-@category Object
-@category Array
-@category Template literal
-*/
-type Get<
-	BaseType,
-	Path extends
-	| readonly string[]
-	| LiteralStringUnion<ToString<Paths<BaseType, {bracketNotation: false; maxRecursionDepth: 2}> | Paths<BaseType, {bracketNotation: true; maxRecursionDepth: 2}>>>,
-	Options extends GetOptions = {}> =
-		GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;
-
-declare const omit: <T extends { [key in string]: unknown; }, K extends string>(object: T, keys: Paths<T>[]) => OmitDeep<T, K>;
-
-declare const pick: <T extends { [key in string]: unknown; }, K extends Paths<T>>(object: T, keys: Paths<T>[]) => PickDeep<T, K>;
-
-interface DeeksOptions {
-    /** @default false */
-    arrayIndexesAsKeys?: boolean;
-    /** @default true */
-    expandNestedObjects?: boolean;
-    /** @default false */
-    expandArrayObjects?: boolean;
-    /** @default false */
-    ignoreEmptyArraysWhenExpanding?: boolean;
-    /** @default false */
-    escapeNestedDots?: boolean;
-    /** @default false */
-    ignoreEmptyArrays?: boolean;
-}
-
-/**
- * Return the deep keys list for a single document
- * @param object
- * @param options
- * @returns {Array}
- */
-declare function deepKeys(object: object, options?: DeeksOptions): string[];
-/**
- * Return the deep keys list for all documents in the provided list
- * @param list
- * @param options
- * @returns Array[Array[String]]
- */
-declare function deepKeysFromList(list: object[], options?: DeeksOptions): string[][];
-
-/**
-Get the value of the property at the given path.
-
-@param object - Object or array to get the `path` value.
-@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
-@param defaultValue - Default value.
-
-@example
-```
-import {getProperty} from 'dot-prop';
-
-getProperty({foo: {bar: 'unicorn'}}, 'foo.bar');
-//=> 'unicorn'
-
-getProperty({foo: {bar: 'a'}}, 'foo.notDefined.deep');
-//=> undefined
-
-getProperty({foo: {bar: 'a'}}, 'foo.notDefined.deep', 'default value');
-//=> 'default value'
-
-getProperty({foo: {'dot.dot': 'unicorn'}}, 'foo.dot\\.dot');
-//=> 'unicorn'
-
-getProperty({foo: [{bar: 'unicorn'}]}, 'foo[0].bar');
-//=> 'unicorn'
-```
-*/
-declare function getProperty<ObjectType, PathType extends string, DefaultValue = undefined>(
-	object: ObjectType,
-	path: PathType,
-	defaultValue?: DefaultValue
-): ObjectType extends Record<string, unknown> | unknown[] ? (unknown extends Get<ObjectType, PathType> ? DefaultValue : Get<ObjectType, PathType>) : undefined;
-
-/**
-Set the property at the given path to the given value.
-
-@param object - Object or array to set the `path` value.
-@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
-@param value - Value to set at `path`.
-@returns The object.
-
-@example
-```
-import {setProperty} from 'dot-prop';
-
-const object = {foo: {bar: 'a'}};
-setProperty(object, 'foo.bar', 'b');
-console.log(object);
-//=> {foo: {bar: 'b'}}
-
-const foo = setProperty({}, 'foo.bar', 'c');
-console.log(foo);
-//=> {foo: {bar: 'c'}}
-
-setProperty(object, 'foo.baz', 'x');
-console.log(object);
-//=> {foo: {bar: 'b', baz: 'x'}}
-
-setProperty(object, 'foo.biz[0]', 'a');
-console.log(object);
-//=> {foo: {bar: 'b', baz: 'x', biz: ['a']}}
-```
-*/
-declare function setProperty<ObjectType extends Record<string, any>>(
-	object: ObjectType,
-	path: string,
-	value: unknown
-): ObjectType;
-
-/**
-Check whether the property at the given path exists.
-
-@param object - Object or array to test the `path` value.
-@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
-
-@example
-```
-import {hasProperty} from 'dot-prop';
-
-hasProperty({foo: {bar: 'unicorn'}}, 'foo.bar');
-//=> true
-```
-*/
-declare function hasProperty(object: Record<string, any> | undefined, path: string): boolean;
-
-/**
-Delete the property at the given path.
-
-@param object - Object or array to delete the `path` value.
-@param path - Path of the property in the object, using `.` to separate each nested key. Use `\\.` if you have a `.` in the key.
-@returns A boolean of whether the property existed before being deleted.
-
-@example
-```
-import {deleteProperty} from 'dot-prop';
-
-const object = {foo: {bar: 'a'}};
-deleteProperty(object, 'foo.bar');
-console.log(object);
-//=> {foo: {}}
-
-object.foo.bar = {x: 'y', y: 'x'};
-deleteProperty(object, 'foo.bar.x');
-console.log(object);
-//=> {foo: {bar: {y: 'x'}}}
-```
-*/
-declare function deleteProperty(object: Record<string, any>, path: string): boolean;
-
-/**
-Escape special characters in a path. Useful for sanitizing user input.
-
-@param path - The dot path to sanitize.
-
-@example
-```
-import {getProperty, escapePath} from 'dot-prop';
-
-const object = {
-	foo: {
-		bar: '👸🏻 You found me Mario!',
-	},
-	'foo.bar' : '🍄 The princess is in another castle!',
-};
-const escapedPath = escapePath('foo.bar');
-
-console.log(getProperty(object, escapedPath));
-//=> '🍄 The princess is in another castle!'
-```
-*/
-declare function escapePath(path: string): string;
-
-/**
-Check if a value is a plain object.
-
-An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`.
-
-@example
-```
-import isPlainObject from 'is-plain-obj';
-import {runInNewContext} from 'node:vm';
-
-isPlainObject({foo: 'bar'});
-//=> true
-
-isPlainObject(new Object());
-//=> true
-
-isPlainObject(Object.create(null));
-//=> true
-
-// This works across realms
-isPlainObject(runInNewContext('({})'));
-//=> true
-
-isPlainObject([1, 2, 3]);
-//=> false
-
-class Unicorn {}
-isPlainObject(new Unicorn());
-//=> false
-
-isPlainObject(Math);
-//=> false
-```
-*/
-declare function isPlainObject<Value>(value: unknown): value is Record<PropertyKey, Value>;
-
-export { type DeeksOptions as DeepKeysOptions, type OmitDeep, type Paths, type PickDeep, type Split, deepKeys, deepKeysFromList, deleteProperty, escapePath, getProperty, hasProperty, isPlainObject, omit, pick, setProperty };
+export { default as omit } from "./omit.d.cts";
+export { default as pick } from "./pick.d.cts";
+export type { DeeksOptions as DeepKeysOptions } from "deeks";
+export { deepKeys, deepKeysFromList } from "deeks";
+export { deleteProperty, escapePath, getProperty, hasProperty, setProperty } from "dot-prop";
+export { default as isPlainObject } from "is-plain-obj";
+export type { OmitDeep, Paths, PickDeep, Split } from "type-fest";