@react-querybuilder/core 8.9.2 → 8.10.0

package/dist/react-querybuilder_core.d.mts

@@ -2,59 +2,205 @@ import { JsonLogicAll, JsonLogicAnd, JsonLogicDoubleNegation, JsonLogicEqual, Js
 import { Column, Operators, SQL, Table } from "drizzle-orm";
 import { WhereOptions } from "sequelize";
 
-//#region src/types/type-fest/is-equal.d.ts
+//#region ../../node_modules/type-fest/source/primitive.d.ts
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region ../../node_modules/type-fest/source/observable-like.d.ts
+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;
+  }
+}
 
 /**
-Returns a boolean for whether the two given types are equal.
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
 
-@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
+@category Observable
+*/
 
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
+//#endregion
+//#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
+/**
+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 {IsEqual} from 'type-fest';
+import type {UnionToIntersection} 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;
+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;
+//#endregion
+//#region ../../node_modules/type-fest/source/keys-of-union.d.ts
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
 ```
 
-@group type-fest
+@category Object
 */
-type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+type KeysOfUnion<ObjectType> =
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
 //#endregion
-//#region src/types/type-fest/and.d.ts
+//#region ../../node_modules/type-fest/source/optional-keys-of.d.ts
 /**
-Returns a boolean for whether two given types are both true.
+Extract all optional keys from the given type.
 
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+This is useful when you want to create a new type that contains different type values for the optional keys only.
 
 @example
 ```
-import type {And} from 'type-fest';
+import type {OptionalKeysOf, Except} from 'type-fest';
 
-And<true, true>;
-//=> true
+interface User {
+	name: string;
+	surname: string;
 
-And<true, false>;
-//=> false
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+: never;
+//#endregion
+//#region ../../node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
 ```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
 
-@see {@link Or}
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+```
 
-@group type-fest
+@category Utilities
 */
-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;
+type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
 //#endregion
-//#region src/types/type-fest/is-never.d.ts
+//#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -70,20 +216,20 @@ 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
->;
+	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;
+	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);
-}
+	if (input === output) {
+		process.exit(0);
+	}
 }
 
 endIfEqual('abc', 'abc');
@@ -93,11 +239,12 @@ endIfEqual('abc', '123');
 //=> void
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region src/types/type-fest/if-never.d.ts
+//#region ../../node_modules/type-fest/source/if-never.d.ts
 /**
 An if-else-like type that resolves depending on whether the given type is `never`.
 
@@ -114,11 +261,12 @@ type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
 //=> 'bar'
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
 //#endregion
-//#region src/types/type-fest/unknown-array.d.ts
+//#region ../../node_modules/type-fest/source/unknown-array.d.ts
 /**
 Represents an array with `unknown` value.
 
@@ -140,16 +288,15 @@ type C = IsArray<string>;
 //=> false
 ```
 
-@group type-fest
+@category Type
+@category Array
 */
 type UnknownArray = readonly unknown[];
 //#endregion
-//#region src/types/type-fest/internal/array.d.ts
+//#region ../../node_modules/type-fest/source/internal/array.d.ts
 
 /**
 Returns whether the given array `T` is readonly.
-
-@group type-fest
 */
 type IsArrayReadonly<T extends UnknownArray> = IfNever$1<T, false, T extends unknown[] ? false : true>;
 /**
@@ -162,9 +309,9 @@ An if-else-like type that resolves depending on whether the given array is reado
 import type {ArrayTail} from 'type-fest';
 
 type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-ArrayTail<TArray> extends infer Tail
-? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-: never;
+	ArrayTail<TArray> extends infer Tail
+		? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
+		: never;
 
 type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
 //=> readonly [number, boolean]
@@ -178,19 +325,14 @@ type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
 type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
 //=> 'bar'
 ```
-
-@group type-fest
 */
 type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
 //#endregion
-//#region src/types/type-fest/internal/characters.d.ts
-/**
-@group type-fest
-*/
-type Whitespace = "	" | "\n" | "\v" | "\f" | "\r" | " " | "…" | "\xA0" | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | " " | "\u2028" | "\u2029" | " " | " " | "　" | "";
-//#endregion
-//#region src/types/type-fest/is-any.d.ts
+//#region ../../node_modules/type-fest/source/is-any.d.ts
+// 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`.
 
