@react-querybuilder/core 8.10.0 → 8.11.0

package/dist/react-querybuilder_core.production.d.mts

@@ -9,26 +9,6 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 @category Type
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-//#endregion
-//#region ../../node_modules/type-fest/source/observable-like.d.ts
-declare global {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-  interface SymbolConstructor {
-    readonly observable: symbol;
-  }
-}
-
-/**
-@remarks
-The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
-As well, some guidance on making an `Observable` to not include `closed` property.
-@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
-@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
-@see https://github.com/benlesh/symbol-observable#making-an-object-observable
-
-@category Observable
-*/
-
 //#endregion
 //#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
 /**
@@ -89,7 +69,7 @@ Union extends unknown
 // Infer the `Intersection` type since TypeScript represents the positional
 // arguments of unions of functions as an intersection of the union.
 ) extends ((mergedIntersection: infer Intersection) => void)
-// The `& Union` is to allow indexing by the resulting type
+// 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
@@ -134,6 +114,80 @@ 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 `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T$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 key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+interface Admin {
+	name: string;
+	surname?: string;
+}
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+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 ../../node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
@@ -168,8 +222,8 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+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 ../../node_modules/type-fest/source/required-keys-of.d.ts
@@ -197,8 +251,8 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+type RequiredKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
+? Exclude<keyof Type$1, OptionalKeysOf<Type$1>> : never;
 //#endregion
 //#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
@@ -242,29 +296,67 @@ endIfEqual('abc', '123');
 @category Type Guard
 @category Utilities
 */
-type IsNever<T> = [T] extends [never] ? true : false;
+type IsNever<T$1> = [T$1] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/type-fest/source/if-never.d.ts
+//#region ../../node_modules/type-fest/source/if.d.ts
 /**
-An if-else-like type that resolves depending on whether the given type is `never`.
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+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'>`.
 
-@see {@link IsNever}
+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
 ```
-import type {IfNever} from 'type-fest';
+import {If} from 'type-fest';
 
-type ShouldBeTrue = IfNever<never>;
-//=> true
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
 ```
 
 @category Type Guard
 @category Utilities
 */
-type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+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
 /**
@@ -293,104 +385,48 @@ type C = IsArray<string>;
 */
 type UnknownArray = readonly unknown[];
 //#endregion
-//#region ../../node_modules/type-fest/source/internal/array.d.ts
-
+//#region ../../node_modules/type-fest/source/internal/type.d.ts
 /**
-Returns whether the given array `T` is readonly.
+Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
-type IsArrayReadonly<T extends UnknownArray> = IfNever$1<T, false, T extends unknown[] ? false : true>;
+type BuiltIns = Primitive | void | Date | RegExp;
 /**
-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]
+Test if the given function has multiple call signatures.
 
-type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
-//=> true
+Needed to handle the case of a single call signature with properties.
 
-type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
-//=> 'bar'
-```
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
 */
-type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
-//#endregion
-//#region ../../node_modules/type-fest/source/is-any.d.ts
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
-
+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 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.
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
 @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];
-}
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
 
-const typedA = get(typedObject, 'a');
-//=> 1
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
 
-const anyA = get(anyObject, 'a');
-//=> any
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
 ```
-
-@category Type Guard
-@category Utilities
 */
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+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/is-equal.d.ts
+//#region ../../node_modules/type-fest/source/internal/array.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;
-```
-
-@category Type Guard
-@category Utilities
+Returns whether the given array `T` is readonly.
 */
-type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+type IsArrayReadonly<T$1 extends UnknownArray> = If<IsNever<T$1>, false, T$1 extends unknown[] ? false : true>;
 //#endregion
 //#region ../../node_modules/type-fest/source/simplify.d.ts
 /**
@@ -450,7 +486,38 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see SimplifyDeep
 @category Object
 */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/type-fest/source/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;
+```
+
+@category Type Guard
+@category Utilities
+*/
+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 ../../node_modules/type-fest/source/omit-index-signature.d.ts
 /**
@@ -633,67 +700,6 @@ export type FooBar = Merge<Foo, Bar>;
 */
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/type-fest/source/if-any.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfAny$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-//#endregion
-//#region ../../node_modules/type-fest/source/internal/type.d.ts
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-/**
-Test if the given function has multiple call signatures.
-
-Needed to handle the case of a single call signature with properties.
-
-Multiple call signatures cannot currently be supported due to a TypeScript limitation.
-@see https://github.com/microsoft/TypeScript/issues/29732
-*/
-type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
-  (...arguments_: infer A): unknown;
-  (...arguments_: infer B): unknown;
-} ? B extends A ? A extends B ? false : true : true : false;
-// Should never happen
-
-/**
-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'
-```
-*/
-type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = IsAny<T> extends true ? IfAny : IsNever<T> extends true ? IfNever : IfNotAnyOrNever;
-//#endregion
 //#region ../../node_modules/type-fest/source/internal/object.d.ts
 /**
 Works similar to the built-in `Pick` utility type, except for the following differences:
@@ -732,7 +738,7 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
 */
-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.
 
