@react-querybuilder/bootstrap 8.10.0 → 8.11.0

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

@@ -1,27 +1,8 @@
 import * as React from "react";
 import { ComponentType, ForwardRefExoticComponent, MouseEvent, ReactNode, Ref, RefAttributes } from "react";
 
-//#region ../../node_modules/type-fest/source/observable-like.d.ts
-declare global {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-  interface SymbolConstructor {
-    readonly observable: symbol;
-  }
-}
-
-/**
-@remarks
-The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
-As well, some guidance on making an `Observable` to not include `closed` property.
-@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
-@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
-@see https://github.com/benlesh/symbol-observable#making-an-object-observable
-
-@category Observable
-*/
-
-//#endregion
 //#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
+
 /**
 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).
 
@@ -80,7 +61,7 @@ Union extends unknown
 // Infer the `Intersection` type since TypeScript represents the positional
 // arguments of unions of functions as an intersection of the union.
 ) extends ((mergedIntersection: infer Intersection) => void)
-// The `& Union` is to allow indexing by the resulting type
+// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
 ? Intersection & Union : never;
 //#endregion
 //#region ../../node_modules/type-fest/source/keys-of-union.d.ts
@@ -125,6 +106,80 @@ type KeysOfUnion<ObjectType> =
 // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
 keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
 //#endregion
+//#region ../../node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
+//#endregion
+//#region ../../node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+interface Admin {
+	name: string;
+	surname?: string;
+}
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type 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.
@@ -159,8 +214,8 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+type OptionalKeysOf<Type 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
@@ -188,8 +243,8 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+type RequiredKeysOf<Type 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
 /**
@@ -233,29 +288,67 @@ endIfEqual('abc', '123');
 @category Type Guard
 @category Utilities
 */
-type IsNever<T> = [T] extends [never] ? true : false;
+type IsNever<T$1> = [T$1] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/type-fest/source/if-never.d.ts
+//#region ../../node_modules/type-fest/source/if.d.ts
 /**
-An if-else-like type that resolves depending on whether the given type is `never`.
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 
-@see {@link IsNever}
+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 {IfNever} from 'type-fest';
+import {If} from 'type-fest';
 
-type ShouldBeTrue = IfNever<never>;
-//=> true
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
 ```
 
 @category Type Guard
 @category Utilities
 */
-type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+type If<Type 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
 /**
@@ -289,99 +382,7 @@ type UnknownArray = readonly unknown[];
 /**
 Returns whether the given array `T` is readonly.
 */
-type IsArrayReadonly<T extends UnknownArray> = IfNever$1<T, false, T extends unknown[] ? false : true>;
-/**
-An if-else-like type that resolves depending on whether the given array is readonly.
-
-@see {@link IsArrayReadonly}
-
-@example
-```
-import type {ArrayTail} from 'type-fest';
-
-type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-	ArrayTail<TArray> extends infer Tail
-		? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-		: never;
-
-type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
-//=> readonly [number, boolean]
-
-type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
-//=> [number, boolean]
-
-type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
-//=> true
-
-type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
-//=> 'bar'
-```
-*/
-type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
-//#endregion
-//#region ../../node_modules/type-fest/source/is-any.d.ts
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
-
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-//#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> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+type IsArrayReadonly<T$1 extends UnknownArray> = If<IsNever<T$1>, false, T$1 extends unknown[] ? false : true>;
 //#endregion
 //#region ../../node_modules/type-fest/source/simplify.d.ts
 /**
@@ -441,7 +442,38 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see SimplifyDeep
 @category Object
 */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A, B] extends [infer AA, infer BB] ? [AA] extends [never] ? [BB] extends [never] ? true : false : [BB] extends [never] ? false : _IsEqual<AA, BB> : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, 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
 /**
@@ -624,51 +656,6 @@ export type FooBar = Merge<Foo, Bar>;
 */
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/type-fest/source/if-any.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfAny$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-//#endregion
-//#region ../../node_modules/type-fest/source/internal/type.d.ts
-// Should never happen
-
-/**
-An if-else-like type that resolves depending on whether the given type is `any` or `never`.
-
-@example
-```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'VALID'
-
-// When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_ANY'
-
-// When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_NEVER'
-```
-*/
-type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = IsAny<T> extends true ? IfAny : IsNever<T> extends true ? IfNever : IfNotAnyOrNever;
-//#endregion
 //#region ../../node_modules/type-fest/source/internal/object.d.ts
 /**
 Works similar to the built-in `Pick` utility type, except for the following differences:
@@ -707,7 +694,7 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
 */