@@ -206,809 +348,51 @@ 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];
+	return obj[key];
 }
 
 const typedA = get(typedObject, 'a');
 //=> 1
 
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@group type-fest
-*/
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-//#endregion
-//#region src/types/type-fest/primitive.d.ts
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@group type-fest
-*/
-type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-//#endregion
-//#region src/types/type-fest/is-float.d.ts
-/**
-Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
-
-Use-case:
-- If you want to make a conditional branch based on the result of whether a number is a float or not.
-
-@example
-```
-import type {IsFloat, PositiveInfinity} from "type-fest";
-
-type A = IsFloat<1.5>;
-//=> true
-
-type B = IsFloat<-1.5>;
-//=> true
-
-type C = IsFloat<1e-7>;
-//=> true
-
-type D = IsFloat<1.0>;
-//=> false
-
-type E = IsFloat<PositiveInfinity>;
-//=> false
-
-type F = IsFloat<1.23e+21>;
-//=> false
-```
-
-@group type-fest
-*/
-type IsFloat<T> = T extends number ? `${T}` extends `${number}e${infer E extends "-" | "+"}${number}` ? E extends "-" ? true : false : `${T}` extends `${number}.${number}` ? true : false : false;
-//#endregion
-//#region src/types/type-fest/is-integer.d.ts
-/**
-Returns a boolean for whether the given number is an integer, like `-5`, `1.0`, or `100`.
-
-Use-case:
-- If you want to make a conditional branch based on the result of whether a number is an integer or not.
-
-@example
-```
-import type {IsInteger, PositiveInfinity} from "type-fest";
-
-type A = IsInteger<1>;
-//=> true
-
-type B = IsInteger<1.0>;
-//=> true
-
-type C = IsInteger<-1>;
-//=> true
-
-type D = IsInteger<0b10>;
-//=> true
-
-type E = IsInteger<0o10>;
-//=> true
-
-type F = IsInteger<0x10>;
-//=> true
-
-type G = IsInteger<1.23+21>;
-//=> true
-
-type H = IsInteger<1.5>;
-//=> false
-
-type I = IsInteger<PositiveInfinity>;
-//=> false
-
-type J = IsInteger<1e-7>;
-//=> false
-```
-
-@group type-fest
-*/
-type IsInteger<T> = T extends bigint ? true : T extends number ? number extends T ? false : T extends PositiveInfinity | NegativeInfinity ? false : Not<IsFloat<T>> : false;
-//#endregion
-//#region src/types/type-fest/numeric.d.ts
-/**
-@group type-fest
-*/
-type Numeric = number | bigint;
-/**
-@group type-fest
-*/
-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
-
-@group type-fest
-*/
-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
-
-@group type-fest
-*/
-type NegativeInfinity = -1e999;
-/**
-A finite `number`.
-You can't pass a `bigint` as they are already guaranteed to be finite.
-
-Use-case: Validating and documenting parameters.
-
-Note: This can't detect `NaN`, please upvote [this issue](https://github.com/microsoft/TypeScript/issues/28682) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-import type {Finite} from 'type-fest';
-
-declare function setScore<T extends number>(length: Finite<T>): void;
-```
-
-@group type-fest
-*/
-type Finite<T extends number> = T extends PositiveInfinity | NegativeInfinity ? never : T;
-/**
-A `number` that is an integer.
-
-Use-case: Validating and documenting parameters.
-
-@example
-```
-type Integer = Integer<1>;
-//=> 1
-
-type IntegerWithDecimal = Integer<1.0>;
-//=> 1
-
-type NegativeInteger = Integer<-1>;
-//=> -1
-
-type Float = Integer<1.5>;
-//=> never
-
-// Supports non-decimal numbers
-
-type OctalInteger: Integer<0o10>;
-//=> 0o10
-
-type BinaryInteger: Integer<0b10>;
-//=> 0b10
-
-type HexadecimalInteger: Integer<0x10>;
-//=> 0x10
-```
-
-@example
-```
-import type {Integer} from 'type-fest';
-
-declare function setYear<T extends number>(length: Integer<T>): void;
-```
-
-@see NegativeInteger
-@see NonNegativeInteger
-
-@group type-fest
-*/
-type Integer<T> = T extends unknown ? IsInteger<T> extends true ? T : never : never;
-/**
-A `number` that is not an integer.
-
-Use-case: Validating and documenting parameters.
-
-It does not accept `Infinity`.
-
-@example
-```
-import type {Float} from 'type-fest';
-
-declare function setPercentage<T extends number>(length: Float<T>): void;
-```
-
-@see Integer
-
-@group type-fest
-*/
-type Float<T> = T extends unknown ? IsFloat<T> extends true ? T : never : never;
-/**
-A negative (`-∞ < x < 0`) `number` that is not an integer.
-Equivalent to `Negative<Float<T>>`.
-
-Use-case: Validating and documenting parameters.
-
-@see Negative
-@see Float
-
-@group type-fest
-*/
-type NegativeFloat<T extends number> = Negative<Float<T>>;
-/**
-A negative `number`/`bigint` (`-∞ < x < 0`)
-
-Use-case: Validating and documenting parameters.
-
-@see NegativeInteger
-@see NonNegative
-
-@group type-fest
-*/
-type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
-/**
-A negative (`-∞ < x < 0`) `number` that is an integer.
-Equivalent to `Negative<Integer<T>>`.
-
-You can't pass a `bigint` as they are already guaranteed to be integers, instead use `Negative<T>`.
-
-Use-case: Validating and documenting parameters.
-
-@see Negative
-@see Integer
-
-@group type-fest
-*/
-type NegativeInteger<T extends number> = Negative<Integer<T>>;
-/**
-A non-negative `number`/`bigint` (`0 <= x < ∞`).
-
-Use-case: Validating and documenting parameters.
-
-@see NonNegativeInteger
-@see Negative
-
-@example
-```
-import type {NonNegative} from 'type-fest';
-
-declare function setLength<T extends number>(length: NonNegative<T>): void;
-```
-
-@group type-fest
-*/
-type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> extends never ? T : never;
-/**
-A non-negative (`0 <= x < ∞`) `number` that is an integer.
-Equivalent to `NonNegative<Integer<T>>`.
-
-You can't pass a `bigint` as they are already guaranteed to be integers, instead use `NonNegative<T>`.
-
-Use-case: Validating and documenting parameters.
-
-@see NonNegative
-@see Integer
-
-@example
-```
-import type {NonNegativeInteger} from 'type-fest';
-
-declare function setLength<T extends number>(length: NonNegativeInteger<T>): void;
-```
-
-@group type-fest
-*/
-type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
-/**
-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>;
-```
-
-@group type-fest
-*/
-type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
-//#endregion
-//#region src/types/type-fest/is-literal.d.ts
-/**
-Returns a boolean for whether the given type `T` is the specified `LiteralType`.
-
-@link https://stackoverflow.com/a/52806744/10292952
-
-@example
-```
-LiteralCheck<1, number>
-//=> true
-
-LiteralCheck<number, number>
-//=> false
-
-LiteralCheck<1, string>
-//=> false
-```
-*/
-type LiteralCheck<T, LiteralType extends Primitive> = (IsNever<T> extends false ? [T] extends [LiteralType & infer U] ? [U] extends [LiteralType] ? [LiteralType] extends [U] ? false : true : false : false : false);
-/**
-Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
-
-@example
-```
-LiteralChecks<1, Numeric>
-//=> true
-
-LiteralChecks<1n, Numeric>
-//=> true
-
-LiteralChecks<bigint, Numeric>
-//=> false
-```
-*/
-type LiteralChecks<T, LiteralUnionType> = (IsNotFalse<LiteralUnionType extends Primitive ? LiteralCheck<T, LiteralUnionType> : never>);
-/**
-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
-```
-
-@group type-fest
-*/
-type IsStringLiteral<T> = IfNever$1<T, false, T extends string ? {} extends Record<T, never> ? false : true : false>;
-/**
-Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsNumericLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
-type EndsWith<TValue, TEndsWith extends string> =
-TValue extends string
-? IsStringLiteral<TEndsWith> extends true
-? IsStringLiteral<TValue> extends true
-? TValue extends `${string}${TEndsWith}`
-? true
-: false
-: boolean
-: boolean
-: TValue extends number
-? IsNumericLiteral<TValue> extends true
-? EndsWith<`${TValue}`, TEndsWith>
-: false
-: false;
-
-function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
-return `${input}`.endsWith(end) as EndsWith<Input, End>;
-}
-
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123456, '456');
-//=> true
-
-const end = '123' as string;
-
-endsWith('abc123', end);
-//=> boolean
-```
-
-@group type-fest
-*/
-type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
-/**
-Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsBooleanLiteral} from 'type-fest';
-
-const id = 123;
-
-type GetId<AsString extends boolean> =
-IsBooleanLiteral<AsString> extends true
-? AsString extends true
-? `${typeof id}`
-: typeof id
-: number | string;
-
-function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
-return (options?.asString ? `${id}` : id) as GetId<AsString>;
-}
-
-const numberId = getId();
-//=> 123
-
-const stringId = getId({asString: true});
-//=> '123'
-
-declare const runtimeBoolean: boolean;
-const eitherId = getId({asString: runtimeBoolean});
-//=> number | string
-```
-
-@group type-fest
-*/
-type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
-/**
-Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsSymbolLiteral} from 'type-fest';
-
-type Get<Obj extends Record<symbol, number>, Key extends keyof Obj> =
-IsSymbolLiteral<Key> extends true
-? Obj[Key]
-: number;
-
-function get<Obj extends Record<symbol, number>, Key extends keyof Obj>(o: Obj, key: Key) {
-return o[key] as Get<Obj, Key>;
-}
-
-const symbolLiteral = Symbol('literal');
-const symbolValue: symbol = Symbol('value');
-
-get({[symbolLiteral]: 1} as const, symbolLiteral);
-//=> 1
-
-get({[symbolValue]: 1} as const, symbolValue);
-//=> number
-```
-
-@group type-fest
-*/
-type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
-/** Helper type for `IsLiteral`. */
-type IsLiteralUnion<T> = IsStringLiteral<T> | IsNumericLiteral<T> | IsBooleanLiteral<T> | IsSymbolLiteral<T>;
-/**
-Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/string-literals/StripLeading.ts
-export type StripLeading<A, B> =
-A extends string
-? B extends string
-? IsLiteral<A> extends true
-? string extends B ? never : A extends `${B & string}${infer After}` ? After : A
-: string
-: A
-: A;
-
-function stripLeading<Input extends string, Strip extends string>(input: Input, strip: Strip) {
-return input.replace(`^${strip}`, '') as StripLeading<Input, Strip>;
-}
-
-stripLeading('abc123', 'abc');
-//=> '123'
-
-const str = 'abc123' as string;
-
-stripLeading(str, 'abc');
-//=> string
-```
-
-@group type-fest
-*/
-type IsLiteral<T> = IsPrimitive<T> extends true ? IsNotFalse<IsLiteralUnion<T>> : false;
-//#endregion
-//#region src/types/type-fest/trim.d.ts
-/**
-Remove spaces from the left side.
-*/
-type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
-/**
-Remove spaces from the right side.
-*/
-type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
-/**
-Remove leading and trailing spaces from a string.
-
-@example
-```
-import type {Trim} from 'type-fest';
-
-Trim<' foo '>
-//=> 'foo'
-```
-
-@group type-fest
-*/
-type Trim<V extends string> = TrimLeft<TrimRight<V>>;
-//#endregion
-//#region src/types/type-fest/or.d.ts
-/**
-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}
-
-@group type-fest
-*/
-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;
-//#endregion
-//#region src/types/type-fest/greater-than.d.ts
-/**
-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
-```
-
-@group type-fest
-*/
-type GreaterThan<A extends number, B extends number> = 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 : never : never;
-//#endregion
-//#region src/types/type-fest/greater-than-or-equal.d.ts
-/**
-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
-```
-
-@group type-fest
-*/
-type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B ? never : A extends B ? true : GreaterThan<A, B>;
-//#endregion
-//#region src/types/type-fest/less-than.d.ts
-/**
-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
-```
-
-@group type-fest
-*/
-type LessThan<A extends number, B extends number> = number extends A | B ? never : GreaterThanOrEqual<A, B> extends infer Result ? Result extends true ? false : true : never;
-//#endregion
-//#region src/types/type-fest/internal/tuple.d.ts
-/**
-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
-
-@group type-fest
-*/
-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]>;
-//#endregion
-//#region src/types/type-fest/internal/string.d.ts
-/**
-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
-```
-
-@group type-fest
-*/
-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
-```
-
-@group type-fest
-*/
-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
-```
-
-@group type-fest
-*/
-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
-```
-
-@group type-fest
-*/
-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
+const anyA = get(anyObject, 'a');
+//=> any
 ```
