@react-querybuilder/bootstrap 8.14.0 → 8.14.1

package/dist/react-querybuilder_bootstrap.d.mts

@@ -1,2742 +1,6 @@
 import * as React from "react";
-import { ComponentType, ForwardRefExoticComponent, MouseEvent, ReactNode, Ref, RefAttributes } from "react";
+import { Classnames, ControlElementsProp, FullField, NotToggleProps, QueryBuilderContextProvider, Translations, ValueEditorProps } from "react-querybuilder";
 
-//#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
-
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {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};
-```
-
-@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
-/**
-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'
-```
-
-@category Object
-*/
-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>(object: O, key: K) {
-	return object[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';
-
-type User = {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-};
-
-type 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 extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[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.
-
-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';
-
-type 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,
-};
-```
-
-@category Utilities
-*/
-type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // 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
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<
-	Entity extends object,
-	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
->(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
-
-type User = {
-	name: string;
-	surname: string;
-	luckyNumber?: number;
-};
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-
-// @ts-expect-error
-const validator3 = createValidation<User>('luckyNumber', value => value > 0);
-// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
-```
-
-@category Utilities
-*/
-type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
-//#endregion
-//#region ../../node_modules/type-fest/source/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';
-
-type A = IsNever<never>;
-//=> true
-
-type B = IsNever<any>;
-//=> false
-
-type C = IsNever<unknown>;
-//=> false
-
-type D = IsNever<never[]>;
-//=> false
-
-type E = IsNever<object>;
-//=> false
-
-type F = IsNever<string>;
-//=> false
-```
-
-@example
-```
-import type {IsNever} from 'type-fest';
-
-type IsTrue<T> = T extends true ? true : false;
-
-// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
-type A = IsTrue<never>;
-//   ^? type A = never
-
-// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
-type IsTrueFixed<T> =
-	IsNever<T> extends true ? false : T extends true ? true : false;
-
-type B = IsTrueFixed<never>;
-//   ^? type B = false
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T$1> = [T$1] extends [never] ? true : false;
-//#endregion
-//#region ../../node_modules/type-fest/source/if.d.ts
-/**
-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'>`.
-
-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 {If} from 'type-fest';
-
-type A = If<true, 'yes', 'no'>;
-//=> 'yes'
-
-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 type {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 type {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'
-```
-
-Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
-
-@example
-```
-import type {If, IsEqual, StringRepeat} from 'type-fest';
-
-type HundredZeroes = StringRepeat<'0', 100>;
-
-// The following implementation is not tail recursive
-type Includes<S extends string, Char extends string> =
-	S extends `${infer First}${infer Rest}`
-		? If<IsEqual<First, Char>,
-			'found',
-			Includes<Rest, Char>>
-		: 'not found';
-
-// Hence, instantiations with long strings will fail
-// @ts-expect-error
-type Fails = Includes<HundredZeroes, '1'>;
-//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Error: Type instantiation is excessively deep and possibly infinite.
-
-// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
-type IncludesWithoutIf<S extends string, Char extends string> =
-	S extends `${infer First}${infer Rest}`
-		? IsEqual<First, Char> extends true
-			? 'found'
-			: IncludesWithoutIf<Rest, Char>
-		: 'not found';
-
-// Now, instantiations with long strings will work
-type Works = IncludesWithoutIf<HundredZeroes, '1'>;
-//=> 'not found'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
-//#endregion
-//#region ../../node_modules/type-fest/source/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
-```
-
-@category Type
-@category Array
-*/
-type UnknownArray = readonly unknown[];
-//#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 ../../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.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-declare function fn(object: Record<string, unknown>): void;
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-// @ts-expect-error
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see {@link SimplifyDeep}
-@category Object
-*/
-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, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
-// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
-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 ../../node_modules/type-fest/source/omit-index-signature.d.ts
-/**
-Omit any index signatures from the given object type, leaving only explicitly defined properties.
-
-This is the counterpart of `PickIndexSignature`.
-
-Use-cases:
-- Remove overly permissive signatures from third-party types.
-
-This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
-
-(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
-
-```
-const indexed: Record<string, unknown> = {}; // Allowed
-
-// @ts-expect-error
-const keyed: Record<'foo', unknown> = {}; // Error
-// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
-```
-
-Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
-
-```
-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>`'
-
-type Keyed = {} extends 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>`"
-```
-
-Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
-
-```
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
-};
-```
-
-...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
-
-```
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-	// Is `{}` assignable to `Record<KeyType, unknown>`?
-	as {} extends Record<KeyType, unknown>
-		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-	]: ObjectType[KeyType];
-};
-```
-
-If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
-
-@example
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type 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';
-};
-
-type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
-```
-
-@see {@link PickIndexSignature}
-@category Object
-*/
-type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
-//#endregion
-//#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.
-
-This is the counterpart of `OmitIndexSignature`.
-
-@example
-```
-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';
-};
-
-type ExampleIndexSignature = PickIndexSignature<Example>;
-// {
-// 	[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;
-// }
-```
-
-@see {@link OmitIndexSignature}
-@category Object
-*/
-type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
-//#endregion
-//#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.
-
-@example
-```
-import type {Merge} from 'type-fest';
-
-type Foo = {
-	[x: string]: unknown;
-	[x: number]: unknown;
-	foo: string;
-	bar: symbol;
-};
-
-type Bar = {
-	[x: number]: number;
-	[x: symbol]: unknown;
-	bar: Date;
-	baz: boolean;
-};
-
-export type FooBar = Merge<Foo, Bar>;
-// => {
-// 	[x: string]: unknown;
-// 	[x: number]: number;
-// 	[x: symbol]: unknown;
-// 	foo: string;
-// 	bar: Date;
-// 	baz: boolean;
-// }
-```
-
-@category Object
-*/
-type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
-//#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:
-- Distributes over union types and allows picking keys from any member of the union type.
-- Primitives types are returned as-is.
-- Picks all keys if `Keys` is `any`.
-- Doesn't pick `number` from a `string` index signature.
-
-@example
-```
-type ImageUpload = {
-	url: string;
-	size: number;
-	thumbnailUrl: string;
-};
-
-type VideoUpload = {
-	url: string;
-	duration: number;
-	encodingFormat: string;
-};
-
-// Distributes over union types and allows picking keys from any member of the union type
-type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
-//=> {url: string; size: number} | {url: string; duration: number}
-
-// Primitive types are returned as-is
-type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
-//=> string | number
-
-// Picks all keys if `Keys` is `any`
-type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
-//=> {a: 1; b: 2} | {c: 3}
-
-// Doesn't pick `number` from a `string` index signature
-type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
-//=> {}
-*/
-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.
-
-@example
-```
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: true};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//=> {maxRecursionDepth: 10; leavesOnly: true}
-```
-
-@example
-```
-// Complains if default values are not provided for optional options
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
-```
-
-@example
-```
-// Complains if an option's default type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-
-@example
-```
-// Complains if an option's specified type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: 'yes'};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                                                   ~~~~~~~~~~~~~~~~
-// 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> = 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
-/**
-Filter out keys from an object.
-
-Returns `never` if `Exclude` is strictly equal to `Key`.
-Returns `never` if `Key` extends `Exclude`.
-Returns `Key` otherwise.
-
-@example
-```
-type Filtered = Filter<'foo', 'foo'>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', string>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', 'foo'>;
-//=> 'bar'
-```
-
-@see {Except}
-*/
-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
-  */
-  requireExactProps?: boolean;
-};
-type DefaultExceptOptions = {
-  requireExactProps: false;
-};
-
-/**
-Create a type from an object type without certain keys.
-
-We recommend setting the `requireExactProps` option to `true`.
-
-This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
-
-This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
-
-@example
-```
-import type {Except} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b: string;
-};
-
-type FooWithoutA = Except<Foo, 'a'>;
-//=> {b: string}
-
-// @ts-expect-error
-const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-//=> errors: 'a' does not exist in type '{ b: string; }'
-
-type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<"b", never>>
-
-// @ts-expect-error
-const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
-
-// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
-
-// Consider the following example:
-
-type UserData = {
-	[metadata: string]: string;
-	email: string;
-	name: string;
-	role: 'admin' | 'user';
-};
-
-// `Omit` clearly doesn't behave as expected in this case:
-type PostPayload = Omit<UserData, 'email'>;
-//=> { [x: string]: string; [x: number]: string; }
-
-// In situations like this, `Except` works better.
-// It simply removes the `email` key while preserving all the other keys.
-type PostPayloadFixed = Except<UserData, 'email'>;
-//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
-```
-
-@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 ../../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.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
-
-@example
-```
-import type {SetRequired} from 'type-fest';
-
-type Foo = {
-	a?: number;
-	b: string;
-	c?: boolean;
-};
-
-type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
-
-// Set specific indices in an array to be required.
-type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
-//=> [number, number, number?]
-```
-
-@category Object
-*/
-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 // 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 ../../node_modules/type-fest/source/set-non-nullable.d.ts
-/**
-Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
-
-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.
-
-@example
-```
-import type {SetNonNullable} 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 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.
-// }
-```
-
-@category Object
-*/
-type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> = { [Key in keyof BaseType]: Key extends Keys ? NonNullable<BaseType[Key]> : BaseType[Key] };
-//#endregion
-//#region ../core/src/types/options.d.ts
-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 StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown ? FullOption<Op> : 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;
-/**
-* Adds an `unknown` index property to an interface.
-*/
-type WithUnknownIndex<T$1> = T$1 & {
-  [key: string]: unknown;
-};
-/**
-* Do not use this type directly; use {@link Option}, {@link ValueOption},
-* or {@link FullOption} instead. For specific option types, you can use
-* {@link FullField}, {@link FullOperator}, or {@link FullCombinator},
-* all of which extend {@link FullOption}.
-*
-* @group Option Lists
-*/
-interface BaseOption<N extends string = string> {
-  name?: N;
-  value?: N;
-  label: string;
-  disabled?: boolean;
-}
-/**
-* A generic option. Used directly in {@link OptionList} or
-* as the child element of an {@link OptionGroup}.
-*
-* @group Option Lists
-*/
-type Option<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<BaseOption<N>, "name">>>;
-/**
-* Like {@link Option} but requiring `value` instead of `name`.
-*
-* @group Option Lists
-*/
-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 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">>>;
-/**
-* 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">>;
-/**
-* 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 augmented to this
-* type first to ensure both `name` and `value` are available.
-*
-* NOTE: Do not extend from this type directly. Use {@link BaseFullOption}
-* (optionally wrapped in {@link WithUnknownIndex}) instead, otherwise
-* the `unknown` index property will cause issues. See {@link Option} and
-* {@link ValueOption} for examples.
-*
-* @group Option Lists
-*/
-type FullOption<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<BaseOption<N>, "name" | "value">>>;
-/**
-* This type is identical to {@link FullOption} but without the `unknown` index
-* property. Extend from this type instead of {@link FullOption} directly.
-*
-* @group Option Lists
-*/
-type BaseFullOption<N extends string = string> = Simplify<SetRequired<BaseOption<N>, "name" | "value">>;
-/**
-* Utility type to turn an {@link Option}, {@link ValueOption} or
-* {@link BaseOption} into a {@link FullOption}.
-*
-* @group Option Lists
-*/
-type ToFullOption<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt : Opt extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt & FullOption<IdentifierType>> : never;
-/**
-* A group of {@link Option}s, usually within an {@link OptionList}.
-*
-* @group Option Lists
-*/
-interface OptionGroup<Opt extends BaseOption = FlexibleOption> {
-  label: string;
-  options: WithUnknownIndex<Opt>[];
-}
-/**
-* A group of {@link BaseOption}s, usually within a {@link FlexibleOptionList}.
-*
-* @group Option Lists
-*/
-type FlexibleOptionGroup<Opt extends BaseOption | string = BaseOption> = {
-  label: string;
-  options: (Opt extends BaseFullOption ? Opt : ToFlexibleOption<Opt>)[];
-};
-/**
-* 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>[];
-/**
-* 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>>[];
-/**
-* 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>>[];
-/**
-* An array of options or option groups, like {@link OptionList}, but using
-* {@link FullOption} instead of {@link Option}. This means that every member is
-* guaranteed to have both `name` and `value`.
-*
-* @group Option Lists
-*/
-type FullOptionList<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt[] | OptionGroup<Opt>[] : ToFullOption<Opt>[] | OptionGroup<ToFullOption<Opt>>[];
-/**
-* Map of option identifiers to their respective {@link Option}.
-*
-* @group Option Lists
-*/
-type BaseOptionMap<V$1 extends BaseOption = BaseOption, K$1 extends string = GetOptionIdentifierType<V$1>> = { [k in K$1]?: ToFlexibleOption<V$1> };
-//#endregion
-//#region ../core/src/types/ruleGroups.d.ts
-/**
-* Properties common to both rules and groups.
-*/
-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$1 = any, C extends string = string> extends CommonRuleAndGroupProperties {
-  field: F;
-  operator: O;
-  value: V$1;
-  valueSource?: ValueSource;
-  match?: MatchConfig;
-  /**
-  * Only used when adding a rule to a query that uses independent combinators.
-  */
-  combinatorPreceding?: C;
-}
-/**
-* The main rule group type. This type is used for query definitions as well as
-* all sub-groups of queries.
-*/
-interface RuleGroupType<R$1 extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
-  combinator: C;
-  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$1 extends RuleType = RuleType> = (R$1 | RG)[];
-//#endregion
-//#region ../core/src/types/ruleGroupsIC.utils.d.ts
-type MAXIMUM_ALLOWED_BOUNDARY = 80;
-type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [], Count extends ReadonlyArray<number> = []> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result : Tuple extends [] ? [] : Result extends [] ? MappedTuple<Tuple, Tuple, [...Count, 1]> : MappedTuple<Tuple, Result | [...Result, ...Tuple], [...Count, 1]>;
-//#endregion
-//#region ../core/src/types/ruleGroupsIC.d.ts
-/**
-* 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$1 extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R$1, C>, "combinator" | "rules"> {
-  combinator?: undefined;
-  rules: RuleGroupICArray<RuleGroupTypeIC<R$1, C>, R$1, C>;
-  /**
-  * Only used when adding a rule to a query that uses independent combinators
-  */
-  combinatorPreceding?: C;
-}
-/**
-* Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
-*/
-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$1 extends RuleType = RuleType, C extends string = string> = [R$1 | RG] | [R$1 | RG, ...MappedTuple<[C, R$1 | RG]>] | ((R$1 | RG)[] & {
-  length: 0;
-});
-/**
-* Shorthand for "either {@link RuleGroupArray} or {@link RuleGroupICArray}".
-*/
-type RuleOrGroupArray = RuleGroupArray | RuleGroupICArray;
-/**
-* Converts a narrowed rule group type to its most generic form.
-*/
-type GenericizeRuleGroupType<RG> = RG extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
-//#endregion
-//#region ../core/src/types/validation.d.ts
-/**
-* Object with a `valid` boolean value and optional `reasons`.
-*/
-interface ValidationResult {
-  valid: boolean;
-  reasons?: any[];
-}
-/**
-* Map of rule/group `id` to its respective {@link ValidationResult}.
-*/
-type ValidationMap = Record<string, boolean | ValidationResult>;
-/**
-* Function that validates a query.
-*/
-type QueryValidator = (query: RuleGroupTypeAny) => boolean | ValidationMap;
-/**
-* Function that validates a rule.
-*/
-type RuleValidator = (rule: RuleType) => boolean | ValidationResult;
-//#endregion
-//#region ../core/src/types/basic.d.ts
-/**
-* @see https://react-querybuilder.js.org/docs/tips/path
-*/
-type Path = number[];
-/**
-* String of classnames, array of classname strings, or object where the
-* keys are classnames and those with truthy values will be included.
-* Suitable for passing to the `clsx` package.
-*/
-type Classname = string | string[] | Record<string, any>;
-/**
-* A source for the `value` property of a rule.
-*/
-type ValueSource = "value" | "field";
-/**
-* Type of {@link react-querybuilder!ValueEditor ValueEditor} that will be displayed.
-*/
-type ValueEditorType = "text" | "select" | "checkbox" | "radio" | "textarea" | "switch" | "multiselect" | null;
-/**
-* A valid array of potential value sources.
-*
-* @see {@link ValueSource}
-*/
-type ValueSources = ["value"] | ["value", "field"] | ["field", "value"] | ["field"];
-type ValueSourceFlexibleOptions = ToFlexibleOptionArrays<ValueSources>;
-type ValueSourceFullOptions = ToOptionArrays<ValueSources>;
-type ToOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: {
-  name: Sources[K];
-  value: Sources[K];
-  label: string;
-} } : never;
-type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption<Sources[K]> } : never;
-type WithOptionalClassName<T$1> = T$1 & {
-  className?: Classname;
-};
-/**
-* HTML5 input types
-*/
-type InputType = "button" | "checkbox" | "color" | "date" | "datetime-local" | "email" | "file" | "hidden" | "image" | "month" | "number" | "password" | "radio" | "range" | "reset" | "search" | "submit" | "tel" | "text" | "time" | "url" | "week" | "bigint" | (string & {});
-/**
-* Quantification mode describing how many elements of the value array must pass
-* the filter for the rule itself to pass.
-*
-* For "atLeast", "atMost", and "exactly", the threshold value will be converted to
-* a percentage if the number is less than 1. Non-numeric values and numbers less
-* than 0 will be ignored.
-*/
-interface MatchConfig {
-  mode: MatchMode;
-  threshold?: number | null | undefined;
-}
-type MatchMode = "all" | "some" | "none" | "atLeast" | "atMost" | "exactly";
-type MatchModeOptions = StringUnionToFullOptionArray<MatchMode>;
-type ActionElementEventHandler = (event?: any, context?: any) => void;
-type ValueChangeEventHandler = (value?: any, context?: any) => void;
-/**
-* Base for all Field types/interfaces.
-*/
-interface BaseFullField<FieldName extends string = string, OperatorName extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName>, ValueObj extends FullOption = FullOption<ValueName>> extends WithOptionalClassName<BaseFullOption<FieldName>> {
-  id?: string;
-  operators?: FlexibleOptionList<OperatorObj> | OperatorName[] | FlexibleOption<OperatorName>[] | (OperatorName | FlexibleOption<OperatorName>)[];
-  valueEditorType?: ValueEditorType | ((operator: OperatorName) => ValueEditorType);
-  valueSources?: ValueSources | ValueSourceFlexibleOptions | ((operator: OperatorName) => ValueSources | ValueSourceFlexibleOptions);
-  inputType?: InputType | null;
-  values?: FlexibleOptionList<ValueObj>;
-  matchModes?: boolean | MatchMode[] | FlexibleOption<MatchMode>[];
-  /** Properties of items in the value. */
-  subproperties?: FlexibleOptionList<FullField>;
-  defaultOperator?: OperatorName;
-  defaultValue?: any;
-  placeholder?: string;
-  validator?: RuleValidator;
-  comparator?: string | ((f: FullField, operator: string) => boolean);
-}
-/**
-* 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
-* `label` are required.
-*
-* The `name`/`value`, `operators`, and `values` properties of this interface
-* can be narrowed with generics.
-*
-* @group Option Lists
-*/
-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>>;
-/**
-* Allowed values of the {@link FullOperator} property `arity`. A value of `"unary"` or
-* 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 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.
-*
-* The `name`/`value` properties of this interface can be narrowed with generics.
-*
-* @group Option Lists
-*/
-interface FullOperator<N extends string = string> extends WithOptionalClassName<FullOption<N>> {
-  arity?: Arity;
-}
-/**
-* 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.
-*
-* The `name`/`value` properties of this interface can be narrowed with generics.
-*
-* @group Option Lists
-*/
-type FullCombinator<N extends string = string> = WithOptionalClassName<FullOption<N>>;
-type ParseNumberMethodName = "enhanced" | "native" | "strict";
-/**
-* Parsing algorithms used by {@link parseNumber}.
-*/
-
-type ParseNumbersModerationLevel = "-limited" | "";
-/**
-* Options for the `parseNumbers` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
-*/
-type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
-/**
-* 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;
-  qbId: string;
-}) => string;
-//#endregion
-//#region ../core/src/types/dnd.d.ts
-type DropEffect = "move" | "copy";
-//#endregion
-//#region ../core/src/types/queryBuilder.d.ts
-/**
-* Base interface for all rule subcomponents.
-*
-* @group Props
-*/
-interface CommonRuleSubComponentProps {
-  rule: RuleType;
-}
-/**
-* Classnames applied to each component.
-*
-* @group Props
-*/
-interface Classnames {
-  /**
-  * Classnames applied to the root `<div>` element.
-  */
-  queryBuilder: Classname;
-  /**
-  * Classnames applied to the `<div>` containing the RuleGroup.
-  */
-  ruleGroup: Classname;
-  /**
-  * Classnames applied to the `<div>` containing the RuleGroup header controls.
-  */
-  header: Classname;
-  /**
-  * Classnames applied to the `<div>` containing the RuleGroup child rules/groups.
-  */
-  body: Classname;
-  /**
-  * Classnames applied to the `<select>` control for combinators.
-  */
-  combinators: Classname;
-  /**
-  * Classnames applied to the `<button>` to add a Rule.
-  */
-  addRule: Classname;
-  /**
-  * Classnames applied to the `<button>` to add a RuleGroup.
-  */
-  addGroup: Classname;
-  /**
-  * Classnames applied to the `<button>` to clone a Rule.
-  */
-  cloneRule: Classname;
-  /**
-  * Classnames applied to the `<button>` to clone a RuleGroup.
-  */
-  cloneGroup: Classname;
-  /**
-  * Classnames applied to the `<button>` to remove a RuleGroup.
-  */
-  removeGroup: Classname;
-  /**
-  * Classnames applied to the `<div>` containing the Rule.
-  */
-  rule: Classname;
-  /**
-  * Classnames applied to the `<select>` control for fields.
-  */
-  fields: Classname;
-  /**
-  * Classnames applied to the `<select>` control for match modes.
-  */
-  matchMode: Classname;
-  /**
-  * Classnames applied to the `<input>` for match thresholds.
-  */
-  matchThreshold: Classname;
-  /**
-  * Classnames applied to the `<select>` control for operators.
-  */
-  operators: Classname;
-  /**
-  * Classnames applied to the `<input>` for the rule value.
-  */
-  value: Classname;
-  /**
-  * Classnames applied to the `<button>` to remove a Rule.
-  */
-  removeRule: Classname;
-  /**
-  * Classnames applied to the `<label>` on the "not" toggle.
-  */
-  notToggle: Classname;
-  /**
-  * Classnames applied to the `<span>` handle for dragging rules/groups.
-  */
-  shiftActions: Classname;
-  /**
-  * Classnames applied to the `<span>` handle for dragging rules/groups.
-  */
-  dragHandle: Classname;
-  /**
-  * Classnames applied to the `<button>` to lock/disable a Rule.
-  */
-  lockRule: Classname;
-  /**
-  * Classnames applied to the `<button>` to lock/disable a RuleGroup.
-  */
-  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;
-  /**
-  * Classnames applied to all action elements.
-  */
-  actionElement: Classname;
-  /**
-  * Classnames applied to all select elements.
-  */
-  valueSelector: Classname;
-  /**
-  * Classname(s) applied to inline combinator elements.
-  */
-  betweenRules: Classname;
-  /**
-  * Classname(s) applied to valid rules and groups.
-  */
-  valid: Classname;
-  /**
-  * Classname(s) applied to invalid rules and groups.
-  */
-  invalid: Classname;
-  /**
-  * Classname(s) applied to rules and groups while being dragged.
-  */
-  dndDragging: Classname;
-  /**
-  * Classname(s) applied to rules and groups hovered over by a dragged element.
-  */
-  dndOver: Classname;
-  /**
-  * Classname(s) applied to rules and groups hovered over by a dragged element
-  * when the drop effect is "copy" (modifier key is pressed).
-  */
-  dndCopy: Classname;
-  /**
-  * Classname(s) applied to rules and groups hovered over by a dragged element
-  * when the Ctrl key is pressed, indicating the items will form a new group.
-  */
-  dndGroup: Classname;
-  /**
-  * Classname(s) applied to rules and groups that cannot accept a drop from
-  * the dragged element hovering over it.
-  */
-  dndDropNotAllowed: Classname;
-  /**
-  * Classname(s) applied to disabled elements.
-  */
-  disabled: Classname;
-  /**
-  * Classname(s) applied to muted elements.
-  */
-  muted: Classname;
-  /**
-  * Classname(s) applied to each element in a series of value editors.
-  */
-  valueListItem: Classname;
-  /**
-  * Not applied, but see CSS styles.
-  */
-  branches: Classname;
-  /**
-  * Classname(s) applied to rules that render a subquery.
-  */
-  hasSubQuery: Classname;
-  /**
-  * Classname(s) applied to async components in their "loading" state.
-  */
-  loading: 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;
-}
-/**
-* Functions included in the `actions` prop passed to every subcomponent.
-*
-* @group Props
-*/
-interface QueryActions {
-  onGroupAdd(group: RuleGroupTypeAny, parentPath: Path, context?: any): void;
-  onGroupRemove(path: Path): void;
-  onPropChange(prop: Exclude<keyof RuleType | keyof RuleGroupType, "id" | "path">, value: any, path: Path, context?: any): void;
-  onRuleAdd(rule: RuleType, parentPath: Path, context?: any): void;
-  onRuleRemove(path: Path): void;
-  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 ../core/src/utils/queryTools.d.ts
-/**
-* Options for {@link move}.
-*
-* @group Query Tools
-*/
-interface MoveOptions {
-  /**
-  * When `true`, the source rule/group will not be removed from its original path.
-  */
-  clone?: boolean;
-  /**
-  * If the query extends `RuleGroupTypeIC` (i.e. the query is using independent
-  * combinators), then the first combinator in this list will be inserted before
-  * the rule/group if necessary.
-  */
-  combinators?: OptionList;
-  /**
-  * ID generator.
-  */
-  idGenerator?: () => string;
-}
-/**
-* Options for {@link group}.
-*
-* @group Query Tools
-*/
-interface GroupOptions {
-  /**
-  * When `true`, the source rule/group will not be removed from its original path.
-  */
-  clone?: boolean;
-  /**
-  * If the query extends `RuleGroupTypeIC` (i.e. the query is using independent
-  * combinators), then the first combinator in this list will be inserted between
-  * the two rules/groups.
-  */
-  combinators?: OptionList;
-  /**
-  * ID generator.
-  */
-  idGenerator?: () => string;
-}
-//#endregion
-//#region ../react-querybuilder/src/components/RuleGroup.d.ts
-interface UseRuleGroup extends RuleGroupProps {
-  addGroup: ActionElementEventHandler;
-  addRule: ActionElementEventHandler;
-  accessibleDescription: string;
-  muted?: boolean;
-  classNames: Pick<{ [k in keyof Classnames]: string }, "header" | "shiftActions" | "dragHandle" | "combinators" | "notToggle" | "addRule" | "addGroup" | "cloneGroup" | "lockGroup" | "muteGroup" | "removeGroup" | "body">;
-  cloneGroup: ActionElementEventHandler;
-  onCombinatorChange: ValueChangeEventHandler;
-  onGroupAdd: (group: RuleGroupTypeAny, parentPath: Path, context?: any) => void;
-  onIndependentCombinatorChange: (value: any, index: number, context?: any) => void;
-  onNotToggleChange: (checked: boolean, context?: any) => void;
-  outerClassName: string;
-  pathsMemo: {
-    path: Path;
-    disabled: boolean;
-  }[];
-  removeGroup: ActionElementEventHandler;
-  ruleGroup: RuleGroupType | RuleGroupTypeIC;
-  shiftGroupDown: (event?: MouseEvent, context?: any) => void;
-  shiftGroupUp: (event?: MouseEvent, context?: any) => void;
-  toggleLockGroup: ActionElementEventHandler;
-  toggleMuteGroup: ActionElementEventHandler;
-  validationClassName: string;
-  validationResult: boolean | ValidationResult;
-}
-//#endregion
-//#region ../react-querybuilder/src/types/props.d.ts
-/**
-* Base interface for all subcomponents.
-*
-* @group Props
-*/
-interface CommonSubComponentProps<F extends FullOption = FullField, O extends string = string> {
-  /**
-  * CSS classNames to be applied.
-  *
-  * This is `string` and not {@link Classname} because the {@link Rule}
-  * and {@link RuleGroup} components run `clsx()` to produce the `className`
-  * that gets passed to each subcomponent.
-  */
-  className?: string;
-  /**
-  * Path to this subcomponent's rule/group within the query.
-  */
-  path: Path;
-  /**
-  * The level of the current group. Always equal to `path.length`.
-  */
-  level: number;
-  /**
-  * The title/tooltip for this control.
-  */
-  title?: string;
-  /**
-  * Disables the control.
-  */
-  disabled?: boolean;
-  /**
-  * Container for custom props that are passed to all components.
-  */
-  context?: any;
-  /**
-  * Validation result of the parent rule/group.
-  */
-  validation?: boolean | ValidationResult;
-  /**
-  * Test ID for this component.
-  */
-  testID?: string;
-  /**
-  * All subcomponents receive the configuration schema as a prop.
-  */
-  schema: Schema<F, O>;
-}
-/**
-* Base interface for selectors and editors.
-*
-* @group Props
-*/
-interface SelectorOrEditorProps<F extends FullOption = FullField, O extends string = string> extends CommonSubComponentProps<F, O> {
-  value?: string;
-  handleOnChange(value: any): void;
-}
-/**
-* Base interface for selector components.
-*/
-interface BaseSelectorProps<OptType extends Option> extends SelectorOrEditorProps<ToFullOption<OptType>> {
-  options: FullOptionList<OptType>;
-}
-/**
-* Props for all `value` selector components.
-*
-* @group Props
-*/
-interface ValueSelectorProps<OptType extends Option = FullOption> extends BaseSelectorProps<OptType> {
-  multiple?: boolean;
-  listsAsArrays?: boolean;
-}
-/**
-* Props for `combinatorSelector` components.
-*
-* @group Props
-*/
-interface CombinatorSelectorProps extends BaseSelectorProps<FullOption> {
-  options: FullOptionList<FullCombinator>;
-  rules: RuleOrGroupArray;
-  ruleGroup: RuleGroupTypeAny;
-}
-/**
-* Props for `fieldSelector` components.
-*
-* @group Props
-*/
-interface FieldSelectorProps<F extends FullField = FullField> extends BaseSelectorProps<F>, CommonRuleSubComponentProps {
-  operator?: F extends FullField<string, infer OperatorName> ? OperatorName : string;
-}
-/**
-* Props for `matchModeEditor` components.
-*
-* @group Props
-*/
-interface MatchModeEditorProps extends BaseSelectorProps<FullOption>, CommonRuleSubComponentProps {
-  match: MatchConfig;
-  selectorComponent?: ComponentType<ValueSelectorProps>;
-  numericEditorComponent?: ComponentType<ValueEditorProps>;
-  classNames: {
-    matchMode: string;
-    matchThreshold: string;
-  };
-  options: FullOptionList<FullOption<MatchMode>>;
-  field: string;
-  fieldData: FullField;
-}
-/**
-* Props for `operatorSelector` components.
-*
-* @group Props
-*/
-interface OperatorSelectorProps extends BaseSelectorProps<FullOption>, CommonRuleSubComponentProps {
-  options: FullOptionList<FullOperator>;
-  field: string;
-  fieldData: FullField;
-}
-/**
-* Props for `valueSourceSelector` components.
-*
-* @group Props
-*/
-interface ValueSourceSelectorProps extends BaseSelectorProps<FullOption>, CommonRuleSubComponentProps {
-  options: FullOptionList<FullOption<ValueSource>>;
-  field: string;
-  fieldData: FullField;
-}
-/**
-* A translation for a component with `title` and `label`.
-*
-* @group Props
-*/
-interface TranslationWithLabel extends BaseTranslationWithLabel<ReactNode> {}
-/**
-* The shape of the `translations` prop.
-*
-* @group Props
-*/
-interface Translations extends BaseTranslations<ReactNode> {}
-/**
-* Props passed to every action component (rendered as `<button>` by default).
-*
-* @group Props
-*/
-interface ActionProps extends CommonSubComponentProps {
-  /** Visible text. */
-  label?: ReactNode;
-  /**
-  * Triggers the action, e.g. the addition of a new rule or group. The second parameter
-  * will be forwarded to the `onAddRule` or `onAddGroup` callback if appropriate.
-  */
-  handleOnClick(e?: MouseEvent, context?: any): void;
-  /**
-  * Translation which overrides the regular `label`/`title` props when
-  * the element is disabled.
-  */
-  disabledTranslation?: TranslationWithLabel;
-  /**
-  * The {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
-  * associated with this element.
-  */
-  ruleOrGroup: RuleGroupTypeAny | RuleType;
-  /**
-  * Rules in this group (if the action element is for a group).
-  */
-  rules?: RuleOrGroupArray;
-}
-/**
-* Props for `notToggle` components.
-*
-* @group Props
-*/
-interface NotToggleProps extends CommonSubComponentProps {
-  checked?: boolean;
-  handleOnChange(checked: boolean): void;
-  label?: ReactNode;
-  ruleGroup: RuleGroupTypeAny;
-}
-/**
-* Props passed to `shiftActions` components.
-*
-* @group Props
-*/
-interface ShiftActionsProps extends CommonSubComponentProps {
-  /**
-  * Visible text for "shift up"/"shift down" elements.
-  */
-  labels?: {
-    shiftUp?: ReactNode;
-    shiftDown?: ReactNode;
-  };
-  /**
-  * Tooltips for "shift up"/"shift down" elements.
-  */
-  titles?: {
-    shiftUp?: string;
-    shiftDown?: string;
-  };
-  /**
-  * The {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
-  * associated with this element.
-  */
-  ruleOrGroup: RuleGroupTypeAny | RuleType;
-  /**
-  * Method to shift the rule/group up one place.
-  */
-  shiftUp?: () => void;
-  /**
-  * Method to shift the rule/group down one place.
-  */
-  shiftDown?: () => void;
-  /**
-  * Whether shifting the rule/group up is disallowed.
-  */
-  shiftUpDisabled?: boolean;
-  /**
-  * Whether shifting the rule/group down is disallowed.
-  */
-  shiftDownDisabled?: boolean;
-}
-/**
-* Props for `dragHandle` components.
-*
-* @group Props
-*/
-interface DragHandleProps extends CommonSubComponentProps {
-  label?: ReactNode;
-  ruleOrGroup: RuleGroupTypeAny | RuleType;
-}
-/**
-* Props passed to `inlineCombinator` components.
-*
-* @group Props
-*/
-interface InlineCombinatorProps extends CombinatorSelectorProps {
-  component: ComponentType<CombinatorSelectorProps>;
-}
-/**
-* Props passed to `valueEditor` components.
-*
-* @group Props
-*/
-interface ValueEditorProps<F extends FullField = FullField, O extends string = string> extends SelectorOrEditorProps<F, O>, CommonRuleSubComponentProps {
-  field: GetOptionIdentifierType<F>;
-  operator: O;
-  value?: any;
-  valueSource: ValueSource;
-  /** The entire {@link FullField} object. */
-  fieldData: F;
-  type?: ValueEditorType;
-  inputType?: InputType | null;
-  values?: any[];
-  listsAsArrays?: boolean;
-  parseNumbers?: ParseNumbersPropConfig;
-  separator?: ReactNode;
-  selectorComponent?: ComponentType<ValueSelectorProps>;
-  /**
-  * Only pass `true` if the {@link useValueEditor} hook has already run
-  * in a parent/ancestor component. See usage in the compatibility packages.
-  */
-  skipHook?: boolean;
-  schema: Schema<F, O>;
-}
-/**
-* All subcomponents.
-*
-* @group Props
-*/
-type Controls<F extends FullField, O extends string> = Required<SetNonNullable<ControlElementsProp<F, O>, keyof ControlElementsProp<F, O>>>;
-/**
-* Subcomponents.
-*
-* @group Props
-*/
-type ControlElementsProp<F extends FullField, O extends string> = Partial<{
-  /**
-  * Default component for all button-type controls.
-  *
-  * @default ActionElement
-  */
-  actionElement: ComponentType<ActionProps>;
-  /**
-  * Adds a sub-group to the current group.
-  *
-  * @default ActionElement
-  */
-  addGroupAction: ComponentType<ActionProps> | null;
-  /**
-  * Adds a rule to the current group.
-  *
-  * @default ActionElement
-  */
-  addRuleAction: ComponentType<ActionProps> | null;
-  /**
-  * Clones the current group.
-  *
-  * @default ActionElement
-  */
-  cloneGroupAction: ComponentType<ActionProps> | null;
-  /**
-  * Clones the current rule.
-  *
-  * @default ActionElement
-  */
-  cloneRuleAction: ComponentType<ActionProps> | null;
-  /**
-  * Selects the `combinator` property for the current group, or the current independent combinator value.
-  *
-  * @default ValueSelector
-  */
-  combinatorSelector: ComponentType<CombinatorSelectorProps> | null;
-  /**
-  * Provides a draggable handle for reordering rules and groups.
-  *
-  * @default DragHandle
-  */
-  dragHandle: ForwardRefExoticComponent<DragHandleProps & RefAttributes<HTMLElement>> | null;
-  /**
-  * Selects the `field` property for the current rule.
-  *
-  * @default ValueSelector
-  */
-  fieldSelector: ComponentType<FieldSelectorProps<F>> | null;
-  /**
-  * A small wrapper around the `combinatorSelector` component.
-  *
-  * @default InlineCombinator
-  */
-  inlineCombinator: ComponentType<InlineCombinatorProps> | null;
-  /**
-  * Locks the current group (sets the `disabled` property to `true`).
-  *
-  * @default ActionElement
-  */
-  lockGroupAction: ComponentType<ActionProps> | null;
-  /**
-  * Locks the current rule (sets the `disabled` property to `true`).
-  *
-  * @default ActionElement
-  */
-  lockRuleAction: ComponentType<ActionProps> | null;
-  /**
-  * Mutes the current group (sets the `muted` property to `true`).
-  *
-  * @default ActionElement
-  */
-  muteGroupAction: ComponentType<ActionProps> | null;
-  /**
-  * Mutes the current rule (sets the `muted` property to `true`).
-  *
-  * @default ActionElement
-  */
-  muteRuleAction: ComponentType<ActionProps> | null;
-  /**
-  * Selects the `match` property for the current rule.
-  *
-  * @default MatchModeEditor
-  */
-  matchModeEditor: ComponentType<MatchModeEditorProps> | null;
-  /**
-  * Toggles the `not` property of the current group between `true` and `false`.
-  *
-  * @default NotToggle
-  */
-  notToggle: ComponentType<NotToggleProps> | null;
-  /**
-  * Selects the `operator` property for the current rule.
-  *
-  * @default ValueSelector
-  */
-  operatorSelector: ComponentType<OperatorSelectorProps> | null;
-  /**
-  * Removes the current group from its parent group's `rules` array.
-  *
-  * @default ActionElement
-  */
-  removeGroupAction: ComponentType<ActionProps> | null;
-  /**
-  * Removes the current rule from its parent group's `rules` array.
-  *
-  * @default ActionElement
-  */
-  removeRuleAction: ComponentType<ActionProps> | null;
-  /**
-  * Rule layout component.
-  *
-  * @default Rule
-  */
-  rule: ComponentType<RuleProps>;
-  /**
-  * Rule group layout component.
-  *
-  * @default RuleGroup
-  */
-  ruleGroup: ComponentType<RuleGroupProps<F, O>>;
-  /**
-  * Rule group body components.
-  *
-  * @default RuleGroupBodyComponents
-  */
-  ruleGroupBodyElements: ComponentType<RuleGroupProps & UseRuleGroup>;
-  /**
-  * Rule group header components.
-  *
-  * @default RuleGroupHeaderComponents
-  */
-  ruleGroupHeaderElements: ComponentType<RuleGroupProps & UseRuleGroup>;
-  /**
-  * Shifts the current rule/group up or down in the query hierarchy.
-  *
-  * @default ShiftActions
-  */
-  shiftActions: ComponentType<ShiftActionsProps> | null;
-  /**
-  * Updates the `value` property for the current rule.
-  *
-  * @default ValueEditor
-  */
-  valueEditor: ComponentType<ValueEditorProps<F, O>> | null;
-  /**
-  * Default component for all value selector controls.
-  *
-  * @default ValueSelector
-  */
-  valueSelector: ComponentType<ValueSelectorProps>;
-  /**
-  * Selects the `valueSource` property for the current rule.
-  *
-  * @default ValueSelector
-  */
-  valueSourceSelector: ComponentType<ValueSourceSelectorProps> | null;
-}>;
-/**
-* Configuration options passed in the `schema` prop from
-* {@link QueryBuilder} to each subcomponent.
-*
-* @group Props
-*/
-interface Schema<F extends FullField, O extends string> {
-  qbId: string;
-  fields: FullOptionList<F>;
-  fieldMap: Partial<Record<GetOptionIdentifierType<F>, F>>;
-  classNames: Classnames;
-  combinators: FullOptionList<FullCombinator>;
-  controls: Controls<F, O>;
-  createRule(): RuleType;
-  createRuleGroup(ic?: boolean): RuleGroupTypeAny;
-  dispatchQuery(query: RuleGroupTypeAny): void;
-  getQuery(): RuleGroupTypeAny;
-  getOperators(field: string, meta: {
-    fieldData: F;
-  }): FullOptionList<FullOperator>;
-  getValueEditorType(field: string, operator: string, meta: {
-    fieldData: F;
-  }): ValueEditorType;
-  getValueEditorSeparator(field: string, operator: string, meta: {
-    fieldData: F;
-  }): ReactNode;
-  getValueSources(field: string, operator: string, meta: {
-    fieldData: F;
-  }): ValueSourceFullOptions;
-  getInputType(field: string, operator: string, meta: {
-    fieldData: F;
-  }): InputType | null;
-  getValues(field: string, operator: string, meta: {
-    fieldData: F;
-  }): FullOptionList<Option>;
-  getMatchModes(field: string, misc: {
-    fieldData: F;
-  }): MatchModeOptions;
-  getSubQueryBuilderProps(field: GetOptionIdentifierType<F>, misc: {
-    fieldData: F;
-  }): QueryBuilderProps<RuleGroupTypeAny, FullOption, FullOption, FullOption>;
-  getRuleClassname(rule: RuleType, misc: {
-    fieldData: F;
-  }): Classname;
-  getRuleGroupClassname(ruleGroup: RuleGroupTypeAny): Classname;
-  accessibleDescriptionGenerator: AccessibleDescriptionGenerator;
-  showCombinatorsBetweenRules: boolean;
-  showNotToggle: boolean;
-  showShiftActions: boolean;
-  showCloneButtons: boolean;
-  showLockButtons: boolean;
-  showMuteButtons: boolean;
-  autoSelectField: boolean;
-  autoSelectOperator: boolean;
-  autoSelectValue: boolean;
-  addRuleToNewGroups: boolean;
-  enableDragAndDrop: boolean;
-  validationMap: ValidationMap;
-  independentCombinators: boolean;
-  listsAsArrays: boolean;
-  parseNumbers: ParseNumbersPropConfig;
-  disabledPaths: Path[];
-  suppressStandardClassnames: boolean;
-  maxLevels: number;
-}
-/**
-* Common props between {@link Rule} and {@link RuleGroup}.
-*/
-interface CommonRuleAndGroupProps<F extends FullField = FullField, O extends string = string> {
-  id?: string;
-  path: Path;
-  parentDisabled?: boolean;
-  parentMuted?: boolean;
-  translations: Translations;
-  schema: Schema<F, O>;
-  actions: QueryActions;
-  disabled?: boolean;
-  shiftUpDisabled?: boolean;
-  shiftDownDisabled?: boolean;
-  context?: any;
-}
-/**
-* Return type of {@link @react-querybuilder/dnd!useRuleGroupDnD} hook.
-*/
-interface UseRuleGroupDnD {
-  isDragging: boolean;
-  dragMonitorId: string | symbol;
-  isOver: boolean;
-  dropMonitorId: string | symbol;
-  previewRef: Ref<HTMLDivElement>;
-  dragRef: Ref<HTMLSpanElement>;
-  dropRef: Ref<HTMLDivElement>;
-  /** `"move"` by default; `"copy"` if the modifier key is pressed. */
-  dropEffect?: DropEffect;
-  /** True if the dragged and hovered items should form a new group. */
-  groupItems?: boolean;
-  dropNotAllowed?: boolean;
-}
-/**
-* {@link RuleGroup} props.
-*
-* @group Props
-*/
-interface RuleGroupProps<F extends FullOption = FullOption, O extends string = string> extends CommonRuleAndGroupProps<F, O>, Partial<UseRuleGroupDnD> {
-  ruleGroup: RuleGroupTypeAny<RuleType<GetOptionIdentifierType<F>, O>>;
-  /**
-  * @deprecated Use the `combinator` property of the `ruleGroup` prop instead
-  */
-  combinator?: string;
-  /**
-  * @deprecated Use the `rules` property of the `ruleGroup` prop instead
-  */
-  rules?: RuleOrGroupArray;
-  /**
-  * @deprecated Use the `not` property of the `ruleGroup` prop instead
-  */
-  not?: boolean;
-}
-/**
-* Return type of {@link @react-querybuilder/dnd!useRuleDnD} hook.
-*/
-interface UseRuleDnD {
-  isDragging: boolean;
-  dragMonitorId: string | symbol;
-  isOver: boolean;
-  dropMonitorId: string | symbol;
-  dragRef: Ref<HTMLSpanElement>;
-  dndRef: Ref<HTMLDivElement>;
-  /** `"move"` by default; `"copy"` if the modifier key is pressed. */
-  dropEffect?: DropEffect;
-  /** True if the dragged and hovered items should form a new group. */
-  groupItems?: boolean;
-  dropNotAllowed?: boolean;
-}
-/**
-* {@link Rule} props.
-*
-* @group Props
-*/
-interface RuleProps<F extends string = string, O extends string = string> extends CommonRuleAndGroupProps<FullOption<F>, O>, Partial<UseRuleDnD> {
-  rule: RuleType<F, O>;
-  /**
-  * @deprecated Use the `field` property of the `rule` prop instead
-  */
-  field?: string;
-  /**
-  * @deprecated Use the `operator` property of the `rule` prop instead
-  */
-  operator?: string;
-  /**
-  * @deprecated Use the `value` property of the `rule` prop instead
-  */
-  value?: any;
-  /**
-  * @deprecated Use the `valueSource` property of the `rule` prop instead
-  */
-  valueSource?: ValueSource;
-}
-/**
-* Props passed down through context from a {@link QueryBuilderContextProvider}.
-*
-* @group Props
-*/
-interface QueryBuilderContextProps<F extends FullField = FullField, O extends string = string> extends QueryBuilderFlags {
-  /**
-  * Defines replacement components.
-  */
-  controlElements?: ControlElementsProp<F, O>;
-  /**
-  * This can be used to assign specific CSS classes to various controls
-  * that are rendered by {@link QueryBuilder}.
-  */
-  controlClassnames?: Partial<Classnames>;
-  /**
-  * This can be used to override translatable texts applied to the various
-  * controls that are rendered by {@link QueryBuilder}.
-  */
-  translations?: Partial<Translations>;
-}
-/**
-* @group Props
-*/
-interface QueryBuilderContextProviderProps extends QueryBuilderContextProps {
-  children?: ReactNode;
-}
-/**
-* @group Components
-*/
-type QueryBuilderContextProvider<ExtraProps extends object = Record<string, any>> = ComponentType<QueryBuilderContextProviderProps & ExtraProps>;
-/**
-* Props for {@link QueryBuilder}.
-*
-* Notes:
-* - Only one of `query` or `defaultQuery` should be provided. If `query` is present,
-* then `defaultQuery` should be undefined and vice versa.
-* - If rendered initially with a `query` prop, then `query` must be defined in every
-* subsequent render or warnings will be logged (in non-production modes only).
-*
-* @typeParam RG - The type of the query object, inferred from either the `query` or `defaultQuery` prop.
-* Must extend {@link RuleGroupType} or {@link RuleGroupTypeIC}.
-* @typeParam F - The field type (see {@link Field}).
-* @typeParam O - The operator type (see {@link Operator}).
-* @typeParam C - The combinator type (see {@link Combinator}).
-*
-* @group Props
-*/
-type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O extends FullOperator, C extends FullCombinator> = RG extends RuleGroupType<infer R> | RuleGroupTypeIC<infer R> ? QueryBuilderContextProps<F, GetOptionIdentifierType<O>> & {
-  /**
-  * Initial query object for uncontrolled components.
-  */
-  defaultQuery?: RG;
-  /**
-  * Query object for controlled components.
-  */
-  query?: RG;
-  /**
-  * List of valid {@link FullField}s.
-  *
-  * @default []
-  */
-  fields?: FlexibleOptionListProp<F> | BaseOptionMap<F>;
-  /**
-  * List of valid {@link FullOperator}s.
-  *
-  * @see {@link DefaultOperatorName}
-  *
-  * @default
-  * [
-  *   { name: '=', label: '=' },
-  *   { name: '!=', label: '!=' },
-  *   { name: '<', label: '<' },
-  *   { name: '>', label: '>' },
-  *   { name: '<=', label: '<=' },
-  *   { name: '>=', label: '>=' },
-  *   { name: 'contains', label: 'contains' },
-  *   { name: 'beginsWith', label: 'begins with' },
-  *   { name: 'endsWith', label: 'ends with' },
-  *   { name: 'doesNotContain', label: 'does not contain' },
-  *   { name: 'doesNotBeginWith', label: 'does not begin with' },
-  *   { name: 'doesNotEndWith', label: 'does not end with' },
-  *   { name: 'null', label: 'is null' },
-  *   { name: 'notNull', label: 'is not null' },
-  *   { name: 'in', label: 'in' },
-  *   { name: 'notIn', label: 'not in' },
-  *   { name: 'between', label: 'between' },
-  *   { name: 'notBetween', label: 'not between' },
-  * ]
-  */
-  operators?: FlexibleOptionListProp<O>;
-  /**
-  * List of valid {@link FullCombinator}s.
-  *
-  * @see {@link DefaultCombinatorName}
-  *
-  * @default
-  * [
-  *   {name: 'and', label: 'AND'},
-  *   {name: 'or', label: 'OR'},
-  * ]
-  */
-  combinators?: FlexibleOptionListProp<C>;
-  /**
-  * Default properties applied to all objects in the `fields` prop. Properties on
-  * individual field definitions will override these.
-  */
-  baseField?: Record<string, unknown>;
-  /**
-  * Default properties applied to all objects in the `operators` prop. Properties on
-  * individual operator definitions will override these.
-  */
-  baseOperator?: Record<string, unknown>;
-  /**
-  * Default properties applied to all objects in the `combinators` prop. Properties on
-  * individual combinator definitions will override these.
-  */
-  baseCombinator?: Record<string, unknown>;
-  /**
-  * The default `field` value for new rules. This can be the field `name`
-  * itself or a function that returns a valid {@link FullField} `name` given
-  * the `fields` list.
-  */
-  getDefaultField?: GetOptionIdentifierType<F> | ((fieldsData: FullOptionList<F>) => string);
-  /**
-  * The default `operator` value for new rules. This can be the operator
-  * `name` or a function that returns a valid {@link FullOperator} `name` for
-  * a given field name.
-  */
-  getDefaultOperator?: GetOptionIdentifierType<O> | ((field: GetOptionIdentifierType<F>, misc: {
-    fieldData: F;
-  }) => string);
-  /**
-  * Returns the default `value` for new rules.
-  */
-  getDefaultValue?(rule: R, misc: {
-    fieldData: F;
-  }): any;
-  /**
-  * This function should return the list of allowed {@link FullOperator}s
-  * for the given {@link FullField} `name`. If `null` is returned, the
-  * {@link DefaultOperator}s are used.
-  */
-  getOperators?(field: GetOptionIdentifierType<F>, misc: {
-    fieldData: F;
-  }): FlexibleOptionListProp<FullOperator> | null;
-  /**
-  * This function should return the type of {@link ValueEditor} (see
-  * {@link ValueEditorType}) for the given field `name` and operator `name`.
-  */
-  getValueEditorType?(field: GetOptionIdentifierType<F>, operator: GetOptionIdentifierType<O>, misc: {
-    fieldData: F;
-  }): ValueEditorType;
-  /**
-  * This function should return the separator element for a given field
-  * `name` and operator `name`. The element can be any valid React element,
-  * including a bare string (e.g., "and" or "to") or an HTML element like
-  * `<span />`. It will be placed in between value editors when multiple
-  * editors are rendered, such as when the `operator` is `"between"`.
-  */
-  getValueEditorSeparator?(field: GetOptionIdentifierType<F>, operator: GetOptionIdentifierType<O>, misc: {
-    fieldData: F;
-  }): ReactNode;
-  /**
-  * This function should return the list of valid {@link ValueSources}
-  * for a given field `name` and operator `name`. The return value must
-  * be an array that includes at least one valid {@link ValueSource}
-  * (i.e. `["value"]`, `["field"]`, `["value", "field"]`, or
-  * `["field", "value"]`).
-  */
-  getValueSources?(field: GetOptionIdentifierType<F>, operator: GetOptionIdentifierType<O>, misc: {
-    fieldData: F;
-  }): ValueSources | ValueSourceFlexibleOptions;
-  /**
-  * This function should return the `type` of `<input />`
-  * for the given field `name` and operator `name` (only applicable when
-  * `getValueEditorType` returns `"text"` or a falsy value). If no
-  * function is provided, `"text"` is used as the default.
-  */
-  getInputType?(field: GetOptionIdentifierType<F>, operator: GetOptionIdentifierType<O>, misc: {
-    fieldData: F;
-  }): InputType | null;
-  /**
-  * This function should return the list of allowed values for the
-  * given field `name` and operator `name` (only applicable when
-  * `getValueEditorType` returns `"select"` or `"radio"`). If no
-  * function is provided, an empty array is used as the default.
-  */
-  getValues?(field: GetOptionIdentifierType<F>, operator: GetOptionIdentifierType<O>, misc: {
-    fieldData: F;
-  }): FlexibleOptionListProp<Option>;
-  /**
-  * This function should return the list of valid {@link MatchMode}s or
-  * {@link MatchConfig}s for a given field `name`. The return value must
-  * be an array that includes at least one valid {@link MatchMode}, or `true`
-  * to indicate that all match modes are allowed. Any other return value
-  * will be ignored (no match modes will be allowed).
-  */
-  getMatchModes?(field: GetOptionIdentifierType<F>, misc: {
-    fieldData: F;
-  }): boolean | MatchMode[] | FlexibleOption<MatchMode>[];
-  /**
-  * This function should return any props that a subquery (see {@link MatchMode})
-  * should override from the props provided to this query builder. Note that certain
-  * props like `query`, `onQueryChange`, and `enableDragAndDrop` will be ignored.
-  */
-  getSubQueryBuilderProps?(field: GetOptionIdentifierType<F>, misc: {
-    fieldData: F;
-  }): QueryBuilderProps<GenericizeRuleGroupType<RG>, FullOption, FullOption, FullOption>;
-  /**
-  * The return value of this function will be used to apply classnames to the
-  * outer `<div>` of the given {@link Rule}.
-  */
-  getRuleClassname?(rule: R, misc: {
-    fieldData: F;
-  }): Classname;
-  /**
-  * The return value of this function will be used to apply classnames to the
-  * outer `<div>` of the given {@link RuleGroup}.
-  */
-  getRuleGroupClassname?(ruleGroup: RG): Classname;
-  /**
-  * This callback is invoked before a new rule is added. The function should either manipulate
-  * the rule and return the new object, return `true` to allow the addition to proceed as normal,
-  * or return `false` to cancel the addition of the rule.
-  */
-  onAddRule?(rule: R, parentPath: Path, query: RG, context?: any): RuleType | boolean;
-  /**
-  * This callback is invoked before a new group is added. The function should either manipulate
-  * the group and return the new object, return `true` to allow the addition to proceed as normal,
-  * or return `false` to cancel the addition of the group.
-  */
-  onAddGroup?(ruleGroup: RG, parentPath: Path, query: RG, context?: any): RG | boolean;
-  /**
-  * This callback is invoked before a rule is moved or shifted. The function should return
-  * `true` to allow the move/shift to proceed as normal, `false` to cancel the move/shift, or
-  * a new query object (presumably based on `query` or `nextQuery`) which will become the new
-  * query state.
-  */
-  onMoveRule?(rule: R, fromPath: Path, toPath: Path | "up" | "down", query: RG, nextQuery: RG, options: MoveOptions, context?: any): RG | boolean;
-  /**
-  * This callback is invoked before a group is moved or shifted. The function should return
-  * `true` to allow the move/shift to proceed as normal, `false` to cancel the move/shift, or
-  * a new query object (presumably based on `query` or `nextQuery`) which will become the new
-  * query state.
-  */
-  onMoveGroup?(ruleGroup: RG, fromPath: Path, toPath: Path | "up" | "down", query: RG, nextQuery: RG, options: MoveOptions, context?: any): RG | boolean;
-  /**
-  * This callback is invoked before a rule is grouped with another object. The function should
-  * return `true` to allow the grouping to proceed as normal, `false` to cancel the grouping,
-  * or a new query object (presumably based on `query` or `nextQuery`) which will become the new
-  * query state.
-  */
-  onGroupRule?(rule: R, fromPath: Path, toPath: Path, query: RG, nextQuery: RG, options: GroupOptions, context?: any): RG | boolean;
-  /**
-  * This callback is invoked before a group is grouped with another object. The function should
-  * return `true` to allow the grouping to proceed as normal, `false` to cancel the grouping,
-  * or a new query object (presumably based on `query` or `nextQuery`) which will become the new
-  * query state.
-  */
-  onGroupGroup?(ruleGroup: RG, fromPath: Path, toPath: Path, query: RG, nextQuery: RG, options: GroupOptions, context?: any): RG | boolean;
-  /**
-  * This callback is invoked before a rule or group is removed. The function should return
-  * `true` if the rule or group should be removed or `false` if it should not be removed.
-  */
-  onRemove?(ruleOrGroup: R | RG, path: Path, query: RG, context?: any): boolean;
-  /**
-  * This callback is invoked anytime the query state is updated.
-  */
-  onQueryChange?(query: RG): void;
-  /**
-  * Each log object will be passed to this function when `debugMode` is `true`.
-  *
-  * @default console.log
-  */
-  onLog?(obj: any): void;
-  /**
-  * @deprecated As of v7, this prop is ignored. To enable independent combinators, use
-  * {@link RuleGroupTypeIC} for the `query` or `defaultQuery` prop. The query builder
-  * will detect the query type and behave accordingly.
-  */
-  independentCombinators?: boolean;
-  /**
-  * Disables the entire query builder if true, or the rules and groups at
-  * the specified paths (as well as all child rules/groups and subcomponents)
-  * if an array of paths is provided. If the root path is specified (`disabled={[[]]}`),
-  * no changes to the query are allowed.
-  *
-  * @default false
-  */
-  disabled?: boolean | Path[];
-  /**
-  * Store values as numbers whenever possible.
-  *
-  * _**TIP: Try `"strict-limited"` first.**_
-  *
-  * Options include `true`, `false`, `"enhanced"`, `"native"`, and `"strict"`. The `string` options
-  * can be suffixed with `"-limited"`.
-  *
-  * - `false` avoids numeric parsing
-  * - `true` or `"strict"` parses values using `numeric-quantity`, bailing out (returning the original
-  *   string) when trailing invalid characters are present
-  * - `"enhanced"` is the same as `true`/`"strict"`, but ignores trailing invalid characters (CAUTION:
-  *   this can lead to information loss)
-  * - `"native"` parses values using `parseFloat`, returning `NaN` when parsing fails
-  *
-  * When the value is `true` or a string without the "-limited" suffix, the default {@link ValueEditor}
-  * will attempt to parse *all* inputs as numbers. **CAUTION: This can lead to unexpected behavior.**
-  *
-  * When the value is a string with the "-limited" suffix, the default {@link ValueEditor} will
-  * only attempt to parse inputs as numbers when the `inputType` is `"number"`.
-  *
-  * @default false
-  */
-  parseNumbers?: ParseNumbersPropConfig;
-  /**
-  * Query validation function.
-  */
-  validator?: QueryValidator;
-  /**
-  * `id` generator function. Should always produce a unique/random value.
-  *
-  * @default crypto.randomUUID
-  */
-  idGenerator?: () => string;
-  /**
-  * Generator function for the `title` attribute applied to the outermost `<div>` of each
-  * rule group. As this is intended to help with accessibility, the text output from this
-  * function should be meaningful, descriptive, and unique within the page.
-  */
-  accessibleDescriptionGenerator?: AccessibleDescriptionGenerator;
-  /**
-  * Maximum number of levels deep the query is allowed to go. The minimum is 1; values
-  * less than 1 will be ignored.
-  */
-  maxLevels?: number;
-  /**
-  * Container for custom props that are passed to all components.
-  */
-  context?: any;
-} : never;
-//#endregion
-//#region ../react-querybuilder/src/redux/getRqbStore.d.ts
-declare global {
-  var __RQB_DEVTOOLS__: boolean | undefined;
-}
-/**
-* Gets the singleton React Query Builder store instance.
-* DevTools are enabled if either:
-* - globalThis.__RQB_DEVTOOLS__ is truthy
-* - window.__RQB_DEVTOOLS__ is truthy
-*/
-//#endregion
 //#region src/BootstrapNotToggle.d.ts
 /**
 * @group Components