@oscarpalmer/atoms 0.74.1 → 0.76.0

package/types/value/smush.d.cts

@@ -0,0 +1,1368 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+export type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+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
+*/
+export 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
+*/
+export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <
+	G,
+>() => G extends B ? 1 : 2
+	? true
+	: false;
+/**
+Represents an object with `unknown` value. You probably want this instead of `{}`.
+
+Use case: You have an object whose keys and values are unknown to you.
+
+@example
+```
+import type {UnknownRecord} from 'type-fest';
+
+function toJson(object: UnknownRecord) {
+	return JSON.stringify(object);
+}
+
+toJson({hello: 'world'});
+//=> '{"hello":"world"}'
+
+function isObject(value: unknown): value is UnknownRecord {
+	return typeof value === 'object' && value !== null;
+}
+
+isObject({hello: 'world'});
+//=> true
+
+isObject('hello');
+//=> false
+```
+
+@category Type
+@category Object
+*/
+export type UnknownRecord = Record<PropertyKey, unknown>;
+/**
+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
+*/
+export 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
+*/
+export type Simplify<T> = {
+	[KeyType in keyof T]: T[KeyType];
+} & {};
+/**
+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]
+```
+*/
+export 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[]
+```
+*/
+export type VariablePartOfArray<T extends UnknownArray> = T extends unknown
+	? T extends readonly [...StaticPartOfArray<T>, ...infer U]
+		? U
+		: []
+	: never; // Should never happen
+export type StringDigit =
+	| '0'
+	| '1'
+	| '2'
+	| '3'
+	| '4'
+	| '5'
+	| '6'
+	| '7'
+	| '8'
+	| '9';
+/**
+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
+*/
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type Numeric = number | bigint;
+export 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
+export 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
+export type NegativeInfinity = -1e999;
+/**
+A negative `number`/`bigint` (`-∞ < x < 0`)
+
+Use-case: Validating and documenting parameters.
+
+@see NegativeInteger
+@see NonNegative
+
+@category Numeric
+*/
+export 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
+*/
+export 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}
+*/
+export 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}
+*/
+export 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
+```
+*/
+export 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
+```
+*/
+export 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
+```
+*/
+export type LessThan<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThanOrEqual<A, B> extends true
+		? false
+		: true;
+/**
+Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
+
+If `<Fill>` is not provided, it will default to `unknown`.
+
+@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+*/
+export type BuildTuple<
+	L extends number,
+	Fill = unknown,
+	T extends readonly unknown[] = [],
+> = T['length'] extends L ? 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
+```
+*/
+export 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
+```
+*/
+export 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.
+*/
+export 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
+*/
+export 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
+*/
+export 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
+*/
+export 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
+```
+*/
+export 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;
+export 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
+```
+*/
+export type PositiveNumericStringGt<
+	A extends string,
+	B extends string,
+> = A extends B
+	? false
+	: [
+				BuildTuple<StringLength<A>, 0>,
+				BuildTuple<StringLength<B>, 0>,
+			] extends infer R extends [readonly unknown[], readonly unknown[]]
+		? 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
+```
+*/
+export 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;
+/**
+Returns the absolute value of a given value.
+
+@example
+```
+NumberAbsolute<-1>;
+//=> 1
+
+NumberAbsolute<1>;
+//=> 1
+
+NumberAbsolute<NegativeInfinity>
+//=> PositiveInfinity
+```
+*/
+export 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
+*/
+export type IsNumberLike<N> = N extends number
+	? true
+	: N extends `${number}`
+		? true
+		: N extends `${number}.${number}`
+			? true
+			: false;
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+export type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Matches non-recursive types.
+*/
+export type NonRecursiveType =
+	| BuiltIns
+	| Function
+	| (new (
+			...arguments_: any[]
+	  ) => unknown);
+/**
+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.
+export 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.
+export 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}
+*/
+export 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;
+};
+export 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
+*/
+export 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'];
+	}
+>;
+export 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']
+				?
+						| InternalPaths<StaticPartOfArray<T>, Options>
+						| InternalPaths<Array<VariablePartOfArray<T>[number]>, Options>
+				: InternalPaths<T, Options>
+			: T extends object
+				? InternalPaths<T, Options>
+				: never;
+export 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
+										? 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;
+export 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
+*/
+export type LiteralUnion<LiteralType, BaseType extends Primitive> =
+	| LiteralType
+	| (BaseType & Record<never, never>);
+/**
+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
+*/
+export 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
+*/
+export type Split<
+	S extends string,
+	Delimiter extends string,
+> = S extends `${infer Head}${Delimiter}${infer Tail}`
+	? [Head, ...Split<Tail, Delimiter>]
+	: S extends Delimiter
+		? []
+		: [S];
+export 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.
+*/
+export 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.
+*/
+export 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}`).
+*/
+export 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']
+```
+*/
+export type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
+/**
+Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
+*/
+export 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
+```
+*/
+export 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'
+```
+*/
+export type WithStringKeys<BaseType> = {
+	[Key in StringKeyOf<BaseType>]: UncheckedIndex<BaseType, Key>;
+};
+/**
+Perform a `T[U]` operation if `T` supports indexing.
+*/
+export 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.
+*/
+export type PropertyOf<
+	BaseType,
+	Key extends string,
+	Options extends GetOptions = {},
+> = BaseType extends null | undefined
+	? undefined
+	: Key extends keyof BaseType
+		? StrictPropertyOf<BaseType, Key, Options>
+		: BaseType extends readonly [] | readonly [unknown, ...unknown[]]
+			? unknown // It's a tuple, but `Key` did not extend `keyof BaseType`. So the index is out of bounds.
+			: 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
+*/
+export type Get<
+	BaseType,
+	Path extends
+		| readonly string[]
+		| LiteralStringUnion<
+				ToString<
+					| Paths<
+							BaseType,
+							{
+								bracketNotation: false;
+							}
+					  >
+					| Paths<
+							BaseType,
+							{
+								bracketNotation: true;
+							}
+					  >
+				>
+		  >,
+	Options extends GetOptions = {},
+> = GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;
+export type PlainObject = UnknownRecord;
+export type Smushed<Value> = Simplify<{
+	[Key in Paths<Value>]: Get<Value, ToString<Key>>;
+}>;
+/**
+ * Smush an object into a flat object that uses dot notation keys
+ */
+export declare function smush<Value extends PlainObject>(
+	value: Value,
+): Smushed<Value>;
+
+export {};