+
+@category Type Guard
+@category Utilities
 */
-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;
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
-//#region src/types/type-fest/internal/numeric.d.ts
+//#region ../../node_modules/type-fest/source/is-equal.d.ts
 /**
-Returns the absolute value of a given value.
+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
 ```
-NumberAbsolute<-1>;
-//=> 1
-
-NumberAbsolute<1>;
-//=> 1
+import type {IsEqual} from 'type-fest';
 
-NumberAbsolute<NegativeInfinity>
-//=> PositiveInfinity
+// 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;
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
+type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
-//#region src/types/type-fest/simplify.d.ts
+//#region ../../node_modules/type-fest/source/simplify.d.ts
 /**
 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.
 
@@ -1017,13 +401,13 @@ Useful to flatten the type output to improve type hints shown in editors. And al
 import type {Simplify} from 'type-fest';
 
 type PositionProps = {
-top: number;
-left: number;
+	top: number;
+	left: number;
 };
 
 type SizeProps = {
-width: number;
-height: number;
+	width: number;
+	height: number;
 };
 
 // In your editor, hovering over `Props` will show a flattened object with all the properties.
@@ -1039,15 +423,15 @@ If the type definition must be an interface (perhaps it was defined in a third-p
 import type {Simplify} from 'type-fest';
 
 interface SomeInterface {
-foo: number;
-bar?: string;
-baz: number | undefined;
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 }
 
 type SomeType = {
-foo: number;
-bar?: string;
-baz: number | undefined;
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 };
 
 const literal = {foo: 123, bar: 'hello', baz: 456};
@@ -1064,163 +448,11 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 
 @link https://github.com/microsoft/TypeScript/issues/15300
 @see SimplifyDeep
-
-@group type-fest
+@category Object
 */
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
-//#region src/types/type-fest/union-to-intersection.d.ts
-/**
-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}
-```
-
-@group type-fest
-*/
-type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
-//#endregion
-//#region src/types/type-fest/keys-of-union.d.ts
-/**
-Create a union of all keys from a given type, even those exclusive to specific union members.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-common: string;
-a: number;
-};
-
-type B = {
-common: string;
-b: string;
-};
-
-type C = {
-common: string;
-c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@group type-fest
-*/
-type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-//#endregion
-//#region src/types/type-fest/optional-keys-of.d.ts
-/**
-Extract all optional keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-interface User {
-name: string;
-surname: string;
-
-luckyNumber?: number;
-}
-
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
-};
-
-const update1: UpdateOperation<User> = {
-name: 'Alice'
-};
-
-const update2: UpdateOperation<User> = {
-name: 'Bob',
-luckyNumber: REMOVE_FIELD
-};
-```
-
-@group type-fest
-*/
-type OptionalKeysOf<BaseType extends object> = BaseType extends unknown ? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) : never;
-//#endregion
-//#region src/types/type-fest/required-keys-of.d.ts
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
-
-interface User {
-name: string;
-surname: string;
-
-luckyNumber?: number;
-}
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-```
-
-@group type-fest
-*/
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
-//#endregion
-//#region src/types/type-fest/omit-index-signature.d.ts
+//#region ../../node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -1246,13 +478,13 @@ Instead of causing a type error like the above, you can also use a [conditional
 
 ```
 type Indexed = {} extends Record<string, unknown>