-type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
+type HomomorphicPick<T$1, Keys extends KeysOfUnion<T$1>> = { [P in keyof T$1 as Extract<P, Keys>]: T$1[P] };
 /**
 Merges user specified options with default options.
 
@@ -760,8 +747,7 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1<SpecifiedOptions, Defaults, IfNever$1<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
->>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
 //#endregion
 //#region ../../node_modules/type-fest/source/except.d.ts
 /**
@@ -791,7 +777,7 @@ type Filtered = Filter<'bar', 'foo'>;
 
 @see {Except}
 */
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type Filter<KeyType$1, ExcludeType> = IsEqual<KeyType$1, ExcludeType> extends true ? never : (KeyType$1 extends ExcludeType ? never : KeyType$1);
 type ExceptOptions = {
   /**
   Disallow assigning non-specified properties.
@@ -860,38 +846,6 @@ type PostPayload = Except<UserData, 'email'>;
 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/require-at-least-one.d.ts
-/**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
-
-@example
-```
-import type {RequireAtLeastOne} from 'type-fest';
-
-type Responder = {
-	text?: () => string;
-	json?: () => string;
-	secure?: boolean;
-};
-
-const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-
-@category Object
-*/
-type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1<KeysType, never, _RequireAtLeastOne<ObjectType, IfAny$1<KeysType, keyof ObjectType, KeysType>>>>;
-type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = {
-  // For each `Key` in `KeysType` make a mapped type:
-[Key in KeysType]-?: Required<Pick<ObjectType, Key>> &
-// 1. Make `Key`'s type required
-// 2. Make all other keys in `KeysType` optional
-Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] &
-// 3. Add the remaining keys not in `KeysType`
-Except<ObjectType, KeysType>;
-//#endregion
 //#region ../../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.
@@ -922,11 +876,13 @@ type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
 
 @category Object
 */
-type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray> : never : Simplify<
+type SetRequired<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify<
 // Pick just the keys that are optional from the base type.
 Except<BaseType, Keys> &
 // Pick the keys that should be required from the base type and make them required.
 Required<HomomorphicPick<BaseType, Keys>>>;
+
 /**
 Remove the optional modifier from the specified keys in an array.
 */
@@ -980,6 +936,7 @@ type AllNonNullable = SetNonNullable<Foo>;
 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},
@@ -987,11 +944,11 @@ type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown
 *
 * @group Option Lists
 */
-type GetOptionIdentifierType<Opt extends BaseOption> = Opt extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
+type GetOptionIdentifierType<Opt$1 extends BaseOption> = Opt$1 extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
 /**
 * Adds an `unknown` index property to an interface.
 */