@@ -785,8 +791,7 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1<SpecifiedOptions, Defaults, IfNever$1<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
->>;
+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 ../../node_modules/type-fest/source/except.d.ts
 /**
@@ -816,7 +821,7 @@ 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.
@@ -907,7 +912,7 @@ const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 
 @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 = 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>> &
@@ -918,8 +923,6 @@ Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] &
 Except<ObjectType, KeysType>;
 //#endregion
 //#region ../../node_modules/type-fest/source/required-deep.d.ts
-type ExcludeUndefined<T> = Exclude<T, undefined>;
-
 /**
 Create a type from another type with all keys and nested keys set to required.
 
@@ -933,23 +936,23 @@ import type {RequiredDeep} from 'type-fest';
 
 type Settings = {
 	textEditor?: {
-		fontSize?: number | undefined;
-		fontColor?: string | undefined;
+		fontSize?: number;
+		fontColor?: string;
 		fontWeight?: number | undefined;
-	}
-	autocomplete?: boolean | undefined;
+	};
+	autocomplete?: boolean;
 	autosave?: boolean | undefined;
 };
 
 type RequiredSettings = RequiredDeep<Settings>;
-// type RequiredSettings = {
+//=> {
 // 	textEditor: {
 // 		fontSize: number;
 // 		fontColor: string;
-// 		fontWeight: number;
-// 	}
+// 		fontWeight: number | undefined;
+// 	};
 // 	autocomplete: boolean;
-// 	autosave: boolean;
+// 	autosave: boolean | undefined;
 // }
 ```
 
@@ -961,11 +964,7 @@ Note that types containing overloaded functions are not made deeply required due
 @category Set
 @category Map
 */
-type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns ? E : E extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : E extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : E extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : E extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : E extends ((...arguments_: any[]) => unknown) ? {} extends RequiredObjectDeep<E> ? E : HasMultipleCallSignatures<E> extends true ? E : ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E> : E extends object ? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-? ItemType[] extends E // Test for arrays (non-tuples) specifically
-? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
-: RequiredObjectDeep<E> // Tuples behave properly
-: RequiredObjectDeep<E> : unknown;
+type 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 ../../node_modules/type-fest/source/set-optional.d.ts
@@ -994,7 +993,8 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 
 @category Object
 */
-type SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
+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> &
@@ -1031,11 +1031,13 @@ type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
 
 @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<
+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.
 */
@@ -1052,6 +1054,7 @@ type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] =
 : 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>;
 /**
@@ -1059,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;
 };
 /**
@@ -1102,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}
@@ -1143,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}.
 *
@@ -1155,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
@@ -1195,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
 /**
@@ -1235,10 +1238,10 @@ interface CommonRuleAndGroupProperties {
 * 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;
   /**
@@ -1250,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`).
@@ -1267,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.
 *
@@ -1325,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
   */
@@ -1336,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;
 });
 /**
@@ -1350,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;
 /**
@@ -1381,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
 /**
@@ -1424,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;
 /**
@@ -1441,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;
 };
 /**
@@ -1484,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
@@ -1497,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.
 *
@@ -1510,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.
 *
@@ -1525,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.
@@ -1551,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.
@@ -1563,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.
@@ -1574,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.
@@ -1585,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.
 *
@@ -1595,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.
 *
@@ -1611,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;
@@ -1764,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
@@ -1776,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.
@@ -2110,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.
 *
@@ -2386,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
 /**
@@ -2612,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
 /**
@@ -2706,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.
 */
@@ -3513,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()`.
 *
@@ -3534,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.
@@ -3623,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.
@@ -3647,14 +3764,14 @@ declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptio
 * @group Option Lists
 */
 declare const uniqOptList: <T extends BaseOption>(originalArray: FlexibleOptionList<T>) => WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[];
-interface PreparedOptionList<O extends FullOption> {
+interface PreparedOptionList<O$1 extends FullOption> {
   defaultOption: FullOption;
-  optionList: O[] | OptionGroup<O>[];
+  optionList: O$1[] | OptionGroup<O$1>[];
   optionsMap: Partial<FullOptionRecord<FullOption>>;
 }
-interface PrepareOptionListParams<O extends FullOption> {
+interface PrepareOptionListParams<O$1 extends FullOption> {
   placeholder?: Placeholder;
-  optionList?: FlexibleOptionListProp<O> | BaseOptionMap<O>;
+  optionList?: FlexibleOptionListProp<O$1> | BaseOptionMap<O$1>;
   baseOption?: Record<string, unknown>;
   labelMap?: Record<string, string>;
   autoSelectOption?: boolean;
@@ -3727,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}.
@@ -3990,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.
@@ -4004,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
@@ -4099,5 +4233,5 @@ declare function transformQuery(query: RuleGroupType, options?: TransformQueryOp
 */
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
-export { AccessibleDescriptionGenerator, ActionElementEventHandler, AddOptions, Arity, BaseFullOption, BaseOption, BaseOptionMap, BaseTranslation, BaseTranslationWithLabel, BaseTranslationWithPlaceholders, BaseTranslations, BaseTranslationsFull, Classname, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DndDropTargetType, DragCollection, DraggedItem, DropCollection, DropEffect, DropResult, ExportFormat, ExportObjectFormats, ExportOperatorMap, Field, FieldByValue, FindPathReturnType, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GroupOptions, GroupVariantCondition, InputType, InsertOptions, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, LogType, MatchConfig, MatchMode, MatchModeOptions, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Operator, OperatorByValue, Option, OptionGroup, OptionList, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, Placeholder, PrepareOptionListParams, PreparedOptionList, PreparerOptions, QueryActions, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveNullability, RuleGroupArray, RuleGroupICArray, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, TestID, ToFlexibleOption, ToFullOption, TransformQueryOptions, UpdateOptions, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WithRequired, WithUnknownIndex, add, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getValidationClassNames, getValueSourcesUtil, group, groupInvalidReasons, insert, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, normalizeConstituentWordOrder, nullFreeArray, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, regenerateID, regenerateIDs, remove, rootPath, shouldRenderAsNumber, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update };
+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.production.d.mts.map