-? '✅ `{}` is assignable to `Record<string, unknown>`'
-: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
 // => '✅ `{}` is assignable to `Record<string, unknown>`'
 
 type Keyed = {} extends Record<'foo' | 'bar', unknown>
-? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
-: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
 // => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
 ```
 
@@ -1262,8 +494,8 @@ Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-type
 import type {OmitIndexSignature} from 'type-fest';
 
 type OmitIndexSignature<ObjectType> = {
-[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
 };
 ```
 
@@ -1273,12 +505,12 @@ type OmitIndexSignature<ObjectType> = {
 import type {OmitIndexSignature} from 'type-fest';
 
 type OmitIndexSignature<ObjectType> = {
-[KeyType in keyof ObjectType
-// Is `{}` assignable to `Record<KeyType, unknown>`?
-as {} extends Record<KeyType, unknown>
-? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-]: ObjectType[KeyType];
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
 };
 ```
 
@@ -1289,19 +521,19 @@ If `{}` is assignable, it means that `KeyType` is an index signature and we want
 import type {OmitIndexSignature} from 'type-fest';
 
 interface Example {
-// These index signatures will be removed.
-[x: string]: any
-[x: number]: any
-[x: symbol]: any
-[x: `head-${string}`]: string
-[x: `${string}-tail`]: string
-[x: `head-${string}-tail`]: string
-[x: `${bigint}`]: string
-[x: `embedded-${number}`]: string
-
-// These explicitly defined keys will remain.
-foo: 'bar';
-qux?: 'baz';
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
 }
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
@@ -1309,12 +541,11 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 ```
 
 @see PickIndexSignature
-
-@group type-fest
+@category Object
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region src/types/type-fest/pick-index-signature.d.ts
+//#region ../../node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -1327,21 +558,21 @@ import type {PickIndexSignature} from 'type-fest';
 declare const symbolKey: unique symbol;
 
 type Example = {
-// These index signatures will remain.
-[x: string]: unknown;
-[x: number]: unknown;
-[x: symbol]: unknown;
-[x: `head-${string}`]: string;
-[x: `${string}-tail`]: string;
-[x: `head-${string}-tail`]: string;
-[x: `${bigint}`]: string;
-[x: `embedded-${number}`]: string;
-
-// These explicitly defined keys will be removed.
-['kebab-case-key']: string;
-[symbolKey]: string;
-foo: 'bar';
-qux?: 'baz';
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
 };
 
 type ExampleIndexSignature = PickIndexSignature<Example>;
@@ -1358,13 +589,14 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 ```
 
 @see OmitIndexSignature
-
-@group type-fest
+@category Object
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region src/types/type-fest/merge.d.ts
+//#region ../../node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
 type SimpleMerge<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
+
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
@@ -1373,17 +605,17 @@ Merge two types into a new type. Keys of the second type overrides keys of the f
 import type {Merge} from 'type-fest';
 
 interface Foo {
-[x: string]: unknown;
-[x: number]: unknown;
-foo: string;
-bar: symbol;
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
 }
 
 type Bar = {
-[x: number]: number;
-[x: symbol]: unknown;
-bar: Date;
-baz: boolean;
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
 };
 
 export type FooBar = Merge<Foo, Bar>;
@@ -1397,11 +629,11 @@ export type FooBar = Merge<Foo, Bar>;
 // }
 ```
 
-@group type-fest
+@category Object
 */
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region src/types/type-fest/if-any.d.ts
+//#region ../../node_modules/type-fest/source/if-any.d.ts
 /**
 An if-else-like type that resolves depending on whether the given type is `any`.
 
@@ -1418,50 +650,30 @@ type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
 //=> 'bar'
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 type IfAny$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
 //#endregion
-//#region src/types/type-fest/internal/type.d.ts
+//#region ../../node_modules/type-fest/source/internal/type.d.ts
 /**
-Returns a boolean for whether the given `boolean` is not `false`.
-
-@group type-fest
+Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
-type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+type BuiltIns = Primitive | void | Date | RegExp;
 /**
-Returns a boolean for whether the given type is primitive value or primitive type.
-
-@example
-```
-IsPrimitive<'string'>
-//=> true
-
-IsPrimitive<string>
-//=> true
+Test if the given function has multiple call signatures.
 
-IsPrimitive<Object>
-//=> false
-```
+Needed to handle the case of a single call signature with properties.
 
-@group type-fest
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
 */
-type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-/**
-Returns a boolean for whether A is false.
-
-@example
-```
-Not<true>;
-//=> false
-
-Not<false>;
-//=> true
-```
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
+// Should never happen
 
-@group type-fest
-*/
-type Not<A extends boolean> = A extends true ? false : A extends false ? true : never;
 /**
 An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
@@ -1479,12 +691,10 @@ type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 //=> 'IS_NEVER'
 ```
-
-@group type-fest
 */
 type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = IsAny<T> extends true ? IfAny : IsNever<T> extends true ? IfNever : IfNotAnyOrNever;
 //#endregion
-//#region src/types/type-fest/internal/object.d.ts
+//#region ../../node_modules/type-fest/source/internal/object.d.ts
 /**
 Works similar to the built-in `Pick` utility type, except for the following differences:
 - Distributes over union types and allows picking keys from any member of the union type.
@@ -1495,15 +705,15 @@ Works similar to the built-in `Pick` utility type, except for the following diff
 @example
 ```
 type ImageUpload = {
-url: string;
-size: number;
-thumbnailUrl: string;
+	url: string;
+	size: number;
+	thumbnailUrl: string;
 };
 
 type VideoUpload = {
-url: string;
-duration: number;
-encodingFormat: string;
+	url: string;
+	duration: number;
+	encodingFormat: string;
 };
 
 // Distributes over union types and allows picking keys from any member of the union type
@@ -1521,8 +731,6 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 // Doesn't pick `number` from a `string` index signature
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
-
-@group type-fest
 */
 type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
 /**
@@ -1576,12 +784,11 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 //                                                                   ~~~~~~~~~~~~~~~~
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
-
-@group type-fest
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1<SpecifiedOptions, Defaults, IfNever$1<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1<SpecifiedOptions, Defaults, IfNever$1<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+>>;
 //#endregion
-//#region src/types/type-fest/except.d.ts
+//#region ../../node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -1613,16 +820,15 @@ type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ?
 type ExceptOptions = {
   /**
   Disallow assigning non-specified properties.
-  
-  Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-  
-  @default false
+  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  	@default false
   */
   requireExactProps?: boolean;
 };
 type DefaultExceptOptions = {
   requireExactProps: false;
 };
