@react-querybuilder/core 8.9.2 → 8.11.0

package/dist/cjs/react-querybuilder_core.cjs.production.d.ts

@@ -2,1013 +2,433 @@ 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
-
-/**
-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;
-```
-
-@group type-fest
-*/
-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/and.d.ts
-/**
-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}
-
-@group type-fest
-*/
-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;
-//#endregion
-//#region src/types/type-fest/is-never.d.ts
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-And<
-IsNever<Exclude<A, B>> extends true ? true : false,
-IsNever<Exclude<B, A>> extends true ? true : false
->;
-
-type EndIfEqual<I extends string, O extends string> =
-AreStringsEqual<I, O> extends true
-? never
-: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-if (input === output) {
-process.exit(0);
-}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@group type-fest
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-//#endregion
-//#region src/types/type-fest/if-never.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `never`.
-
-@see {@link IsNever}
-
-@example
-```
-import type {IfNever} from 'type-fest';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
-
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@group type-fest
-*/
-type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
-//#endregion
-//#region src/types/type-fest/unknown-array.d.ts
-/**
-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
-```
-
-@group type-fest
-*/
-type UnknownArray = readonly unknown[];
-//#endregion
-//#region src/types/type-fest/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>;
-/**
-An if-else-like type that resolves depending on whether the given array is readonly.
-
-@see {@link IsArrayReadonly}
-
-@example
-```
-import type {ArrayTail} from 'type-fest';
-
-type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-ArrayTail<TArray> extends infer Tail
-? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-: never;
-
-type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
-//=> readonly [number, boolean]
-
-type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
-//=> [number, boolean]
-
-type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
-//=> true
-
-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
-type NoInfer<T> = T extends infer U ? U : never;
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-return obj[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@group type-fest
-*/
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-//#endregion
-//#region src/types/type-fest/primitive.d.ts
+//#region ../../node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
-@group type-fest
+@category Type
 */
 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
+//#region ../../node_modules/type-fest/source/union-to-intersection.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
+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).
 
-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`.
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
 
 @example
 ```
-LiteralChecks<1, Numeric>
-//=> true
+import type {UnionToIntersection} from 'type-fest';
 
-LiteralChecks<1n, Numeric>
-//=> true
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
 
-LiteralChecks<bigint, Numeric>
-//=> false
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
 ```
-*/
-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).
+A more applicable example which could make its way into your library code follows.
 
 @example
 ```
-import type {IsStringLiteral} from 'type-fest';
-
-type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
+import type {UnionToIntersection} from 'type-fest';
 
-// 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>;
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
 }
 
-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>;
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
 }
 
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123456, '456');
-//=> true
-
-const end = '123' as string;
+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}
 
-endsWith('abc123', end);
-//=> boolean
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
 ```
 
-@group type-fest
-*/
-type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
+@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 ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+? Intersection & Union : never;
+//#endregion
+//#region ../../node_modules/type-fest/source/keys-of-union.d.ts
 /**
-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).
+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.
 
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
+@link https://stackoverflow.com/a/49402091
 
 @example
 ```
-import type {IsBooleanLiteral} from 'type-fest';
+import type {KeysOfUnion} from 'type-fest';
 
-const id = 123;
+type A = {
+	common: string;
+	a: number;
+};
 
-type GetId<AsString extends boolean> =
-IsBooleanLiteral<AsString> extends true
-? AsString extends true
-? `${typeof id}`
-: typeof id
-: number | string;
+type B = {
+	common: string;
+	b: string;
+};
 
-function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
-return (options?.asString ? `${id}` : id) as GetId<AsString>;
-}
+type C = {
+	common: string;
+	c: boolean;
+};
 
-const numberId = getId();
-//=> 123
+type Union = A | B | C;
 
-const stringId = getId({asString: true});
-//=> '123'
+type CommonKeys = keyof Union;
+//=> 'common'
 
-declare const runtimeBoolean: boolean;
-const eitherId = getId({asString: runtimeBoolean});
-//=> number | string
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
 ```
 
-@group type-fest
+@category Object
 */
-type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
+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 ../../node_modules/type-fest/source/is-any.d.ts
 /**
-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).
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
 
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
 
 @example
 ```
-import type {IsSymbolLiteral} from 'type-fest';
+import type {IsAny} from 'type-fest';
 
-type Get<Obj extends Record<symbol, number>, Key extends keyof Obj> =
-IsSymbolLiteral<Key> extends true
-? Obj[Key]
-: number;
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
 
-function get<Obj extends Record<symbol, number>, Key extends keyof Obj>(o: Obj, key: Key) {
-return o[key] as Get<Obj, Key>;
+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 symbolLiteral = Symbol('literal');
-const symbolValue: symbol = Symbol('value');
-
-get({[symbolLiteral]: 1} as const, symbolLiteral);
+const typedA = get(typedObject, 'a');
 //=> 1
 
-get({[symbolValue]: 1} as const, symbolValue);
-//=> number
+const anyA = get(anyObject, 'a');
+//=> any
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
-/** Helper type for `IsLiteral`. */
-type IsLiteralUnion<T> = IsStringLiteral<T> | IsNumericLiteral<T> | IsBooleanLiteral<T> | IsSymbolLiteral<T>;
+type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
+//#endregion
+//#region ../../node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
-Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+Returns a boolean for whether the given key is an optional key of type.
 
-Useful for:
-- providing strongly-typed functions when given literal arguments
-- type utilities, such as when constructing parsers and ASTs
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
 
 @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>;
+import type {IsOptionalKeyOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
 }
 
-stripLeading('abc123', 'abc');
-//=> '123'
+interface Admin {
+	name: string;
+	surname?: string;
+}
 
-const str = 'abc123' as string;
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
 
-stripLeading(str, 'abc');
-//=> string
-```
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
 
-@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.
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
 
-@example
-```
-import type {Trim} from 'type-fest';
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
 
-Trim<' foo '>
-//=> 'foo'
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+type IsOptionalKeyOf<Type$1 extends object, Key$1 extends keyof Type$1> = IsAny<Type$1 | Key$1> extends true ? never : Key$1 extends keyof Type$1 ? Type$1 extends Record<Key$1, Type$1[Key$1]> ? false : true : false;
 //#endregion
-//#region src/types/type-fest/or.d.ts
+//#region ../../node_modules/type-fest/source/optional-keys-of.d.ts
 /**
-Returns a boolean for whether either of two given types are 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 {Or} from 'type-fest';
-
-Or<true, false>;
-//=> true
-
-Or<false, false>;
-//=> false
-```
-
-@see {@link And}
+import type {OptionalKeysOf, Except} from 'type-fest';
 
-@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.
+interface User {
+	name: string;
+	surname: string;
 
-@example
-```
-import type {GreaterThan} from 'type-fest';
+	luckyNumber?: number;
+}
 
-GreaterThan<1, -5>;
-//=> true
+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;
+};
 
-GreaterThan<1, 1>;
-//=> false
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
 
-GreaterThan<1, 5>;
-//=> false
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
 ```
 
-@group type-fest
+@category Utilities
 */
-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;
+type OptionalKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type$1 as IsOptionalKeyOf<Type$1, Key> extends false ? never : Key]: never }) & keyof Type$1 // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
 //#endregion