-type WithUnknownIndex<T> = T & {
+type WithUnknownIndex<T$1> = T$1 & {
   [key: string]: unknown;
 };
 /**
@@ -1023,8 +980,8 @@ type Option<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<B
 type ValueOption<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<BaseOption<N>, "value">>>;
 /**
 * A generic {@link Option} with either a `name` or `value` as its primary identifier.
-* {@link OptionList}-type props on the {@link QueryBuilder} component accept this type,
-* but corresponding props passed down to subcomponents will always be translated
+* {@link OptionList}-type props on the {@link react-querybuilder!QueryBuilder QueryBuilder} component accept this type,
+* but corresponding props passed down to subcomponents will always be augmented
 * to {@link FullOption} first.
 *
 * @group Option Lists
@@ -1036,11 +993,11 @@ type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<Requi
 *
 * @group Option Lists
 */
-type ToFlexibleOption<Opt extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt extends string ? FlexibleOption<Opt> : Opt, "name" | "value">>;
+type ToFlexibleOption<Opt$1 extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt$1 extends string ? FlexibleOption<Opt$1> : Opt$1, "name" | "value">>;
 /**
 * A generic {@link Option} requiring both `name` _and_ `value` properties.
 * Props that extend {@link OptionList} accept {@link BaseOption}, but
-* corresponding props sent to subcomponents will always be translated to this
+* corresponding props sent to subcomponents will always be augmented to this
 * type first to ensure both `name` and `value` are available.
 *
 * NOTE: Do not extend from this type directly. Use {@link BaseFullOption}
@@ -1064,45 +1021,45 @@ type BaseFullOption<N extends string = string> = Simplify<SetRequired<BaseOption
 *
 * @group Option Lists
 */
-type ToFullOption<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt : Opt extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt & FullOption<IdentifierType>> : never;
+type ToFullOption<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1 : Opt$1 extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt$1 & FullOption<IdentifierType>> : never;
 /**
 * A group of {@link Option}s, usually within an {@link OptionList}.
 *
 * @group Option Lists
 */
-interface OptionGroup<Opt extends BaseOption = FlexibleOption> {
+interface OptionGroup<Opt$1 extends BaseOption = FlexibleOption> {
   label: string;
-  options: WithUnknownIndex<Opt>[];
+  options: WithUnknownIndex<Opt$1>[];
 }
 /**
 * A group of {@link BaseOption}s, usually within a {@link FlexibleOptionList}.
 *
 * @group Option Lists
 */
-type FlexibleOptionGroup<Opt extends BaseOption | string = BaseOption> = {
+type FlexibleOptionGroup<Opt$1 extends BaseOption | string = BaseOption> = {
   label: string;
-  options: (Opt extends BaseFullOption ? Opt : ToFlexibleOption<Opt>)[];
+  options: (Opt$1 extends BaseFullOption ? Opt$1 : ToFlexibleOption<Opt$1>)[];
 };
 /**
 * Either an array of {@link Option}s or an array of {@link OptionGroup}s.
 *
 * @group Option Lists
 */
-type OptionList<Opt extends Option = Option> = Opt[] | OptionGroup<Opt>[];
+type OptionList<Opt$1 extends Option = Option> = Opt$1[] | OptionGroup<Opt$1>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionList<Opt extends BaseOption> = ToFlexibleOption<Opt>[] | FlexibleOptionGroup<ToFlexibleOption<Opt>>[];
+type FlexibleOptionList<Opt$1 extends BaseOption> = ToFlexibleOption<Opt$1>[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1>>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>>[];
+type FlexibleOptionListProp<Opt$1 extends BaseOption> = (ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>>[];
 /**
 * An array of options or option groups, like {@link OptionList}, but using
 * {@link FullOption} instead of {@link Option}. This means that every member is
@@ -1110,13 +1067,13 @@ type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | G
 *
 * @group Option Lists
 */
-type FullOptionList<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt[] | OptionGroup<Opt>[] : ToFullOption<Opt>[] | OptionGroup<ToFullOption<Opt>>[];
+type FullOptionList<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1[] | OptionGroup<Opt$1>[] : ToFullOption<Opt$1>[] | OptionGroup<ToFullOption<Opt$1>>[];
 /**
 * Map of option identifiers to their respective {@link Option}.
 *
 * @group Option Lists
 */
-type BaseOptionMap<V extends BaseOption = BaseOption, K extends string = GetOptionIdentifierType<V>> = { [k in K]?: ToFlexibleOption<V> };
+type BaseOptionMap<V$1 extends BaseOption = BaseOption, K$1 extends string = GetOptionIdentifierType<V$1>> = { [k in K$1]?: ToFlexibleOption<V$1> };
 //#endregion
 //#region ../core/src/types/ruleGroups.d.ts
 /**
@@ -1137,10 +1094,10 @@ interface CommonRuleAndGroupProperties {
 * The main rule type. The `field`, `operator`, and `value` properties
 * can be narrowed with generics.
 */
-interface RuleType<F extends string = string, O extends string = string, V = any, C extends string = string> extends CommonRuleAndGroupProperties {
+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;
+  value: V$1;
   valueSource?: ValueSource;
   match?: MatchConfig;
   /**
@@ -1152,15 +1109,15 @@ interface RuleType<F extends string = string, O extends string = string, V = any
 * The main rule group type. This type is used for query definitions as well as
 * all sub-groups of queries.
 */
-interface RuleGroupType<R extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
+interface RuleGroupType<R$1 extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
   combinator: C;
-  rules: RuleGroupArray<RuleGroupType<R, C>, R>;
+  rules: RuleGroupArray<RuleGroupType<R$1, C>, R$1>;
   not?: boolean;
 }
 /**
 * The type of the `rules` array in a {@link RuleGroupType}.
 */
-type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType = RuleType> = (R | RG)[];
+type RuleGroupArray<RG$1 extends RuleGroupType = RuleGroupType, R$1 extends RuleType = RuleType> = (R$1 | RG$1)[];
 //#endregion
 //#region ../core/src/types/ruleGroupsIC.utils.d.ts
 type MAXIMUM_ALLOWED_BOUNDARY = 80;
@@ -1171,9 +1128,9 @@ type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [
 * The main rule group interface when using independent combinators. This type is used
 * for query definitions as well as all sub-groups of queries.
 */
-interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R, C>, "combinator" | "rules"> {
+interface RuleGroupTypeIC<R$1 extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R$1, C>, "combinator" | "rules"> {
   combinator?: undefined;
-  rules: RuleGroupICArray<RuleGroupTypeIC<R, C>, R, C>;
+  rules: RuleGroupICArray<RuleGroupTypeIC<R$1, C>, R$1, C>;
   /**
   * Only used when adding a rule to a query that uses independent combinators
   */
@@ -1182,11 +1139,11 @@ interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = stri
 /**
 * Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
 */
-type RuleGroupTypeAny<R extends RuleType = RuleType, C extends string = string> = RuleGroupType<R, C> | RuleGroupTypeIC<R, C>;
+type RuleGroupTypeAny<R$1 extends RuleType = RuleType, C extends string = string> = RuleGroupType<R$1, C> | RuleGroupTypeIC<R$1, C>;
 /**
 * The type of the `rules` array in a {@link RuleGroupTypeIC}.
 */
-type RuleGroupICArray<RG extends RuleGroupTypeIC = RuleGroupTypeIC, R extends RuleType = RuleType, C extends string = string> = [R | RG] | [R | RG, ...MappedTuple<[C, R | RG]>] | ((R | RG)[] & {
+type RuleGroupICArray<RG$1 extends RuleGroupTypeIC = RuleGroupTypeIC, R$1 extends RuleType = RuleType, C extends string = string> = [R$1 | RG$1] | [R$1 | RG$1, ...MappedTuple<[C, R$1 | RG$1]>] | ((R$1 | RG$1)[] & {
   length: 0;
 });
 /**
@@ -1196,7 +1153,7 @@ type RuleOrGroupArray = RuleGroupArray | RuleGroupICArray;
 /**
 * Converts a narrowed rule group type to its most generic form.
 */
-type GenericizeRuleGroupType<RG> = RG extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
+type GenericizeRuleGroupType<RG$1> = RG$1 extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
 //#endregion
 //#region ../core/src/types/validation.d.ts
 /**
@@ -1235,7 +1192,7 @@ type Classname = string | string[] | Record<string, any>;
 */
 type ValueSource = "value" | "field";
 /**
-* Type of {@link ValueEditor} that will be displayed.
+* Type of {@link react-querybuilder!ValueEditor ValueEditor} that will be displayed.
 */
 type ValueEditorType = "text" | "select" | "checkbox" | "radio" | "textarea" | "switch" | "multiselect" | null;
 /**
@@ -1252,7 +1209,7 @@ type ToOptionArrays<Sources extends readonly string[]> = Sources extends unknown
   label: string;
 } } : never;
 type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption<Sources[K]> } : never;
-type WithOptionalClassName<T> = T & {
+type WithOptionalClassName<T$1> = T$1 & {
   className?: Classname;
 };
 /**
@@ -1278,24 +1235,24 @@ 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>> {
+interface BaseFullField<FieldName extends string = string, OperatorName$1 extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName$1>, 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);
+  operators?: FlexibleOptionList<OperatorObj> | OperatorName$1[] | FlexibleOption<OperatorName$1>[] | (OperatorName$1 | FlexibleOption<OperatorName$1>)[];
+  valueEditorType?: ValueEditorType | ((operator: OperatorName$1) => ValueEditorType);
+  valueSources?: ValueSources | ValueSourceFlexibleOptions | ((operator: OperatorName$1) => ValueSources | ValueSourceFlexibleOptions);
   inputType?: InputType | null;
   values?: FlexibleOptionList<ValueObj>;
   matchModes?: boolean | MatchMode[] | FlexibleOption<MatchMode>[];
   /** Properties of items in the value. */
   subproperties?: FlexibleOptionList<FullField>;
-  defaultOperator?: OperatorName;
+  defaultOperator?: OperatorName$1;
   defaultValue?: any;
   placeholder?: string;
   validator?: RuleValidator;
   comparator?: string | ((f: FullField, operator: string) => boolean);
 }
 /**
-* Full field definition used in the `fields` prop of {@link QueryBuilder}.
+* Full field definition used in the `fields` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type requires both `name` and `value`, but the `fields` prop itself
 * can use a {@link FlexibleOption} where only one of `name` or `value` is
 * required (along with `label`), or {@link Field} where only `name` and
@@ -1306,15 +1263,15 @@ interface BaseFullField<FieldName extends string = string, OperatorName extends
 *
 * @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>>;
+type FullField<FieldName extends string = string, OperatorName$1 extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName$1>, ValueObj extends FullOption = FullOption<ValueName>> = Simplify<FullOption<FieldName> & BaseFullField<FieldName, OperatorName$1, 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 ValueEditor} to render `null`.
+* a number less than two will cause the default {@link react-querybuilder!ValueEditor ValueEditor} to render `null`.
 */
 type Arity = number | "unary" | "binary" | "ternary";
 /**
 * Full operator definition used in the `operators`/`getOperators` props of
-* {@link QueryBuilder}. This type requires both `name` and `value`, but the
+* {@link react-querybuilder!QueryBuilder QueryBuilder}. This type requires both `name` and `value`, but the
 * `operators`/`getOperators` props themselves can use a {@link FlexibleOption}
 * where only one of `name` or `value` is required, or {@link FullOperator} where
 * only `name` is required.
@@ -1327,7 +1284,7 @@ interface FullOperator<N extends string = string> extends WithOptionalClassName<
   arity?: Arity;
 }
 /**
-* Full combinator definition used in the `combinators` prop of {@link QueryBuilder}.
+* Full combinator definition used in the `combinators` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type requires both `name` and `value`, but the `combinators` prop itself
 * can use a {@link FlexibleOption} where only one of `name` or `value` is required,
 * or {@link Combinator} where only `name` is required.
@@ -1344,12 +1301,12 @@ type ParseNumberMethodName = "enhanced" | "native" | "strict";
 
 type ParseNumbersModerationLevel = "-limited" | "";
 /**
-* Options for the `parseNumbers` prop of {@link QueryBuilder}.
+* Options for the `parseNumbers` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 */
 type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
 /**
-* Signature of `accessibleDescriptionGenerator` prop, used by {@link QueryBuilder} to generate
-* accessible descriptions for each {@link RuleGroup}.
+* Signature of `accessibleDescriptionGenerator` prop, used by {@link react-querybuilder!QueryBuilder QueryBuilder} to generate
+* accessible descriptions for each {@link react-querybuilder!RuleGroup RuleGroup}.
 */
 type AccessibleDescriptionGenerator = (props: {
   path: Path;
@@ -1359,7 +1316,7 @@ type AccessibleDescriptionGenerator = (props: {
 //#region ../core/src/types/dnd.d.ts
 type DropEffect = "move" | "copy";
 //#endregion
-//#region ../core/src/types/props.d.ts
+//#region ../core/src/types/queryBuilder.d.ts
 /**
 * Base interface for all rule subcomponents.
 *
@@ -1629,6 +1586,113 @@ interface QueryActions {
   moveRule(oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any): void;
   groupRule(sourcePath: Path, targetPath: Path, clone?: boolean, context?: any): void;
 }
+interface QueryBuilderFlags {
+  /**
+  * Set to `false` to avoid calling the `onQueryChange` callback
+  * when the component mounts.
+  *
+  * @default true
+  */
+  enableMountQueryChange?: boolean;
+  /**
+  * Enables drag-and-drop features.
+  *
+  * @default false
+  */
+  enableDragAndDrop?: boolean;
+  /**
+  * Enables debug logging for query builders (and React DnD when applicable).
+  *
+  * @default false
+  */
+  debugMode?: boolean;
+  /**
+  * Show group combinator selectors in the body of the group, between each child rule/group,
+  * instead of in the group header.
+  *
+  * @default false
+  */
+  showCombinatorsBetweenRules?: boolean;
+  /**
+  * Show the "not" (aka inversion) toggle for rule groups.
+  *
+  * @default false
+  */
+  showNotToggle?: boolean;
+  /**
+  * Show the "Shift up"/"Shift down" actions.
+  *
+  * @default false
+  */
+  showShiftActions?: boolean;
+  /**
+  * Show the "Clone rule" and "Clone group" buttons.
+  *
+  * @default false
+  */
+  showCloneButtons?: boolean;
+  /**
+  * Show the "Lock rule" and "Lock group" buttons.
+  *
+  * @default false
+  */
+  showLockButtons?: boolean;
+  /**
+  * Show the "Mute rule" and "Mute group" buttons.
+  *
+  * @default false
+  */
+  showMuteButtons?: boolean;
+  /**
+  * Reset the `operator` and `value` when the `field` changes.
+  *
+  * @default true
+  */
+  resetOnFieldChange?: boolean;
+  /**
+  * Reset the `value` when the `operator` changes.
+  *
+  * @default false
+  */
+  resetOnOperatorChange?: boolean;
+  /**
+  * Select the first field in the array automatically.
+  *
+  * @default true
+  */
+  autoSelectField?: boolean;
+  /**
+  * Select the first operator in the array automatically.
+  *
+  * @default true
+  */
+  autoSelectOperator?: boolean;
+  /**
+  * Select the first value in the array automatically. Only applicable when the value editor renders a select list.
+  *
+  * @default false
+  */
+  autoSelectValue?: boolean;
+  /**
+  * Adds a new default rule automatically to each new group.
+  *
+  * @default false
+  */
+  addRuleToNewGroups?: boolean;
+  /**
+  * Store list-type values as native arrays instead of comma-separated strings.
+  *
+  * @default false
+  */
+  listsAsArrays?: boolean;
+  /**
+  * Prevent _any_ assignment of standard classes to elements. This includes conditional
+  * and event-based classes for validation, drag-and-drop, etc.
+  *
+  * @default false
+  */
+  suppressStandardClassnames?: boolean;
+}
 //#endregion
 //#region ../core/src/utils/queryTools.d.ts
 /**
@@ -2296,19 +2360,12 @@ interface RuleProps<F extends string = string, O extends string = string> extend
 *
 * @group Props
 */
-interface QueryBuilderContextProps<F extends FullField, O extends string> {
+interface QueryBuilderContextProps<F extends FullField = FullField, O extends string = string> extends QueryBuilderFlags {
   /**
   * Defines replacement components.
   */
   controlElements?: ControlElementsProp<F, O>;
   /**
-  * Set to `false` to avoid calling the `onQueryChange` callback
-  * when the component mounts.
-  *
-  * @default true
-  */
-  enableMountQueryChange?: boolean;
-  /**
   * This can be used to assign specific CSS classes to various controls
   * that are rendered by {@link QueryBuilder}.
   */
@@ -2318,23 +2375,11 @@ interface QueryBuilderContextProps<F extends FullField, O extends string> {
   * controls that are rendered by {@link QueryBuilder}.
   */
   translations?: Partial<Translations>;
-  /**
-  * Enables drag-and-drop features.
-  *
-  * @default false
-  */
-  enableDragAndDrop?: boolean;
-  /**
-  * Enables debug logging for {@link QueryBuilder} (and React DnD when applicable).
-  *
-  * @default false
-  */
-  debugMode?: boolean;
 }
 /**
 * @group Props
 */
-interface QueryBuilderContextProviderProps extends QueryBuilderContextProps<FullField, string> {
+interface QueryBuilderContextProviderProps extends QueryBuilderContextProps {
   children?: ReactNode;
 }
 /**
@@ -2358,15 +2403,15 @@ type QueryBuilderContextProvider<ExtraProps extends object = Record<string, any>
 *
 * @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>> & {
+type QueryBuilderProps<RG$1 extends RuleGroupTypeAny, F extends FullField, O extends FullOperator, C extends FullCombinator> = RG$1 extends RuleGroupType<infer R> | RuleGroupTypeIC<infer R> ? QueryBuilderContextProps<F, GetOptionIdentifierType<O>> & {
   /**
   * Initial query object for uncontrolled components.
   */
-  defaultQuery?: RG;
+  defaultQuery?: RG$1;
   /**
   * Query object for controlled components.
   */
-  query?: RG;
+  query?: RG$1;
   /**
   * List of valid {@link FullField}s.
   *
@@ -2518,7 +2563,7 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   getSubQueryBuilderProps?(field: GetOptionIdentifierType<F>, misc: {
     fieldData: F;
-  }): QueryBuilderProps<GenericizeRuleGroupType<RG>, FullOption, FullOption, FullOption>;
+  }): QueryBuilderProps<GenericizeRuleGroupType<RG$1>, FullOption, FullOption, FullOption>;
   /**
   * The return value of this function will be used to apply classnames to the
   * outer `<div>` of the given {@link Rule}.
@@ -2530,56 +2575,56 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   * 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;
+  getRuleGroupClassname?(ruleGroup: RG$1): 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;
+  onAddRule?(rule: R, parentPath: Path, query: RG$1, 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;
+  onAddGroup?(ruleGroup: RG$1, parentPath: Path, query: RG$1, context?: any): RG$1 | 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;
+  onMoveRule?(rule: R, fromPath: Path, toPath: Path | "up" | "down", query: RG$1, nextQuery: RG$1, options: MoveOptions, context?: any): RG$1 | 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;
+  onMoveGroup?(ruleGroup: RG$1, fromPath: Path, toPath: Path | "up" | "down", query: RG$1, nextQuery: RG$1, options: MoveOptions, context?: any): RG$1 | 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;
+  onGroupRule?(rule: R, fromPath: Path, toPath: Path, query: RG$1, nextQuery: RG$1, options: GroupOptions, context?: any): RG$1 | 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;
+  onGroupGroup?(ruleGroup: RG$1, fromPath: Path, toPath: Path, query: RG$1, nextQuery: RG$1, options: GroupOptions, context?: any): RG$1 | 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;
+  onRemove?(ruleOrGroup: R | RG$1, path: Path, query: RG$1, context?: any): boolean;
   /**
   * This callback is invoked anytime the query state is updated.
   */
-  onQueryChange?(query: RG): void;
+  onQueryChange?(query: RG$1): void;
   /**
   * Each log object will be passed to this function when `debugMode` is `true`.
   *
@@ -2587,90 +2632,20 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   onLog?(obj: any): void;
   /**
-  * 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;
-  /**
   * @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;
   /**
-  * 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.
+  * 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
   */
-  listsAsArrays?: boolean;
+  disabled?: boolean | Path[];
   /**
   * Store values as numbers whenever possible.
   *
@@ -2696,15 +2671,6 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   parseNumbers?: ParseNumbersPropConfig;
   /**
-  * 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[];
-  /**
   * Query validation function.
   */
   validator?: QueryValidator;
@@ -2721,11 +2687,6 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   accessibleDescriptionGenerator?: AccessibleDescriptionGenerator;
   /**
-  * Prevent _any_ assignment of standard classes to elements. This includes conditional
-  * and event-based classes for validation, drag-and-drop, etc.
-  */
-  suppressStandardClassnames?: boolean;
-  /**
   * Maximum number of levels deep the query is allowed to go. The minimum is 1; values
   * less than 1 will be ignored.
   */