+
 /**
 Create a type from an object type without certain keys.
 
@@ -1637,8 +843,8 @@ This type was proposed to the TypeScript team, which declined it, saying they pr
 import type {Except} from 'type-fest';
 
 type Foo = {
-a: number;
-b: string;
+	a: number;
+	b: string;
 };
 
 type FooWithoutA = Except<Foo, 'a'>;
@@ -1658,10 +864,10 @@ const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
 // Consider the following example:
 
 type UserData = {
-[metadata: string]: string;
-email: string;
-name: string;
-role: 'admin' | 'user';
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
 };
 
 // `Omit` clearly doesn't behave as expected in this case:
@@ -1674,38 +880,12 @@ type PostPayload = Except<UserData, 'email'>;
 //=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
 ```
 
-@group type-fest
+@category Object
 */
 type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options["requireExactProps"] extends true ? Partial<Record<KeysType, never>> : {});
-//#endregion
-//#region src/types/type-fest/override-properties.d.ts
-/**
-Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
-
-This is useful when you want to override existing properties with a different type and make sure that these properties really exist in the original.
-
-@example
-```
-type Foo = {
-a: string
-b: string
-}
-type Bar = OverrideProperties<Foo, {b: number}>
-//=> {a: string, b: number}
-
-type Baz = OverrideProperties<Foo, {c: number}>
-// Error, type '{ c: number; }' does not satisfy the constraint '{ c: never; }'
-
-type Fizz = OverrideProperties<Foo, {b: number; c: number}>
-// Error, type '{ b: number; c: number; }' does not satisfy the constraint '{ b: number; c: never; }'
-```
-
-@group type-fest
-*/
-type OverrideProperties<TOriginal, TOverride extends Partial<Record<keyof TOriginal, unknown>> & { [Key in keyof TOverride]: Key extends keyof TOriginal ? TOverride[Key] : never }> = Merge<TOriginal, TOverride>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 //#endregion
-//#region src/types/type-fest/require-at-least-one.d.ts
+//#region ../../node_modules/type-fest/source/require-at-least-one.d.ts
 /**
 Create a type that requires at least one of the given keys. The remaining keys are kept as is.
 
@@ -1714,60 +894,81 @@ Create a type that requires at least one of the given keys. The remaining keys a
 import type {RequireAtLeastOne} from 'type-fest';
 
 type Responder = {
-text?: () => string;
-json?: () => string;
-secure?: boolean;
+	text?: () => string;
+	json?: () => string;
+	secure?: boolean;
 };
 
 const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-json: () => '{"message": "ok"}',
-secure: true
+	json: () => '{"message": "ok"}',
+	secure: true
 };
 ```
 
-@group type-fest
+@category Object
 */
 type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1<KeysType, never, _RequireAtLeastOne<ObjectType, IfAny$1<KeysType, keyof ObjectType, KeysType>>>>;
-type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] & Except<ObjectType, KeysType>;
+type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = {
+  // For each `Key` in `KeysType` make a mapped type:
+[Key in KeysType]-?: Required<Pick<ObjectType, Key>> &
+// 1. Make `Key`'s type required
+// 2. Make all other keys in `KeysType` optional
+Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] &
+// 3. Add the remaining keys not in `KeysType`
+Except<ObjectType, KeysType>;
 //#endregion