-//#region src/types/type-fest/greater-than-or-equal.d.ts
+//#region ../../node_modules/type-fest/source/required-keys-of.d.ts
 /**
-Returns a boolean for whether a given number is greater than or equal to another number.
+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 {GreaterThanOrEqual} from 'type-fest';
+import type {RequiredKeysOf} from 'type-fest';
 
-GreaterThanOrEqual<1, -5>;
-//=> true
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
 
-GreaterThanOrEqual<1, 1>;
-//=> true
+interface User {
+	name: string;
+	surname: string;
 
-GreaterThanOrEqual<1, 5>;
-//=> false
+	luckyNumber?: number;
+}
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
 ```
 
-@group type-fest
+@category Utilities
 */
-type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B ? never : A extends B ? true : GreaterThan<A, B>;
+type RequiredKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
+? Exclude<keyof Type$1, OptionalKeysOf<Type$1>> : never;
 //#endregion
-//#region src/types/type-fest/less-than.d.ts
+//#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
-Returns a boolean for whether a given number is less than another number.
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
 
 @example
 ```
-import type {LessThan} from 'type-fest';
+import type {IsNever, And} from 'type-fest';
 
-LessThan<1, -5>;
-//=> false
+// 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
+	>;
 
-LessThan<1, 1>;
-//=> false
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
 
-LessThan<1, 5>;
-//=> true
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-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;
+type IsNever<T$1> = [T$1] extends [never] ? true : false;
 //#endregion
-//#region src/types/type-fest/internal/tuple.d.ts
+//#region ../../node_modules/type-fest/source/if.d.ts
 /**
-Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 
-If `<Fill>` is not provided, it will default to `unknown`.
-
-@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
 
-@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.
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
 
 @example
 ```
-type PositiveInt = StringToNumber<'1234'>;
-//=> 1234
+import {If} from 'type-fest';
 
-type NegativeInt = StringToNumber<'-1234'>;
-//=> -1234
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-type PositiveFloat = StringToNumber<'1234.56'>;
-//=> 1234.56
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
 
-type NegativeFloat = StringToNumber<'-1234.56'>;
-//=> -1234.56
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-type PositiveInfinity = StringToNumber<'Infinity'>;
-//=> Infinity
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-type NegativeInfinity = StringToNumber<'-Infinity'>;
-//=> -Infinity
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
 ```
 
-@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']
+import {If, IsAny, IsNever} from 'type-fest';
 
-StringToArray<string>;
-//=> never
-```
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
 
-@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.
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
 
 @example
 ```
-StringLength<'abcde'>;
-//=> 5
+import {If, IsEqual} from 'type-fest';
 
-StringLength<string>;
-//=> never
-```
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
-@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.
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
 
-@example
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
 ```
-SameLengthPositiveNumericStringGt<'50', '10'>;
-//=> true
 
-SameLengthPositiveNumericStringGt<'10', '10'>;
-//=> false
-```
+@category Type Guard
+@category Utilities
 */
-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";
+type If<Type$1 extends boolean, IfBranch, ElseBranch> = IsNever<Type$1> extends true ? ElseBranch : Type$1 extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/type-fest/source/unknown-array.d.ts
 /**
-Returns a boolean for whether `A` is greater than `B`, where `A` and `B` are both positive numeric strings.
+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
 ```
-PositiveNumericStringGt<'500', '1'>;
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
 //=> true
 
-PositiveNumericStringGt<'1', '1'>;
-//=> false
+type B = IsArray<readonly number[]>;
+//=> true
 
-PositiveNumericStringGt<'1', '500'>;
+type C = IsArray<string>;
 //=> false
 ```
 
-@group type-fest
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../../node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
-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;
+type BuiltIns = Primitive | void | Date | RegExp;
 /**
-Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both positive numeric characters.
+Test if the given function has multiple call signatures.
 
-@example
-```
-PositiveNumericCharacterGt<'5', '1'>;
-//=> true
+Needed to handle the case of a single call signature with properties.
 
-PositiveNumericCharacterGt<'1', '1'>;
-//=> false
-```
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
 */
-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;
-//#endregion
-//#region src/types/type-fest/internal/numeric.d.ts
+type HasMultipleCallSignatures<T$1 extends (...arguments_: any[]) => unknown> = T$1 extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
 /**
-Returns the absolute value of a given value.
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
 @example
 ```
-NumberAbsolute<-1>;
-//=> 1
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
 
-NumberAbsolute<1>;
-//=> 1
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
 
-NumberAbsolute<NegativeInfinity>
-//=> PositiveInfinity
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
 ```
-
-@group type-fest
 */
-type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
+type IfNotAnyOrNever<T$1, IfNotAnyOrNever$1, IfAny = any, IfNever = never> = If<IsAny<T$1>, IfAny, If<IsNever<T$1>, IfNever, IfNotAnyOrNever$1>>;
+//#endregion
+//#region ../../node_modules/type-fest/source/internal/array.d.ts
+/**
+Returns whether the given array `T` is readonly.
+*/
+type IsArrayReadonly<T$1 extends UnknownArray> = If<IsNever<T$1>, false, T$1 extends unknown[] ? false : true>;
 //#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 +437,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 +459,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 +484,42 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 
 @link https://github.com/microsoft/TypeScript/issues/15300
 @see SimplifyDeep
-
-@group type-fest
-*/
-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
+@category Object
 */
