@visulima/object 1.0.10 → 1.0.11

package/dist/index.d.cts

@@ -1,2456 +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 the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed string manipulation functions
-	- constraining strings to be a string literal
-	- type utilities, such as when constructing parsers and ASTs
-
-The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-@example
-```
-import type {IsStringLiteral} from 'type-fest';
-
-type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
-
-// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
-function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
-	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
-}
-
-const output = capitalize('hello, world!');
-//=> 'Hello, world!'
-```
-
-@example
-```
-// String types with infinite set of possible values return `false`.
-
-import type {IsStringLiteral} from 'type-fest';
-
-type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
-//=> false
-
-type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
-//=> false
-
-// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
-
-type Length<S extends string, Counter extends never[] = []> =
-	IsStringLiteral<S> extends false
-		? number // return `number` for infinite string types
-		: S extends `${string}${infer Tail}`
-			? Length<Tail, [...Counter, never]>
-			: Counter['length'];
-
-type L1 = Length<Lowercase<string>>;
-//=> number
-
-type L2 = Length<`${number}`>;
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsStringLiteral<T> = IfNever<T, false,
-// 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>
-		? false
-		: 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;
-
-// 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]>;
-
-/**
-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 number with reversed sign.
-
-@example
-```
-ReverseSign<-1>;
-//=> 1
-
-ReverseSign<1>;
-//=> -1
-
-ReverseSign<NegativeInfinity>
-//=> PositiveInfinity
-
-ReverseSign<PositiveInfinity>
-//=> NegativeInfinity
-```
-*/
-type ReverseSign<N extends number> =
-	// Handle edge cases
-	N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity :
-	// Handle negative numbers
-	`${N}` extends `-${infer P extends number}` ? P
-		// Handle positive numbers
-		: `-${N}` extends `${infer R extends number}` ? R : never;
-
-/**
-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);
-
-/**
-Returns a boolean for whether A is false.
-
-@example
-```
-Not<true>;
-//=> false
-
-Not<false>;
-//=> true
-```
-*/
-type Not<A extends boolean> = A extends true
-	? false
-	: A extends false
-		? true
-		: never;
-
-/**
-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 difference between two numbers.
-
-Note:
-- A or B can only support `-999` ~ `999`.
-
-@example
-```
-import type {Subtract} from 'type-fest';
-
-Subtract<333, 222>;
-//=> 111
-
-Subtract<111, -222>;
-//=> 333
-
-Subtract<-111, 222>;
-//=> -333
-
-Subtract<18, 96>;
-//=> -78
-
-Subtract<PositiveInfinity, 9999>;
-//=> PositiveInfinity
-
-Subtract<PositiveInfinity, PositiveInfinity>;
-//=> number
-```
-
-@category Numeric
-*/
-// TODO: Support big integer.
-type Subtract<A extends number, B extends number> =
-	// Handle cases when A or B is the actual "number" type
-	number extends A | B ? number
-		// Handle cases when A and B are both +/- infinity
-		: A extends B & (PositiveInfinity | NegativeInfinity) ? number
-			// Handle cases when A is - infinity or B is + infinity
-			: A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity
-				// Handle cases when A is + infinity or B is - infinity
-				: A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity
-					// Handle case when numbers are equal to each other
-					: A extends B ? 0
-						// Handle cases when A or B is 0
-						: A extends 0 ? ReverseSign<B> : B extends 0 ? A
-							// Handle remaining regular cases
-							: SubtractPostChecks<A, B>;
-
-/**
-Subtracts two numbers A and B, such that they are not equal and neither of them are 0, +/- infinity or the `number` type
-*/
-type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
-	AreNegative extends [false, false]
-		? SubtractPositives<A, B>
-		: AreNegative extends [true, true]
-			// When both numbers are negative we subtract the absolute values and then reverse the sign
-			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
-			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
-				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
-				: never;
-
-/**
-Subtracts two positive numbers.
-*/
-type SubtractPositives<A extends number, B extends number> =
-	LessThan<A, B> extends true
-		// When A < B we can reverse the result of B - A
-		? ReverseSign<SubtractIfAGreaterThanB<B, A>>
-		: SubtractIfAGreaterThanB<A, B>;
-
-/**
-Subtracts two positive numbers A and B such that A > B.
-*/
-type SubtractIfAGreaterThanB<A extends number, B extends number> =
-	// This is where we always want to end up and do the actual subtraction
-	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
-		? R['length']
-		: 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;
-
-	/**
-	Only include leaf paths in the output.
-
-	@default false
-
-	@example
-	```
-	type Post = {
-		id: number;
-		author: {
-			id: number;
-			name: {
-				first: string;
-				last: string;
-			};
-		};
-	};
-
-	type AllPaths = Paths<Post, {leavesOnly: false}>;
-	//=> 'id' | 'author' | 'author.id' | 'author.name' | 'author.name.first' | 'author.name.last'
-
-	type LeafPaths = Paths<Post, {leavesOnly: true}>;
-	//=> 'id' | 'author.id' | 'author.name.first' | 'author.name.last'
-	```
-
-	@example
-	```
-	type ArrayExample = {
-		array: Array<{foo: string}>;
-		tuple: [string, {bar: string}];
-	};
-
-	type AllPaths = Paths<ArrayExample, {leavesOnly: false}>;
-	//=> 'array' | `array.${number}` | `array.${number}.foo` | 'tuple' | 'tuple.0' | 'tuple.1' | 'tuple.1.bar'
-
-	type LeafPaths = Paths<ArrayExample, {leavesOnly: true}>;
-	//=> `array.${number}.foo` | 'tuple.0' | 'tuple.1.bar'
-	```
-	*/
-	leavesOnly?: boolean;
-
-	/**
-	Only include paths at the specified depth. By default all paths up to {@link PathsOptions.maxRecursionDepth | `maxRecursionDepth`} are included.
-
-	Note: Depth starts at `0` for root properties.
-
-	@default number
-
-	@example
-	```
-	type Post = {
-		id: number;
-		author: {
-			id: number;
-			name: {
-				first: string;
-				last: string;
-			};
-		};
-	};
-
-	type DepthZero = Paths<Post, {depth: 0}>;
-	//=> 'id' | 'author'
-
-	type DepthOne = Paths<Post, {depth: 1}>;
-	//=> 'author.id' | 'author.name'
-
-	type DepthTwo = Paths<Post, {depth: 2}>;
-	//=> 'author.name.first' | 'author.name.last'
-
-	type LeavesAtDepthOne = Paths<Post, {leavesOnly: true; depth: 1}>;
-	//=> 'author.id'
-	```
-	*/
-	depth?: number;
-};
-
-type DefaultPathsOptions = {
-	maxRecursionDepth: 10;
-	bracketNotation: false;
-	leavesOnly: false;
-	depth: number;
-};
-
-/**
-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'];
-	// Set default leavesOnly to false
-	leavesOnly: Options['leavesOnly'] extends boolean ? Options['leavesOnly'] : DefaultPathsOptions['leavesOnly'];
-	// Set default depth to number
-	depth: Options['depth'] extends number ? Options['depth'] : DefaultPathsOptions['depth'];
-}>;
-
-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
-							| ((Options['leavesOnly'] extends true
-								? MaxDepth extends 0
-									? TranformedKey
-									: T[Key] extends EmptyObject | readonly [] | NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
-										? TranformedKey
-										: never
-								: TranformedKey
-							) extends infer _TransformedKey
-								// If `depth` is provided, the condition becomes truthy only when it reaches `0`.
-								// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
-								? 0 extends Options['depth']
-									? _TransformedKey
-									: never
-								: never)
-							| (
-								// Recursively generate paths for the current key
-								GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
-									? _Paths<T[Key],
-									{
-										bracketNotation: Options['bracketNotation'];
-										maxRecursionDepth: Subtract<MaxDepth, 1>;
-										leavesOnly: Options['leavesOnly'];
-										depth: Subtract<Options['depth'], 1>;
-									}> extends infer SubPath
-										? 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<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, 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>);
-
-/**
-Returns the last element of a union type.
-
-@example
-```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
-```
-*/
-type LastOfUnion<T> =
-UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
-	? R
-	: never;
-
-/**
-Convert a union type into an unordered tuple type of its elements.
-
-"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
-
-This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
-
-@example
-```
-import type {UnionToTuple} from 'type-fest';
-
-type Numbers = 1 | 2 | 3;
-type NumbersTuple = UnionToTuple<Numbers>;
-//=> [1, 2, 3]
-```
-
-@example
-```
-import type {UnionToTuple} from 'type-fest';
-
-const pets = {
-  dog: '🐶',
-  cat: '🐱',
-  snake: '🐍',
-};
-
-type Pet = keyof typeof pets;
-//=> 'dog' | 'cat' | 'snake'
-
-const petList = Object.keys(pets) as UnionToTuple<Pet>;
-//=> ['dog', 'cat', 'snake']
-```
-
-@category Array
-*/
-type UnionToTuple<T, L = LastOfUnion<T>> =
-IsNever<T> extends false
-	? [...UnionToTuple<Exclude<T, L>>, L]
-	: [];
-
-/**
-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<
-	OmitDeepHelper<T, UnionToTuple<PathUnion>>,
-	UnknownArray>;
-
-/**
-Internal helper for {@link OmitDeep}.
-
-Recursively transforms `T` by applying {@link OmitDeepWithOnePath} for each path in `PathTuple`.
-*/
-type OmitDeepHelper<T, PathTuple extends UnknownArray> =
-	PathTuple extends [infer Path, ...infer RestPaths]
-		? OmitDeepHelper<OmitDeepWithOnePath<T, Path & (string | number)>, RestPaths>
-		: T;
-
-/**
-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>}`;
-
-/**
-Split options.
-
-@see {@link Split}
-*/
-type SplitOptions = {
-	/**
-	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
-
-	Note: In the future, this option might be enabled by default, so if you currently rely on this being disabled, you should consider explicitly enabling it.
-
-	@default false
-
-	@example
-	```ts
-	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
-	//=> ['foo', string, 'bar']
-
-	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
-	//=> string[]
-
-	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
-	//=> ['foo', 'r', 'z']
-
-	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
-	//=> string[]
-	```
-	*/
-	strictLiteralChecks?: boolean;
-};
-
-type DefaultSplitOptions = {
-	strictLiteralChecks: false;
-};
-
-/**
-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, ',');
-```
-
-@see {@link SplitOptions}
-
-@category String
-@category Template literal
-*/
-type Split<
-	S extends string,
-	Delimiter extends string,
-	Options extends SplitOptions = {},
-> = SplitHelper<S, Delimiter, {
-	strictLiteralChecks: Options['strictLiteralChecks'] extends boolean ? Options['strictLiteralChecks'] : DefaultSplitOptions['strictLiteralChecks'];
-}>;
-
-type SplitHelper<
-	S extends string,
-	Delimiter extends string,
-	Options extends Required<SplitOptions>,
-	Accumulator extends string[] = [],
-> = S extends string // For distributing `S`
-	? Delimiter extends string // For distributing `Delimeter`
-		// If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
-		? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true
-			? S extends `${infer Head}${Delimiter}${infer Tail}`
-				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
-				: Delimiter extends ''
-					? Accumulator
-					: [...Accumulator, S]
-			// Otherwise, return `string[]`
-			: string[]
-		: never // Should never happen
-	: never; // Should never happen
-
-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";