-//#region src/types/type-fest/set-non-nullable.d.ts
-/**
-Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
+//#region ../../node_modules/type-fest/source/required-deep.d.ts
+type ExcludeUndefined<T> = Exclude<T, undefined>;
 
-If no keys are given, all keys will be made non-nullable.
+/**
+Create a type from another type with all keys and nested keys set to required.
 
-Use-case: You want to define a single model where the only thing that changes is whether or not some or all of the keys are non-nullable.
+Use-cases:
+- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
+- Modeling the resulting type after a deep merge with a set of defaults.
 
 @example
 ```
-import type {SetNonNullable} from 'type-fest';
-
-type Foo = {
-a: number | null;
-b: string | undefined;
-c?: boolean | null;
-}
+import type {RequiredDeep} from 'type-fest';
 
-type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
-// type SomeNonNullable = {
-// 	a: number | null;
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
+type Settings = {
+	textEditor?: {
+		fontSize?: number | undefined;
+		fontColor?: string | undefined;
+		fontWeight?: number | undefined;
+	}
+	autocomplete?: boolean | undefined;
+	autosave?: boolean | undefined;
+};
 
-type AllNonNullable = SetNonNullable<Foo>;
-// type AllNonNullable = {
-// 	a: number; // Can no longer be null.
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
+type RequiredSettings = RequiredDeep<Settings>;
+// type RequiredSettings = {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number;
+// 	}
+// 	autocomplete: boolean;
+// 	autosave: boolean;
 // }
 ```
 
-@group type-fest
+Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Utilities
+@category Object
+@category Array
+@category Set
+@category Map
 */
-type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> = { [Key in keyof BaseType]: Key extends Keys ? NonNullable<BaseType[Key]> : BaseType[Key] };
+type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns ? E : E extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : E extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : E extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : E extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : E extends ((...arguments_: any[]) => unknown) ? {} extends RequiredObjectDeep<E> ? E : HasMultipleCallSignatures<E> extends true ? E : ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E> : E extends object ? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+? ItemType[] extends E // Test for arrays (non-tuples) specifically
+? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
+: RequiredObjectDeep<E> // Tuples behave properly
+: RequiredObjectDeep<E> : unknown;
+type RequiredObjectDeep<ObjectType extends object> = { [KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]> };
 //#endregion
-//#region src/types/type-fest/set-optional.d.ts
+//#region ../../node_modules/type-fest/source/set-optional.d.ts
 /**
 Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
 
@@ -1778,9 +979,9 @@ Use-case: You want to define a single model where the only thing that changes is
 import type {SetOptional} from 'type-fest';
 
 type Foo = {
-a: number;
-b?: string;
-c: boolean;
+	a: number;
+	b?: string;
+	c: boolean;
 }
 
 type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
@@ -1791,11 +992,16 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 // }
 ```
 
-@group type-fest
+@category Object
 */
-type SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown ? Simplify<Except<BaseType, Keys> & Partial<HomomorphicPick<BaseType, Keys>>> : never;
+type SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
+? Simplify<
+// Pick just the keys that are readonly from the base type.
+Except<BaseType, Keys> &
+// Pick the keys that should be mutable from the base type and make them mutable.
+Partial<HomomorphicPick<BaseType, Keys>>> : never;
 //#endregion
-//#region src/types/type-fest/set-required.d.ts
+//#region ../../node_modules/type-fest/source/set-required.d.ts
 /**
 Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
 
@@ -1806,9 +1012,9 @@ Use-case: You want to define a single model where the only thing that changes is
 import type {SetRequired} from 'type-fest';
 
 type Foo = {
-a?: number;
-b: string;
-c?: boolean;
+	a?: number;
+	b: string;
+	c?: boolean;
 }
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
@@ -1823,60 +1029,27 @@ type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
 //=> [number, number, number?]
 ```
 
-@group type-fest
+@category Object
 */
-type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray> : never : Simplify<Except<BaseType, Keys> & Required<HomomorphicPick<BaseType, Keys>>>;
+type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray> : never : Simplify<
+// Pick just the keys that are optional from the base type.
+Except<BaseType, Keys> &
+// Pick the keys that should be required from the base type and make them required.
+Required<HomomorphicPick<BaseType, Keys>>>;
 /**
 Remove the optional modifier from the specified keys in an array.
 */