-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;
+type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
 //#endregion
-//#region src/types/type-fest/required-keys-of.d.ts
+//#region ../../node_modules/type-fest/source/is-equal.d.ts
 /**
-Extract all required keys from the given type.
+Returns a boolean for whether the two given types are equal.
 
-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...
+@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 {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;
-}
+import type {IsEqual} from 'type-fest';
 
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
+// 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 RequiredKeysOf<BaseType extends object> = BaseType extends unknown ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+type IsEqual<A$1, B$1> = [A$1, B$1] extends [infer AA, infer BB] ? [AA] extends [never] ? [BB] extends [never] ? true : false : [BB] extends [never] ? false : _IsEqual<AA, BB> : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A$1, B$1> = (<G>() => G extends A$1 & G | G ? 1 : 2) extends (<G>() => G extends B$1 & G | G ? 1 : 2) ? true : false;
 //#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 +545,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 +561,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 +572,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 +588,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 +608,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 +625,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 +656,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 +672,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,94 +696,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
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@group type-fest
-*/
-type IfAny$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-//#endregion
-//#region src/types/type-fest/internal/type.d.ts
-/**
-Returns a boolean for whether the given `boolean` is not `false`.
-
-@group type-fest
-*/
-type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
-/**
-Returns a boolean for whether the given type is primitive value or primitive type.
-
-@example
-```
-IsPrimitive<'string'>
-//=> true
-
-IsPrimitive<string>
-//=> true
-
-IsPrimitive<Object>
-//=> false
-```
-
-@group type-fest
-*/
-type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-/**
-Returns a boolean for whether A is false.
-
-@example
-```
-Not<true>;
-//=> false
-
-Not<false>;
-//=> true
-```
-
-@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`.
-
-@example
-```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'VALID'
-
-// When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_ANY'
-
-// When `T` is `never` => Returns `IfNever` branch
-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 +711,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,10 +737,8 @@ 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] };
+type HomomorphicPick<T$1, Keys extends KeysOfUnion<T$1>> = { [P in keyof T$1 as Extract<P, Keys>]: T$1[P] };
 /**
 Merges user specified options with default options.
 
@@ -1576,12 +790,10 @@ 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> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
 //#endregion
-//#region src/types/type-fest/except.d.ts
+//#region ../../node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -1609,20 +821,19 @@ type Filtered = Filter<'bar', 'foo'>;
 
 @see {Except}
 */
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type Filter<KeyType$1, ExcludeType> = IsEqual<KeyType$1, ExcludeType> extends true ? never : (KeyType$1 extends ExcludeType ? never : KeyType$1);
 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 +848,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 +869,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 +885,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 +899,75 @@ 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 = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, _RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof 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
+//#region ../../node_modules/type-fest/source/required-deep.d.ts
 /**
-Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
+Create a type from another type with all keys and nested keys set to required.
 
-If no keys are given, all keys will be made non-nullable.
-
-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';
+import type {RequiredDeep} from 'type-fest';
 
-type Foo = {
-a: number | null;
-b: string | undefined;
-c?: boolean | null;
-}
-
-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;
+		fontColor?: string;
+		fontWeight?: number | undefined;
+	};
+	autocomplete?: boolean;
+	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>;
+//=> {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number | undefined;
+// 	};
+// 	autocomplete: boolean;
+// 	autosave: boolean | undefined;
 // }
 ```
 
-@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$1> = T$1 extends BuiltIns ? T$1 : T$1 extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T$1 extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T$1 extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T$1 extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T$1 extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T$1> extends true ? T$1 : HasMultipleCallSignatures<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & RequiredObjectDeep<T$1> : T$1 extends object ? RequiredObjectDeep<T$1> : 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 +978,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 +991,17 @@ 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 ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
+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,62 +1029,32 @@ 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 ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<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 RequireAtLeastOne$1<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] & Except<ObjectType, KeysType>;
 type StringUnionToFlexibleOptionArray<Op extends string> = Array<Op extends unknown ? FlexibleOption<Op> : never>;
 type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown ? FullOption<Op> : never>;
 /**
@@ -1886,18 +1062,18 @@ type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown
 *
 * @group Option Lists
 */
-type GetOptionType<OL extends FlexibleOptionList<FullOption>> = OL extends FlexibleOptionList<infer Opt> ? Opt : never;
+type GetOptionType<OL$1 extends FlexibleOptionList<FullOption>> = OL$1 extends FlexibleOptionList<infer Opt> ? Opt : never;
 /**
 * Extracts the type of the identifying property from a {@link Option},
 * {@link ValueOption}, or {@link FullOption}.
 *
 * @group Option Lists
 */
-type GetOptionIdentifierType<Opt extends BaseOption> = Opt extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
+type GetOptionIdentifierType<Opt$1 extends BaseOption> = Opt$1 extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
 /**
 * Adds an `unknown` index property to an interface.
 */
-type WithUnknownIndex<T> = T & {
+type WithUnknownIndex<T$1> = T$1 & {
   [key: string]: unknown;
 };
 /**
@@ -1929,24 +1105,24 @@ type Option<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<B
 type ValueOption<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<BaseOption<N>, "value">>>;
 /**
 * A generic {@link Option} with either a `name` or `value` as its primary identifier.
-* {@link OptionList}-type props on the {@link QueryBuilder} component accept this type,
-* but corresponding props passed down to subcomponents will always be translated
+* {@link OptionList}-type props on the {@link react-querybuilder!QueryBuilder QueryBuilder} component accept this type,
+* but corresponding props passed down to subcomponents will always be augmented
 * to {@link FullOption} first.
 *
 * @group Option Lists
 */
-type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<RequireAtLeastOne<BaseOption<N>, "name" | "value">>>;
+type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<RequireAtLeastOne$1<BaseOption<N>, "name" | "value">>>;
 /**
 * Utility type to turn an {@link Option}, {@link ValueOption}, or {@link BaseOption}
 * into a {@link FlexibleOption}.
 *
 * @group Option Lists
 */
-type ToFlexibleOption<Opt extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt extends string ? FlexibleOption<Opt> : Opt, "name" | "value">>;
+type ToFlexibleOption<Opt$1 extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne$1<Opt$1 extends string ? FlexibleOption<Opt$1> : Opt$1, "name" | "value">>;
 /**
 * A generic {@link Option} requiring both `name` _and_ `value` properties.
 * Props that extend {@link OptionList} accept {@link BaseOption}, but
-* corresponding props sent to subcomponents will always be translated to this
+* corresponding props sent to subcomponents will always be augmented to this
 * type first to ensure both `name` and `value` are available.
 *
 * NOTE: Do not extend from this type directly. Use {@link BaseFullOption}
@@ -1970,7 +1146,7 @@ type BaseFullOption<N extends string = string> = Simplify<SetRequired<BaseOption
 *
 * @group Option Lists
 */
-type ToFullOption<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt : Opt extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt & FullOption<IdentifierType>> : never;
+type ToFullOption<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1 : Opt$1 extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt$1 & FullOption<IdentifierType>> : never;
 /**
 * @deprecated Renamed to {@link Option}.
 *
@@ -1982,39 +1158,39 @@ type NameLabelPair<N extends string = string> = Option<N>;
 *
 * @group Option Lists
 */
-interface OptionGroup<Opt extends BaseOption = FlexibleOption> {
+interface OptionGroup<Opt$1 extends BaseOption = FlexibleOption> {
   label: string;
-  options: WithUnknownIndex<Opt>[];
+  options: WithUnknownIndex<Opt$1>[];
 }
 /**
 * A group of {@link BaseOption}s, usually within a {@link FlexibleOptionList}.
 *
 * @group Option Lists
 */
-type FlexibleOptionGroup<Opt extends BaseOption | string = BaseOption> = {
+type FlexibleOptionGroup<Opt$1 extends BaseOption | string = BaseOption> = {
   label: string;
-  options: (Opt extends BaseFullOption ? Opt : ToFlexibleOption<Opt>)[];
+  options: (Opt$1 extends BaseFullOption ? Opt$1 : ToFlexibleOption<Opt$1>)[];
 };
 /**
 * Either an array of {@link Option}s or an array of {@link OptionGroup}s.
 *
 * @group Option Lists
 */
-type OptionList<Opt extends Option = Option> = Opt[] | OptionGroup<Opt>[];
+type OptionList<Opt$1 extends Option = Option> = Opt$1[] | OptionGroup<Opt$1>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionList<Opt extends BaseOption> = ToFlexibleOption<Opt>[] | FlexibleOptionGroup<ToFlexibleOption<Opt>>[];
+type FlexibleOptionList<Opt$1 extends BaseOption> = ToFlexibleOption<Opt$1>[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1>>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>>[];
+type FlexibleOptionListProp<Opt$1 extends BaseOption> = (ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>>[];
 /**
 * An array of options or option groups, like {@link OptionList}, but using
 * {@link FullOption} instead of {@link Option}. This means that every member is
@@ -2022,26 +1198,26 @@ type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | G
 *
 * @group Option Lists
 */
-type FullOptionList<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt[] | OptionGroup<Opt>[] : ToFullOption<Opt>[] | OptionGroup<ToFullOption<Opt>>[];
+type FullOptionList<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1[] | OptionGroup<Opt$1>[] : ToFullOption<Opt$1>[] | OptionGroup<ToFullOption<Opt$1>>[];
 /**
 * Map of option identifiers to their respective {@link Option}.
 *
 * @group Option Lists
 */
-type BaseOptionMap<V extends BaseOption = BaseOption, K extends string = GetOptionIdentifierType<V>> = { [k in K]?: ToFlexibleOption<V> };
+type BaseOptionMap<V$1 extends BaseOption = BaseOption, K$1 extends string = GetOptionIdentifierType<V$1>> = { [k in K$1]?: ToFlexibleOption<V$1> };
 /**
 * Map of option identifiers to their respective {@link FullOption}.
 *
 * @group Option Lists
 */
-type FullOptionMap<V extends BaseFullOption, K extends string = GetOptionIdentifierType<V>> = { [k in K]?: V };
+type FullOptionMap<V$1 extends BaseFullOption, K$1 extends string = GetOptionIdentifierType<V$1>> = { [k in K$1]?: V$1 };
 /**
 * Map of option identifiers to their respective {@link FullOption}.
 * Must include all possible strings from the identifier type.
 *
 * @group Option Lists
 */
-type FullOptionRecord<V extends BaseFullOption, K extends string = GetOptionIdentifierType<V>> = Record<K, V>;
+type FullOptionRecord<V$1 extends BaseFullOption, K$1 extends string = GetOptionIdentifierType<V$1>> = Record<K$1, V$1>;
 //#endregion
 //#region src/types/ruleGroups.d.ts
 /**
@@ -2051,15 +1227,21 @@ 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
 * can be narrowed with generics.
 */
-interface RuleType<F extends string = string, O extends string = string, V = any, C extends string = string> extends CommonRuleAndGroupProperties {
-  field: F;
-  operator: O;
-  value: V;
+interface RuleType<F$1 extends string = string, O$1 extends string = string, V$1 = any, C extends string = string> extends CommonRuleAndGroupProperties {
+  field: F$1;
+  operator: O$1;
+  value: V$1;
   valueSource?: ValueSource;
   match?: MatchConfig;
   /**
@@ -2071,15 +1253,15 @@ interface RuleType<F extends string = string, O extends string = string, V = any
 * The main rule group type. This type is used for query definitions as well as
 * all sub-groups of queries.
 */
-interface RuleGroupType<R extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
+interface RuleGroupType<R$1 extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
   combinator: C;
-  rules: RuleGroupArray<RuleGroupType<R, C>, R>;
+  rules: RuleGroupArray<RuleGroupType<R$1, C>, R$1>;
   not?: boolean;
 }
 /**
 * The type of the `rules` array in a {@link RuleGroupType}.
 */
-type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType = RuleType> = (R | RG)[];
+type RuleGroupArray<RG$1 extends RuleGroupType = RuleGroupType, R$1 extends RuleType = RuleType> = (R$1 | RG$1)[];
 /**
 * All updateable properties of rules and groups (everything except
 * `id`, `path`, and `rules`).
@@ -2088,18 +1270,18 @@ type UpdateableProperties = Exclude<keyof (RuleType & RuleGroupType), "id" | "pa
 /**
 * The type of the `rules` array in a {@link DefaultRuleGroupType}.
 */
-type DefaultRuleGroupArray<F extends string = string> = RuleGroupArray<DefaultRuleGroupType, DefaultRuleType<F>>;
+type DefaultRuleGroupArray<F$1 extends string = string> = RuleGroupArray<DefaultRuleGroupType, DefaultRuleType<F$1>>;
 /**
 * {@link RuleGroupType} with the `combinator` property limited to
 * {@link DefaultCombinatorNameExtended} and `rules` limited to {@link DefaultRuleType}.
 */
-type DefaultRuleGroupType<F extends string = string> = RuleGroupType<DefaultRuleType<F>, DefaultCombinatorNameExtended> & {
-  rules: DefaultRuleGroupArray<F>;
+type DefaultRuleGroupType<F$1 extends string = string> = RuleGroupType<DefaultRuleType<F$1>, DefaultCombinatorNameExtended> & {
+  rules: DefaultRuleGroupArray<F$1>;
 };
 /**
 * {@link RuleType} with the `operator` property limited to {@link DefaultOperatorName}.
 */
-type DefaultRuleType<F extends string = string> = RuleType<F, DefaultOperatorName>;
+type DefaultRuleType<F$1 extends string = string> = RuleType<F$1, DefaultOperatorName>;
 /**
 * Default allowed values for the `combinator` property.
 *
@@ -2146,9 +1328,9 @@ type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [
 * The main rule group interface when using independent combinators. This type is used
 * for query definitions as well as all sub-groups of queries.
 */
-interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R, C>, "combinator" | "rules"> {
+interface RuleGroupTypeIC<R$1 extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R$1, C>, "combinator" | "rules"> {
   combinator?: undefined;
-  rules: RuleGroupICArray<RuleGroupTypeIC<R, C>, R, C>;
+  rules: RuleGroupICArray<RuleGroupTypeIC<R$1, C>, R$1, C>;
   /**
   * Only used when adding a rule to a query that uses independent combinators
   */
@@ -2157,11 +1339,11 @@ interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = stri
 /**
 * Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
 */
-type RuleGroupTypeAny<R extends RuleType = RuleType, C extends string = string> = RuleGroupType<R, C> | RuleGroupTypeIC<R, C>;
+type RuleGroupTypeAny<R$1 extends RuleType = RuleType, C extends string = string> = RuleGroupType<R$1, C> | RuleGroupTypeIC<R$1, C>;
 /**
 * The type of the `rules` array in a {@link RuleGroupTypeIC}.
 */
-type RuleGroupICArray<RG extends RuleGroupTypeIC = RuleGroupTypeIC, R extends RuleType = RuleType, C extends string = string> = [R | RG] | [R | RG, ...MappedTuple<[C, R | RG]>] | ((R | RG)[] & {
+type RuleGroupICArray<RG$1 extends RuleGroupTypeIC = RuleGroupTypeIC, R$1 extends RuleType = RuleType, C extends string = string> = [R$1 | RG$1] | [R$1 | RG$1, ...MappedTuple<[C, R$1 | RG$1]>] | ((R$1 | RG$1)[] & {
   length: 0;
 });
 /**
@@ -2171,27 +1353,27 @@ type RuleOrGroupArray = RuleGroupArray | RuleGroupICArray;
 /**
 * The type of the `rules` array in a {@link DefaultRuleGroupTypeIC}.
 */
-type DefaultRuleGroupICArray<F extends string = string> = RuleGroupICArray<DefaultRuleGroupTypeIC<F>, DefaultRuleType<F>, DefaultCombinatorName>;
+type DefaultRuleGroupICArray<F$1 extends string = string> = RuleGroupICArray<DefaultRuleGroupTypeIC<F$1>, DefaultRuleType<F$1>, DefaultCombinatorName>;
 /**
 * Shorthand for "either {@link DefaultRuleGroupArray} or {@link DefaultRuleGroupICArray}".
 */
-type DefaultRuleOrGroupArray<F extends string = string> = DefaultRuleGroupArray<F> | DefaultRuleGroupICArray<F>;
+type DefaultRuleOrGroupArray<F$1 extends string = string> = DefaultRuleGroupArray<F$1> | DefaultRuleGroupICArray<F$1>;
 /**
 * {@link RuleGroupTypeIC} with combinators limited to
 * {@link DefaultCombinatorName} and rules limited to {@link DefaultRuleType}.
 */
-interface DefaultRuleGroupTypeIC<F extends string = string> extends RuleGroupTypeIC<DefaultRuleType<F>> {
-  rules: DefaultRuleGroupICArray<F>;
+interface DefaultRuleGroupTypeIC<F$1 extends string = string> extends RuleGroupTypeIC<DefaultRuleType<F$1>> {
+  rules: DefaultRuleGroupICArray<F$1>;
 }
 /**
 * Shorthand for "either {@link DefaultRuleGroupType} or {@link DefaultRuleGroupTypeIC}".
 */
-type DefaultRuleGroupTypeAny<F extends string = string> = DefaultRuleGroupType<F> | DefaultRuleGroupTypeIC<F>;
+type DefaultRuleGroupTypeAny<F$1 extends string = string> = DefaultRuleGroupType<F$1> | DefaultRuleGroupTypeIC<F$1>;
 /**
 * Determines if a type extending {@link RuleGroupTypeAny} is actually
 * {@link RuleGroupType} or {@link RuleGroupTypeIC}.
 */
-type GetRuleGroupType<RG> = RG extends {
+type GetRuleGroupType<RG$1> = RG$1 extends {
   combinator: string;
 } ? RuleGroupType : RuleGroupTypeIC;
 /**
@@ -2202,11 +1384,11 @@ type GetRuleGroupType<RG> = RG extends {
 * the rule type has its field and operator types narrowed to the
 * identifier types of the provided Field and Operator types.
 */
-type GetRuleTypeFromGroupWithFieldAndOperator<RG extends RuleGroupTypeAny, F extends BaseOption, O extends BaseOption> = RG extends RuleGroupType<infer RT> | RuleGroupTypeIC<infer RT> ? RT extends RuleType<infer RuleFieldName, infer RuleOperatorName, infer RuleValueName, infer RuleCombinatorName> ? RuleFieldName extends GetOptionIdentifierType<F> ? RuleOperatorName extends GetOptionIdentifierType<O> ? RuleType<RuleFieldName, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<RuleFieldName, GetOptionIdentifierType<O>, RuleValueName, RuleCombinatorName> : RuleOperatorName extends GetOptionIdentifierType<O> ? RuleType<GetOptionIdentifierType<F>, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<GetOptionIdentifierType<F>, GetOptionIdentifierType<O>, RuleValueName, RuleCombinatorName> : never : never;
+type GetRuleTypeFromGroupWithFieldAndOperator<RG$1 extends RuleGroupTypeAny, F$1 extends BaseOption, O$1 extends BaseOption> = RG$1 extends RuleGroupType<infer RT> | RuleGroupTypeIC<infer RT> ? RT extends RuleType<infer RuleFieldName, infer RuleOperatorName, infer RuleValueName, infer RuleCombinatorName> ? RuleFieldName extends GetOptionIdentifierType<F$1> ? RuleOperatorName extends GetOptionIdentifierType<O$1> ? RuleType<RuleFieldName, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<RuleFieldName, GetOptionIdentifierType<O$1>, RuleValueName, RuleCombinatorName> : RuleOperatorName extends GetOptionIdentifierType<O$1> ? RuleType<GetOptionIdentifierType<F$1>, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<GetOptionIdentifierType<F$1>, GetOptionIdentifierType<O$1>, RuleValueName, RuleCombinatorName> : never : never;
 /**
 * Converts a narrowed rule group type to its most generic form.
 */
-type GenericizeRuleGroupType<RG> = RG extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
+type GenericizeRuleGroupType<RG$1> = RG$1 extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
 //#endregion
 //#region src/types/validation.d.ts
 /**
@@ -2245,7 +1427,7 @@ type Classname = string | string[] | Record<string, any>;
 */
 type ValueSource = "value" | "field";
 /**
-* Type of {@link ValueEditor} that will be displayed.
+* Type of {@link react-querybuilder!ValueEditor ValueEditor} that will be displayed.
 */
 type ValueEditorType = "text" | "select" | "checkbox" | "radio" | "textarea" | "switch" | "multiselect" | null;
 /**
@@ -2262,7 +1444,7 @@ type ToOptionArrays<Sources extends readonly string[]> = Sources extends unknown
   label: string;
 } } : never;
 type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption<Sources[K]> } : never;
-type WithOptionalClassName<T> = T & {
+type WithOptionalClassName<T$1> = T$1 & {
   className?: Classname;
 };
 /**
@@ -2305,7 +1487,7 @@ interface BaseFullField<FieldName extends string = string, OperatorName extends
   comparator?: string | ((f: FullField, operator: string) => boolean);
 }
 /**
-* Full field definition used in the `fields` prop of {@link QueryBuilder}.
+* Full field definition used in the `fields` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type requires both `name` and `value`, but the `fields` prop itself
 * can use a {@link FlexibleOption} where only one of `name` or `value` is
 * required (along with `label`), or {@link Field} where only `name` and
@@ -2318,7 +1500,7 @@ interface BaseFullField<FieldName extends string = string, OperatorName extends
 */
 type FullField<FieldName extends string = string, OperatorName extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName>, ValueObj extends FullOption = FullOption<ValueName>> = Simplify<FullOption<FieldName> & BaseFullField<FieldName, OperatorName, ValueName, OperatorObj, ValueObj>>;
 /**
-* Field definition used in the `fields` prop of {@link QueryBuilder}.
+* Field definition used in the `fields` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type is an extension of {@link FullField} where only `name` and
 * `label` are required.
 *
@@ -2331,7 +1513,7 @@ type Field<FieldName extends string = string, OperatorName extends string = stri
   value?: FieldName;
 } & Pick<BaseFullField<FieldName, OperatorName, ValueName, OperatorObj>, Exclude<keyof BaseFullField, "value">>>;
 /**
-* Field definition used in the `fields` prop of {@link QueryBuilder}.
+* Field definition used in the `fields` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type is an extension of {@link FullField} where only `value` and
 * `label` are required.
 *
@@ -2346,19 +1528,19 @@ type FieldByValue<FieldName extends string = string, OperatorName extends string
 /**
 * Utility type to make one or more properties required.
 */
-type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+type WithRequired<T$1, K$1 extends keyof T$1> = T$1 & { [P in K$1]-?: T$1[P] };
 /**
 * Utility type to make all properties non-nullable.
 */
-type RemoveNullability<T extends Record<string, unknown>> = { [k in keyof T]: NonNullable<T[k]> };
+type RemoveNullability<T$1 extends Record<string, unknown>> = { [k in keyof T$1]: NonNullable<T$1[k]> };
 /**
 * Allowed values of the {@link FullOperator} property `arity`. A value of `"unary"` or
-* a number less than two will cause the default {@link ValueEditor} to render `null`.
+* a number less than two will cause the default {@link react-querybuilder!ValueEditor ValueEditor} to render `null`.
 */
 type Arity = number | "unary" | "binary" | "ternary";
 /**
 * Full operator definition used in the `operators`/`getOperators` props of
-* {@link QueryBuilder}. This type requires both `name` and `value`, but the
+* {@link react-querybuilder!QueryBuilder QueryBuilder}. This type requires both `name` and `value`, but the
 * `operators`/`getOperators` props themselves can use a {@link FlexibleOption}
 * where only one of `name` or `value` is required, or {@link FullOperator} where
 * only `name` is required.
@@ -2372,7 +1554,7 @@ interface FullOperator<N extends string = string> extends WithOptionalClassName<
 }
 /**
 * Operator definition used in the `operators`/`getOperators` props of
-* {@link QueryBuilder}. This type is an extension of {@link FullOperator}
+* {@link react-querybuilder!QueryBuilder QueryBuilder}. This type is an extension of {@link FullOperator}
 * where only `name` and `label` are required.
 *
 * The `name`/`value` properties of this interface can be narrowed with generics.
@@ -2384,7 +1566,7 @@ type Operator<N extends string = string> = WithUnknownIndex<SetOptional<BaseFull
 }>>;
 /**
 * Operator definition used in the `operators`/`getOperators` props of
-* {@link QueryBuilder}. This type is an extension of {@link FullOperator}
+* {@link react-querybuilder!QueryBuilder QueryBuilder}. This type is an extension of {@link FullOperator}
 * where only `value` and `label` are required.
 *
 * The `name`/`value` properties of this interface can be narrowed with generics.
@@ -2395,7 +1577,7 @@ type OperatorByValue<N extends string = string> = WithUnknownIndex<SetOptional<B
   arity?: Arity;
 }>>;
 /**
-* Full combinator definition used in the `combinators` prop of {@link QueryBuilder}.
+* Full combinator definition used in the `combinators` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type requires both `name` and `value`, but the `combinators` prop itself
 * can use a {@link FlexibleOption} where only one of `name` or `value` is required,
 * or {@link Combinator} where only `name` is required.
@@ -2406,7 +1588,7 @@ type OperatorByValue<N extends string = string> = WithUnknownIndex<SetOptional<B
 */
 type FullCombinator<N extends string = string> = WithOptionalClassName<FullOption<N>>;
 /**
-* Combinator definition used in the `combinators` prop of {@link QueryBuilder}.
+* Combinator definition used in the `combinators` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type is an extension of {@link FullCombinator} where only `name` and
 * `label` are required.
 *
@@ -2416,7 +1598,7 @@ type FullCombinator<N extends string = string> = WithOptionalClassName<FullOptio
 */
 type Combinator<N extends string = string> = WithUnknownIndex<WithOptionalClassName<SetOptional<BaseFullOption<N>, "value">>>;
 /**
-* Combinator definition used in the `combinators` prop of {@link QueryBuilder}.
+* Combinator definition used in the `combinators` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type is an extension of {@link FullCombinator} where only `value` and
 * `label` are required.
 *
@@ -2432,12 +1614,12 @@ type ParseNumberMethodName = "enhanced" | "native" | "strict";
 type ParseNumberMethod = boolean | ParseNumberMethodName;
 type ParseNumbersModerationLevel = "-limited" | "";
 /**
-* Options for the `parseNumbers` prop of {@link QueryBuilder}.
+* Options for the `parseNumbers` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 */
 type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
 /**
-* Signature of `accessibleDescriptionGenerator` prop, used by {@link QueryBuilder} to generate
-* accessible descriptions for each {@link RuleGroup}.
+* Signature of `accessibleDescriptionGenerator` prop, used by {@link react-querybuilder!QueryBuilder QueryBuilder} to generate
+* accessible descriptions for each {@link react-querybuilder!RuleGroup RuleGroup}.
 */
 type AccessibleDescriptionGenerator = (props: {
   path: Path;
@@ -2585,11 +1767,11 @@ interface FormatQueryOptions {
   quoteValuesWith?: string;
   /**
   * Validator function for the entire query. Can be the same function passed
-  * as `validator` prop to {@link QueryBuilder}.
+  * as `validator` prop to {@link react-querybuilder!QueryBuilder QueryBuilder}.
   */
   validator?: QueryValidator;
   /**
-  * This can be the same {@link FullField} array passed to {@link QueryBuilder}, but
+  * This can be the same {@link FullField} array passed to {@link react-querybuilder!QueryBuilder QueryBuilder}, but
   * really all you need to provide is the `name` and `validator` for each field.
   *
   * The full field object from this array, where the field's identifying property
@@ -2597,7 +1779,7 @@ interface FormatQueryOptions {
   */
   fields?: FlexibleOptionList<FullField>;
   /**
-  * This can be the same `getOperators` function passed to {@link QueryBuilder}.
+  * This can be the same `getOperators` function passed to {@link react-querybuilder!QueryBuilder QueryBuilder}.
   *
   * The full operator object from this array, where the operator's identifying property
   * matches the rule's `operator`, will be passed to the rule processor.
@@ -2931,7 +2113,7 @@ type NLTranslationKey = "and" | "or" | "true" | "false" | `groupPrefix${ZeroOrMo
 */
 type NLTranslations = Partial<Record<NLTranslationKey, string>>;
 //#endregion
-//#region src/types/props.d.ts
+//#region src/types/queryBuilder.d.ts
 /**
 * Base interface for all rule subcomponents.
 *
@@ -3035,6 +2217,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 +2276,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 +2293,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
@@ -3112,6 +2389,113 @@ interface QueryActions {
   moveRule(oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any): void;
   groupRule(sourcePath: Path, targetPath: Path, clone?: boolean, context?: any): void;
 }
+interface QueryBuilderFlags {
+  /**
+  * Set to `false` to avoid calling the `onQueryChange` callback
+  * when the component mounts.
+  *
+  * @default true
+  */
+  enableMountQueryChange?: boolean;
+  /**
+  * Enables drag-and-drop features.
+  *
+  * @default false
+  */
+  enableDragAndDrop?: boolean;
+  /**
+  * Enables debug logging for query builders (and React DnD when applicable).
+  *
+  * @default false
+  */
+  debugMode?: boolean;
+  /**
+  * Show group combinator selectors in the body of the group, between each child rule/group,
+  * instead of in the group header.
+  *
+  * @default false
+  */
+  showCombinatorsBetweenRules?: boolean;
+  /**
+  * Show the "not" (aka inversion) toggle for rule groups.
+  *
+  * @default false
+  */
+  showNotToggle?: boolean;
+  /**
+  * Show the "Shift up"/"Shift down" actions.
+  *
+  * @default false
+  */
+  showShiftActions?: boolean;
+  /**
+  * Show the "Clone rule" and "Clone group" buttons.
+  *
+  * @default false
+  */
+  showCloneButtons?: boolean;
+  /**
+  * Show the "Lock rule" and "Lock group" buttons.
+  *
+  * @default false
+  */
+  showLockButtons?: boolean;
+  /**
+  * Show the "Mute rule" and "Mute group" buttons.
+  *
+  * @default false
+  */
+  showMuteButtons?: boolean;
+  /**
+  * Reset the `operator` and `value` when the `field` changes.
+  *
+  * @default true
+  */
+  resetOnFieldChange?: boolean;
+  /**
+  * Reset the `value` when the `operator` changes.
+  *
+  * @default false
+  */
+  resetOnOperatorChange?: boolean;
+  /**
+  * Select the first field in the array automatically.
+  *
+  * @default true
+  */
+  autoSelectField?: boolean;
+  /**
+  * Select the first operator in the array automatically.
+  *
+  * @default true
+  */
+  autoSelectOperator?: boolean;
+  /**
+  * Select the first value in the array automatically. Only applicable when the value editor renders a select list.
+  *
+  * @default false
+  */
+  autoSelectValue?: boolean;
+  /**
+  * Adds a new default rule automatically to each new group.
+  *
+  * @default false
+  */
+  addRuleToNewGroups?: boolean;
+  /**
+  * Store list-type values as native arrays instead of comma-separated strings.
+  *
+  * @default false
+  */
+  listsAsArrays?: boolean;
+  /**
+  * Prevent _any_ assignment of standard classes to elements. This includes conditional
+  * and event-based classes for validation, drag-and-drop, etc.
+  *
+  * @default false
+  */
+  suppressStandardClassnames?: boolean;
+}
 //#endregion
 //#region src/defaults.d.ts
 /**
@@ -3177,6 +2561,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 +2643,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 +2694,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";
 };
@@ -3327,6 +2722,13 @@ declare const LogType: {
 * @group Defaults
 */
 declare const rootPath: Path;
+/**
+* Default values for all `boolean`
+* {@link react-querybuilder!QueryBuilder QueryBuilder} options.
+*
+* @group Defaults
+*/
+declare const queryBuilderFlagDefaults: Required<QueryBuilderFlags>;
 //#endregion
 //#region src/utils/arrayUtils.d.ts
 /**
@@ -3421,7 +2823,7 @@ declare function convertQuery(query: RuleGroupTypeIC): RuleGroupType;
 //#endregion
 //#region src/utils/defaultValidator.d.ts
 /**
-* This is an example validation function you can pass to {@link QueryBuilder} in the
+* This is an example validation function you can pass to {@link react-querybuilder!QueryBuilder QueryBuilder} in the
 * `validator` prop. It assumes that you want to validate groups, and has a no-op
 * for validating rules which you can replace with your own implementation.
 */
@@ -4183,10 +3585,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)[];
 /**
@@ -4220,7 +3630,7 @@ declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefi
 * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
 * ```
 */
-type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
+type ObjectKeys<T$1 extends object> = Exclude<keyof T$1, symbol>;
 /**
 * A strongly-typed version of `Object.keys()`.
 *
@@ -4241,14 +3651,14 @@ declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value:
 *
 * @group Option Lists
 */
-declare function toFullOption<Opt extends BaseOption>(opt: Opt | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt>;
+declare function toFullOption<Opt$1 extends BaseOption>(opt: Opt$1 | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt$1>;
 /**
 * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
 * Lists of full options are left unchanged.
 *
 * @group Option Lists
 */
-declare function toFullOptionList<Opt extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt>;
+declare function toFullOptionList<Opt$1 extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt$1>;
 /**
 * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
 * Lists of full options are left unchanged.
@@ -4330,9 +3740,9 @@ declare function getOption<OptType extends Option>(arr: FlexibleOptionList<OptTy
 *
 * @group Option Lists
 */
-declare function getFirstOption<Opt extends FullOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-declare function getFirstOption<Opt extends ValueOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-declare function getFirstOption<Opt extends Option>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
+declare function getFirstOption<Opt$1 extends FullOption>(arr?: OptionGroup<Opt$1>[] | Opt$1[]): GetOptionIdentifierType<Opt$1> | null;
+declare function getFirstOption<Opt$1 extends ValueOption>(arr?: OptionGroup<Opt$1>[] | Opt$1[]): GetOptionIdentifierType<Opt$1> | null;
+declare function getFirstOption<Opt$1 extends Option>(arr?: OptionGroup<Opt$1>[] | Opt$1[]): GetOptionIdentifierType<Opt$1> | null;
 /**
 * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
 * If the array is already flat, it is returned as is.
@@ -4354,6 +3764,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$1 extends FullOption> {
+  defaultOption: FullOption;
+  optionList: O$1[] | OptionGroup<O$1>[];
+  optionsMap: Partial<FullOptionRecord<FullOption>>;
+}
+interface PrepareOptionListParams<O$1 extends FullOption> {
+  placeholder?: Placeholder;
+  optionList?: FlexibleOptionListProp<O$1> | BaseOptionMap<O$1>;
+  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
 /**
@@ -4421,6 +3844,23 @@ declare const getCommonAncestorPath: (path1: Path, path2: Path) => Path;
 */
 declare const pathIsDisabled: (path: Path, query: RuleGroupTypeAny) => boolean;
 //#endregion
+//#region src/utils/preferProp.d.ts
+/**
+* For given default, prop, and context values, return the first provided of prop,
+* context, and default, in that order.
+*/
+declare const preferProp: (def: boolean, prop?: boolean, context?: boolean, doNotFinalize?: boolean) => boolean;
+/**
+* For given default, prop, and context values, return the first provided of prop,
+* context, and default, in that order.
+*/
+declare const preferAnyProp: (def?: any, prop?: any, context?: any) => any;
+/**
+* For a given set of defaults, props, and context values, return the first provided of prop,
+* context, and default—in that order—for each property in the defaults object.
+*/
+declare const preferFlagProps: (props?: QueryBuilderFlags, contextVals?: QueryBuilderFlags, finalize?: boolean) => QueryBuilderFlags;
+//#endregion
 //#region src/utils/prepareQueryObjects.d.ts
 /**
 * Options for {@link prepareRule}/{@link prepareRuleGroup}.
@@ -4684,7 +4124,7 @@ declare const regenerateIDs: <RG>(subject: RG, {
 /**
 * Options object for {@link index!transformQuery transformQuery}.
 */
-interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {
+interface TransformQueryOptions<RG$1 extends RuleGroupTypeAny = RuleGroupType> {
   /**
   * When a rule is encountered in the hierarchy, it will be replaced
   * with the result of this function.
@@ -4698,7 +4138,7 @@ interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {
   *
   * @defaultValue `rg => rg`
   */
-  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;
+  ruleGroupProcessor?: (ruleGroup: RG$1) => Record<string, any>;
   /**
   * For each rule and group in the query, any properties matching a key
   * in this object will be renamed to the corresponding value. To retain both
@@ -4793,5 +4233,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, QueryBuilderFlags, 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, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, remove, rootPath, shouldRenderAsNumber, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update };
 //# sourceMappingURL=react-querybuilder_core.cjs.production.d.ts.map