-type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown ? keyof TArray & `${number}` extends never ? [...Accumulator, ...TArray] : TArray extends readonly [(infer First)?, ...infer Rest] ? "0" extends OptionalKeysOf<TArray> ? `${Counter["length"]}` extends `${Keys & (string | number)}` ? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]> : [...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never : never;
-//#endregion
-//#region src/types/type-fest/writable.d.ts
-/**
-Create a writable version of the given array type.
-*/
-type WritableArray<ArrayType extends readonly unknown[]> = ArrayType extends readonly [] ? [] : ArrayType extends readonly [...infer U, infer V] ? [...U, V] : ArrayType extends readonly [infer U, ...infer V] ? [U, ...V] : ArrayType extends ReadonlyArray<infer U> ? U[] : ArrayType;
-/**
-Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
-
-The 2nd argument will be ignored if the input type is not an object.
-
-Note: This type can make readonly `Set` and `Map` writable. This behavior is different from `Readonly<T>` (as of TypeScript 5.2.2). See: https://github.com/microsoft/TypeScript/issues/29655
-
-This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
-
-@example
-```
-import type {Writable} from 'type-fest';
-
-type Foo = {
-readonly a: number;
-readonly b: readonly string[]; // To show that only the mutability status of the properties, not their values, are affected.
-readonly c: boolean;
-};
-
-const writableFoo: Writable<Foo> = {a: 1, b: ['2'], c: true};
-writableFoo.a = 3;
-writableFoo.b[0] = 'new value'; // Will still fail as the value of property "b" is still a readonly type.
-writableFoo.b = ['something']; // Will work as the "b" property itself is no longer readonly.
-
-type SomeWritable = Writable<Foo, 'b' | 'c'>;
-// type SomeWritable = {
-// 	readonly a: number;
-// 	b: readonly string[]; // It's now writable. The type of the property remains unaffected.
-// 	c: boolean; // It's now writable.
-// }
-
-// Also supports array
-const readonlyArray: readonly number[] = [1, 2, 3];
-readonlyArray.push(4); // Will fail as the array itself is readonly.
-const writableArray: Writable<typeof readonlyArray> = readonlyArray as Writable<typeof readonlyArray>;
-writableArray.push(4); // Will work as the array itself is now writable.
-```
-
-@group type-fest
-*/
-type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> = BaseType extends ReadonlyMap<infer KeyType, infer ValueType> ? Map<KeyType, ValueType> : BaseType extends ReadonlySet<infer ItemType> ? Set<ItemType> : BaseType extends readonly unknown[] ? WritableArray<BaseType> : Simplify<Except<BaseType, Keys> & { -readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType] }>;
+type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown // For distributing `TArray` when it's a union
+? keyof TArray & `${number}` extends never
+// Exit if `TArray` is empty (e.g., []), or
+// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+? [...Accumulator, ...TArray] : TArray extends readonly [(infer First)?, ...infer Rest] ? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
+? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
+? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
+// If the current element is optional, but it doesn't need to be required,
+// then we can exit early, since no further elements can now be made required.
+: [...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+: never; // Should never happen
 //#endregion
 //#region src/types/options.d.ts
 type StringUnionToFlexibleOptionArray<Op extends string> = Array<Op extends unknown ? FlexibleOption<Op> : never>;
@@ -2051,6 +1224,12 @@ interface CommonRuleAndGroupProperties {
   path?: Path;
   id?: string;
   disabled?: boolean;
+  /**
+  * Whether this rule or group is muted. When muted, the rule or group
+  * is excluded from query export formats (SQL, JSON, MongoDB, etc.).
+  * For groups, muting recursively mutes all children.
+  */
+  muted?: boolean;
 }
 /**
 * The main rule type. The `field`, `operator`, and `value` properties
@@ -3035,6 +2214,14 @@ interface Classnames {
   */
   lockGroup: Classname;
   /**
+  * Classnames applied to the `<button>` to mute a Rule.
+  */
+  muteRule: Classname;
+  /**
+  * Classnames applied to the `<button>` to mute a RuleGroup.
+  */
+  muteGroup: Classname;
+  /**
   * Classnames applied to the `<select>` control for value sources.
   */
   valueSource: Classname;
@@ -3086,6 +2273,10 @@ interface Classnames {
   */
   disabled: Classname;
   /**
+  * Classname(s) applied to muted elements.
+  */
+  muted: Classname;
+  /**
   * Classname(s) applied to each element in a series of value editors.
   */
   valueListItem: Classname;
@@ -3099,6 +2290,89 @@ interface Classnames {
   hasSubQuery: Classname;
 }
 /**
+* Placeholder strings for option lists.
+*
+* @group Props
+*/
+interface Placeholder {
+  /**
+  * Value for the placeholder field option if autoSelectField is false,
+  * or the placeholder operator option if autoSelectOperator is false.
+  */
+  placeholderName?: string;
+  /**
+  * Label for the placeholder field option if autoSelectField is false,
+  * or the placeholder operator option if autoSelectOperator is false.
+  */
+  placeholderLabel?: string;
+  /**
+  * Label for the placeholder field optgroup if autoSelectField is false,
+  * or the placeholder operator optgroup if autoSelectOperator is false.
+  */
+  placeholderGroupLabel?: string;
+}
+/**
+* A translation for a component with `title` only.
+*
+* @group Props
+*/
+interface BaseTranslation {
+  title?: string;
+}
+/**
+* A translation for a component with `title` and `label`.
+*
+* @group Props
+*/
+interface BaseTranslationWithLabel<LabelType = string> extends BaseTranslation {
+  label?: LabelType;
+}
+/**
+* A translation for a component with `title` and a placeholder.
+*
+* @group Props
+*/
+interface BaseTranslationWithPlaceholders extends BaseTranslation, Placeholder {}
+/**
+* The shape of the `translations` prop.
+*
+* @group Props
+*/
+interface BaseTranslations<LabelType = string> {
+  fields: BaseTranslationWithPlaceholders;
+  operators: BaseTranslationWithPlaceholders;
+  values: BaseTranslationWithPlaceholders;
+  matchMode: BaseTranslation;
+  matchThreshold: BaseTranslation;
+  value: BaseTranslation;
+  removeRule: BaseTranslationWithLabel<LabelType>;
+  removeGroup: BaseTranslationWithLabel<LabelType>;
+  addRule: BaseTranslationWithLabel<LabelType>;
+  addGroup: BaseTranslationWithLabel<LabelType>;
+  combinators: BaseTranslation;
+  notToggle: BaseTranslationWithLabel<LabelType>;
+  cloneRule: BaseTranslationWithLabel<LabelType>;
+  cloneRuleGroup: BaseTranslationWithLabel<LabelType>;
+  shiftActionUp: BaseTranslationWithLabel<LabelType>;
+  shiftActionDown: BaseTranslationWithLabel<LabelType>;
+  dragHandle: BaseTranslationWithLabel<LabelType>;
+  lockRule: BaseTranslationWithLabel<LabelType>;
+  lockGroup: BaseTranslationWithLabel<LabelType>;
+  lockRuleDisabled: BaseTranslationWithLabel<LabelType>;
+  lockGroupDisabled: BaseTranslationWithLabel<LabelType>;
+  muteRule: BaseTranslationWithLabel<LabelType>;
+  muteGroup: BaseTranslationWithLabel<LabelType>;
+  unmuteRule: BaseTranslationWithLabel<LabelType>;
+  unmuteGroup: BaseTranslationWithLabel<LabelType>;
+  valueSourceSelector: BaseTranslation;
+}
+/**
+* The full `translations` interface with all properties required.
+*
+* @group Props
+*/
+type BaseTranslationsFull<LabelType = string> = RequiredDeep<BaseTranslations<LabelType>>;
+/**
 * Functions included in the `actions` prop passed to every subcomponent.
 *
 * @group Props
@@ -3177,6 +2451,12 @@ declare const defaultPlaceholderValueLabel: typeof defaultPlaceholderLabel;
 */
 declare const defaultPlaceholderValueGroupLabel: typeof defaultPlaceholderLabel;
 /**
+* Default configuration of translatable strings.
+*
+* @group Defaults
+*/
+declare const defaultTranslations: BaseTranslationsFull;
+/**
 * Default character used to `.join` and `.split` arrays.
 *
 * @group Defaults
@@ -3253,8 +2533,11 @@ declare const standardClassnames: {
   readonly dndDropNotAllowed: "dndDropNotAllowed";
   readonly dragHandle: "queryBuilder-dragHandle";
   readonly disabled: "queryBuilder-disabled";
+  readonly muted: "queryBuilder-muted";
   readonly lockRule: "rule-lock";
   readonly lockGroup: "ruleGroup-lock";
+  readonly muteRule: "rule-mute";
+  readonly muteGroup: "ruleGroup-mute";
   readonly valueSource: "rule-valueSource";
   readonly valueListItem: "rule-value-list-item";
   readonly branches: "queryBuilder-branches";
@@ -3301,6 +2584,8 @@ declare const TestID: {
   readonly dragHandle: "drag-handle";
   readonly lockRule: "lock-rule";
   readonly lockGroup: "lock-group";
+  readonly muteRule: "mute-rule";
+  readonly muteGroup: "mute-group";
   readonly valueSourceSelector: "value-source-selector";
   readonly matchModeEditor: "match-mode-editor";
 };
@@ -4183,10 +3468,18 @@ declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
 declare const isValidationResult: (vr?: ValidationResult) => vr is ValidationResult;
 /**
 * Determines if a rule or group is valid based on a validation result (if defined)
-* or a validator function. Returns `true` if neither are defined.
+* or a validator function. Returns `true` if neither are defined and the `muted`
+* property is not `true`.
 */
 declare const isRuleOrGroupValid: (rg: RuleType | RuleGroupTypeAny, validationResult?: boolean | ValidationResult, validator?: RuleValidator) => boolean;
 //#endregion
+//#region src/utils/mergeAnyTranslations.d.ts
+/**
+* Merges any number of partial translations into a single definition.
+*/
+declare const mergeAnyTranslations: (base: Record<string, Record<string, unknown>>, ...otherTranslations: (Record<string, Record<string, unknown>> | undefined)[]) => Record<string, Record<string, unknown>>;
+declare const mergeAnyTranslation: (el: string, keyPropContextMap: Record<string, [unknown, unknown]>, defaults?: Record<string, Record<string, unknown>>) => Record<string, Record<string, unknown>> | undefined;
+//#endregion
 //#region src/utils/mergeClassnames.d.ts
 type MergeClassnamesParams = (Partial<Classnames> | undefined)[];
 /**
@@ -4354,6 +3647,19 @@ declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptio
 * @group Option Lists
 */
 declare const uniqOptList: <T extends BaseOption>(originalArray: FlexibleOptionList<T>) => WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[];
+interface PreparedOptionList<O extends FullOption> {
+  defaultOption: FullOption;
+  optionList: O[] | OptionGroup<O>[];
+  optionsMap: Partial<FullOptionRecord<FullOption>>;
+}
+interface PrepareOptionListParams<O extends FullOption> {
+  placeholder?: Placeholder;
+  optionList?: FlexibleOptionListProp<O> | BaseOptionMap<O>;
+  baseOption?: Record<string, unknown>;
+  labelMap?: Record<string, string>;
+  autoSelectOption?: boolean;
+}
+declare const prepareOptionList: <O extends FullOption>(props: PrepareOptionListParams<O>) => PreparedOptionList<O>;
 //#endregion
 //#region src/utils/parseNumber.d.ts
 /**
@@ -4793,5 +4099,5 @@ declare function transformQuery(query: RuleGroupType, options?: TransformQueryOp
 */
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
-export { AccessibleDescriptionGenerator, ActionElementEventHandler, AddOptions, And, Arity, BaseFullOption, BaseOption, BaseOptionMap, Classname, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DndDropTargetType, DragCollection, DraggedItem, DropCollection, DropEffect, DropResult, Except, ExportFormat, ExportObjectFormats, ExportOperatorMap, Field, FieldByValue, FindPathReturnType, Finite, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, Float, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GreaterThan, GreaterThanOrEqual, GroupOptions, GroupVariantCondition, IfAny$1 as IfAny, IfNever$1 as IfNever, InputType, InsertOptions, Integer, IsAny, IsBooleanLiteral, IsEqual, IsFloat, IsInteger, IsLiteral, IsNegative, IsNever, IsNumericLiteral, IsStringLiteral, IsSymbolLiteral, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, KeysOfUnion, LessThan, LogType, MatchConfig, MatchMode, MatchModeOptions, Merge, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Negative, NegativeFloat, NegativeInfinity, NegativeInteger, NonNegative, NonNegativeInteger, Numeric, OmitIndexSignature, Operator, OperatorByValue, Option, OptionGroup, OptionList, OptionalKeysOf, Or, OverrideProperties, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, PickIndexSignature, PositiveInfinity, PreparerOptions, Primitive, QueryActions, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveNullability, RequireAtLeastOne, RequiredKeysOf, RuleGroupArray, RuleGroupICArray, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, SetNonNullable, SetOptional, SetRequired, Simplify, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, TestID, ToFlexibleOption, ToFullOption, TransformQueryOptions, Trim, UnionToIntersection, UnknownArray, UpdateOptions, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WithRequired, WithUnknownIndex, Writable, Zero, add, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getValidationClassNames, getValueSourcesUtil, group, groupInvalidReasons, insert, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeClassnames, mongoDbFallback, mongoOperators, move, normalizeConstituentWordOrder, nullFreeArray, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, regenerateID, regenerateIDs, remove, rootPath, shouldRenderAsNumber, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update };
+export { AccessibleDescriptionGenerator, ActionElementEventHandler, AddOptions, Arity, BaseFullOption, BaseOption, BaseOptionMap, BaseTranslation, BaseTranslationWithLabel, BaseTranslationWithPlaceholders, BaseTranslations, BaseTranslationsFull, Classname, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DndDropTargetType, DragCollection, DraggedItem, DropCollection, DropEffect, DropResult, ExportFormat, ExportObjectFormats, ExportOperatorMap, Field, FieldByValue, FindPathReturnType, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GroupOptions, GroupVariantCondition, InputType, InsertOptions, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, LogType, MatchConfig, MatchMode, MatchModeOptions, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Operator, OperatorByValue, Option, OptionGroup, OptionList, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, Placeholder, PrepareOptionListParams, PreparedOptionList, PreparerOptions, QueryActions, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveNullability, RuleGroupArray, RuleGroupICArray, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, TestID, ToFlexibleOption, ToFullOption, TransformQueryOptions, UpdateOptions, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WithRequired, WithUnknownIndex, add, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getValidationClassNames, getValueSourcesUtil, group, groupInvalidReasons, insert, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, normalizeConstituentWordOrder, nullFreeArray, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, regenerateID, regenerateIDs, remove, rootPath, shouldRenderAsNumber, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update };
 //# sourceMappingURL=react-querybuilder_core.d.mts.map