@react-querybuilder/core 8.20.2 → 8.21.1

package/dist/{index-DlVg-QXo.d.ts → index-BSwFvkeI.d.ts}

@@ -1,5 +1,4 @@
-import { RulesLogic } from "json-logic-js";
-
+import { JsonLogicLessThan, JsonLogicLessThanOrEqual, RulesLogic, RulesLogic as JsonLogicRulesLogic } from "json-logic-js";
 //#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
 /**
 Convert a union type to an intersection type.
@@ -18,16 +17,21 @@ type Intersection = UnionToIntersection<Union>;
 
 @category Type
 */
-type UnionToIntersection<Union> = (// `extends unknown` is always going to be the case and is used to convert the
+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
+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
+(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;
+) 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
 /**
@@ -67,7 +71,8 @@ type AllKeys = KeysOfUnion<Union>;
 
 @category Object
 */
-type KeysOfUnion<ObjectType> = // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+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
@@ -179,8 +184,8 @@ const update2: UpdateOperation<User> = {
 @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;
+ ? (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; // Should never happen
 //#endregion
 //#region ../../node_modules/type-fest/source/required-keys-of.d.ts
 /**
@@ -214,7 +219,7 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 @category Utilities
 */
 type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+ ? Exclude<keyof Type, OptionalKeysOf<Type>> : never; // Should never happen
 //#endregion
 //#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
@@ -459,7 +464,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
 //#endregion
 //#region ../../node_modules/type-fest/source/is-equal.d.ts
 /**
@@ -584,7 +589,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 @see {@link PickIndexSignature}
 @category Object
 */
-type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+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
 /**
@@ -632,11 +637,11 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 @see {@link OmitIndexSignature}
 @category Object
 */
-type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+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> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+type SimpleMerge<Destination, Source> = Simplify<{ [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.
 
@@ -700,10 +705,9 @@ Note: If you want a merge type that more accurately reflects the runtime behavio
 @category Object
 */
 type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
-? Source extends unknown // For distributing `Source`
-? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
-: never;
-// Should never happen
+ ? Source extends unknown // For distributing `Source`
+ ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+ : never; // Should never happen
 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
@@ -744,7 +748,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, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P]; };
 /**
 Merges user specified options with default options.
 
@@ -797,36 +801,9 @@ 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> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-? Result : never;
-type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key] }>>>;
-/**
-Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
-
-Note: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `("foo" & Tag<"Tag", never>) | (string & Tag<"Tag", never>)` and not `string & Tag<"Tag", never>`.
-
-Use-case: For collapsing unions created using {@link LiteralUnion}.
-
-@example
-```
-import type {LiteralUnion} from 'type-fest';
-
-type A = CollapseLiterals<'foo' | 'bar' | (string & {})>;
-//=> string
-
-type B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;
-//=> number
-
-type C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;
-//=> `on${string}`
-
-type D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;
-//=> 'click' | 'change' | `on${string}`
-
-type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
-//=> string | null | undefined
-```
-*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+) ? Result : never;
+type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;
 //#endregion
 //#region ../../node_modules/type-fest/source/except.d.ts
 /**
@@ -859,10 +836,12 @@ type Filtered = Filter<'bar', 'foo'>;
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 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
-  */
+	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 = {
@@ -924,7 +903,7 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 @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>> : {});
+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
 /**
@@ -953,38 +932,42 @@ type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
 @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>>>;
+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
+ ? 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,
+[...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
+[...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+ : never; // Should never happen
 //#endregion
 //#region src/types/options.d.ts
-type RequireAtLeastOne<O, K extends keyof O> = { [P in K]-?: Required<Pick<O, P>> & Partial<Pick<O, Exclude<K, P>>> }[K] & Except<O, K>;
+type RequireAtLeastOne<O, K extends keyof O> = { [P in K]-?: Required<Pick<O, P>> & Partial<Pick<O, Exclude<K, P>>>; }[K] & Except<O, K>;
 /**
-* Adds an `unknown` index property to an interface.
-*/
+ * Adds an `unknown` index property to an interface.
+ */
 type WithUnknownIndex<T> = T & {
   [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
-*/
+ * 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;
@@ -992,115 +975,141 @@ interface BaseOption<N extends string = string> {
   disabled?: boolean;
 }
 /**
-* A generic option. Used directly in {@link OptionList} or
-* as the child element of an {@link OptionGroup}.
-*
-* @group Option Lists
-*/
+ * 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">>>;
 /**
-* 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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
-*/
+ * 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 using
-* {@link FullOption} instead of {@link Option}. This means that every member is
-* guaranteed to have both `name` and `value`.
-*
-* @group Option Lists
-*/
+ * 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>>[];
 //#endregion
+//#region src/types/expression.d.ts
+/**
+ * A single node in an expression tree. Expressions are recursive: a `func` node's
+ * arguments are themselves {@link ExpressionNode}s, enabling arbitrary nesting.
+ *
+ * Used by `@react-querybuilder/expr` for arithmetic/function expressions on a rule's
+ * left- and right-hand sides. The core library preserves these nodes (on
+ * {@link RuleType.lhs} and, for the right-hand side, in `value` when `valueSource` is
+ * `"expression"`) but does not interpret them.
+ */
+type ExpressionNode = {
+  kind: "field";
+  field: string;
+} | {
+  kind: "value";
+  value: unknown;
+  valueType?: string;
+} | {
+  kind: "parameter";
+  parameter: string;
+} | {
+  kind: "func";
+  fn: string;
+  args: ExpressionNode[];
+};
+//#endregion
 //#region src/types/ruleGroups.d.ts
 /**
-* Properties common to both rules and groups.
-*/
+ * 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.
-  */
+   * 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.
-*/
+ * 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, M = Record<string, any>> extends CommonRuleAndGroupProperties {
   field: F;
   operator: O;
@@ -1108,60 +1117,65 @@ interface RuleType<F extends string = string, O extends string = string, V = any
   valueSource?: ValueSource;
   match?: MatchConfig;
   /**
-  * Only used when adding a rule to a query that uses independent combinators.
-  */
+   * When present, the rule's left-hand side is this expression. The `field`
+   * property continues to drive operator selection and validation.
+   */
+  lhs?: ExpressionNode;
+  /**
+   * Only used when adding a rule to a query that uses independent combinators.
+   */
   combinatorPreceding?: C;
   /**
-  * Opaque metadata for use by extension packages. The core library
-  * preserves this property but does not read or interpret it.
-  */
+   * Opaque metadata for use by extension packages. The core library
+   * preserves this property but does not read or interpret it.
+   */
   meta?: M;
 }
 /**
-* The main rule group type. This type is used for query definitions as well as
-* all sub-groups of queries.
-*/
+ * 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 {
   combinator: C;
   rules: RuleGroupArray<RuleGroupType<R, C>, R>;
   not?: boolean;
 }
 /**
-* The type of the `rules` array in a {@link RuleGroupType}.
-*/
+ * The type of the `rules` array in a {@link RuleGroupType}.
+ */
 type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType = RuleType> = (R | RG)[];
 /**
-* The type of the `rules` array in a {@link DefaultRuleGroupType}.
-*/
+ * The type of the `rules` array in a {@link DefaultRuleGroupType}.
+ */
 type DefaultRuleGroupArray<F extends string = string> = RuleGroupArray<DefaultRuleGroupType, DefaultRuleType<F>>;
 /**
-* {@link RuleGroupType} with the `combinator` property limited to
-* {@link DefaultCombinatorNameExtended} and `rules` limited to {@link DefaultRuleType}.
-*/
+ * {@link RuleGroupType} with the `combinator` property limited to
+ * {@link DefaultCombinatorNameExtended} and `rules` limited to {@link DefaultRuleType}.
+ */
 type DefaultRuleGroupType<F extends string = string> = RuleGroupType<DefaultRuleType<F>, DefaultCombinatorNameExtended> & {
   rules: DefaultRuleGroupArray<F>;
 };
 /**
-* {@link RuleType} with the `operator` property limited to {@link DefaultOperatorName}.
-*/
+ * {@link RuleType} with the `operator` property limited to {@link DefaultOperatorName}.
+ */
 type DefaultRuleType<F extends string = string> = RuleType<F, DefaultOperatorName>;
 /**
-* Default allowed values for the `combinator` property.
-*
-* @group Option Lists
-*/
+ * Default allowed values for the `combinator` property.
+ *
+ * @group Option Lists
+ */
 type DefaultCombinatorName = "and" | "or";
 /**
-* Default allowed values for the `combinator` property, plus `"xor"`.
-*
-* @group Option Lists
-*/
+ * Default allowed values for the `combinator` property, plus `"xor"`.
+ *
+ * @group Option Lists
+ */
 type DefaultCombinatorNameExtended = DefaultCombinatorName | "xor";
 /**
-* Default values for the `operator` property.
-*
-* @group Option Lists
-*/
+ * Default values for the `operator` property.
+ *
+ * @group Option Lists
+ */
 type DefaultOperatorName = "=" | "!=" | "<" | ">" | "<=" | ">=" | "contains" | "beginsWith" | "endsWith" | "doesNotContain" | "doesNotBeginWith" | "doesNotEndWith" | "null" | "notNull" | "in" | "notIn" | "between" | "notBetween";
 //#endregion
 //#region src/types/ruleGroupsIC.utils.d.ts
@@ -1170,110 +1184,110 @@ type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [
 //#endregion
 //#region 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.
-*/
+ * 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"> {
   combinator?: undefined;
   rules: RuleGroupICArray<RuleGroupTypeIC<R, C>, R, C>;
   /**
-  * Only used when adding a rule to a query that uses independent combinators
-  */
+   * Only used when adding a rule to a query that uses independent combinators
+   */
   combinatorPreceding?: C;
 }
 /**
-* Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
-*/
+ * Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
+ */
 type RuleGroupTypeAny<R extends RuleType = RuleType, C extends string = string> = RuleGroupType<R, C> | RuleGroupTypeIC<R, C>;
 /**
-* The type of the `rules` array in a {@link RuleGroupTypeIC}.
-*/
+ * 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)[] & {
   length: 0;
 });
 /**
-* The type of the `rules` array in a {@link DefaultRuleGroupTypeIC}.
-*/
+ * The type of the `rules` array in a {@link DefaultRuleGroupTypeIC}.
+ */
 type DefaultRuleGroupICArray<F extends string = string> = RuleGroupICArray<DefaultRuleGroupTypeIC<F>, DefaultRuleType<F>, DefaultCombinatorName>;
 /**
-* {@link RuleGroupTypeIC} with combinators limited to
-* {@link DefaultCombinatorName} and rules limited to {@link DefaultRuleType}.
-*/
+ * {@link RuleGroupTypeIC} with combinators limited to
+ * {@link DefaultCombinatorName} and rules limited to {@link DefaultRuleType}.
+ */
 interface DefaultRuleGroupTypeIC<F extends string = string> extends RuleGroupTypeIC<DefaultRuleType<F>> {
   rules: DefaultRuleGroupICArray<F>;
 }
 //#endregion
 //#region src/types/validation.d.ts
 /**
-* Object with a `valid` boolean value and optional `reasons`.
-*/
+ * 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}.
-*/
+ * Map of rule/group `id` to its respective {@link ValidationResult}.
+ */
 type ValidationMap = Record<string, boolean | ValidationResult>;
 /**
-* Function that validates a query.
-*/
+ * Function that validates a query.
+ */
 type QueryValidator = (query: RuleGroupTypeAny) => boolean | ValidationMap;
 /**
-* Function that validates a rule.
-*/
+ * Function that validates a rule.
+ */
 type RuleValidator = (rule: RuleType) => boolean | ValidationResult;
 //#endregion
 //#region src/types/basic.d.ts
 /**
-* @see https://react-querybuilder.js.org/docs/tips/path
-*/
+ * @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.
-*/
+ * 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";
+ * A source for the `value` property of a rule.
+ */
+type ValueSource = "value" | "field" | "expression" | "parameter";
 /**
-* Type of {@link react-querybuilder!ValueEditor 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;
 /**
-* A valid array of potential value sources.
-*
-* @see {@link ValueSource}
-*/
-type ValueSources = ["value"] | ["value", "field"] | ["field", "value"] | ["field"];
+ * A valid array of potential value sources.
+ *
+ * @see {@link ValueSource}
+ */
+type ValueSources = [ValueSource, ...ValueSource[]];
 type ValueSourceFlexibleOptions = ToFlexibleOptionArrays<ValueSources>;
-type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption } : never;
+type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption; } : never;
 type WithOptionalClassName<T> = T & {
   className?: Classname;
 };
 /**
-* HTML5 input types
-*/
+ * 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.
-*/
+ * 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";
 /**
-* Base for all Field types/interfaces.
-*/
+ * 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>)[];
@@ -1291,329 +1305,337 @@ interface BaseFullField<FieldName extends string = string, OperatorName extends
   comparator?: string | ((f: FullField, operator: string) => boolean);
 }
 /**
-* Full field definition used in the `fields` prop of {@link 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
-*/
+ * 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`.
-*/
+ * 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
-*/
+ * 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;
 }
 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}.
-*/
+ * Options for the `parseNumbers` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
+ */
 type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
 //#endregion
 //#region src/types/export.d.ts
 /**
-* Available export formats for {@link formatQuery}.
-*
-* @group Export
-*/
+ * Available export formats for {@link formatQuery}.
+ *
+ * @group Export
+ */
 type ExportFormat = "json" | "sql" | "json_without_ids" | "parameterized" | "parameterized_named" | "mongodb" | "mongodb_query" | "cel" | "jsonlogic" | "spel" | "elasticsearch" | "jsonata" | "natural_language" | "ldap" | "drizzle" | "tanstack_db" | "prisma" | "sequelize" | "cypher" | "gql" | "sparql" | "gremlin" | "diagnostics";
 /**
-* Export formats for {@link formatQuery} that produce objects instead of strings.
-*
-* @group Export
-*/
+ * Export formats for {@link formatQuery} that produce objects instead of strings.
+ *
+ * @group Export
+ */
 type ExportObjectFormats = "parameterized" | "parameterized_named" | "jsonlogic" | "elasticsearch" | "jsonata" | "mongodb_query" | "diagnostics";
 /**
-* Available presets for the "sql" export format.
-*
-* @group Export
-*/
+ * Available presets for the "sql" export format.
+ *
+ * @group Export
+ */
 type SQLPreset = "ansi" | "sqlite" | "postgresql" | "mysql" | "mssql" | "oracle";
 /**
-* A map of operators to strings to be used in the output of {@link formatQuery}. If the
-* result can differ based on the `valueSource`, the key should map to an array where the
-* second element represents the string to be used when `valueSource` is "field". The first
-* element will be used in all other cases.
-*
-* @group Export
-*/
+ * A map of operators to strings to be used in the output of {@link formatQuery}. If the
+ * result can differ based on the `valueSource`, the key should map to an array where the
+ * second element represents the string to be used when `valueSource` is "field". The first
+ * element will be used in all other cases.
+ *
+ * @group Export
+ */
 type ExportOperatorMap = Partial<Record<Lowercase<DefaultOperatorName> | DefaultOperatorName, string | [string, string]>>;
 /**
-* Options object shape for {@link formatQuery}.
-*
-* @group Export
-*/
+ * Options object shape for {@link formatQuery}.
+ *
+ * @group Export
+ */
 interface FormatQueryOptions {
   /**
-  * The {@link ExportFormat}.
-  */
+   * The {@link ExportFormat}.
+   */
   format?: ExportFormat;
   /**
-  * This function will be used to process the `operator` from each rule
-  * for query language formats. If not defined, the appropriate
-  * `defaultOperatorProcessor*` for the format will be used.
-  */
+   * This function will be used to process the `operator` from each rule
+   * for query language formats. If not defined, the appropriate
+   * `defaultOperatorProcessor*` for the format will be used.
+   */
   operatorProcessor?: RuleProcessor;
   /**
-  * This function will be used to process the `value` from each rule
-  * for query language formats. If not defined, the appropriate
-  * `defaultValueProcessor*` for the format will be used.
-  */
+   * This function will be used to process the `value` from each rule
+   * for query language formats. If not defined, the appropriate
+   * `defaultValueProcessor*` for the format will be used.
+   */
   valueProcessor?: ValueProcessorLegacy | ValueProcessorByRule;
   /**
-  * This function will be used to process each rule. If not defined, the appropriate
-  * `defaultRuleProcessor*` for the given format will be used.
-  */
+   * This function will be used to process each rule. If not defined, the appropriate
+   * `defaultRuleProcessor*` for the given format will be used.
+   */
   ruleProcessor?: RuleProcessor;
   /**
-  * This function will be used to process each rule group. If not defined, the appropriate
-  * `defaultRuleGroupProcessor*` for the format will be used.
-  *
-  * If this function is defined, it will override the `format` option. This also allows
-  * `formatQuery` to produce completely custom output formats.
-  */
+   * This function will be used to process each rule group. If not defined, the appropriate
+   * `defaultRuleGroupProcessor*` for the format will be used.
+   *
+   * If this function is defined, it will override the `format` option. This also allows
+   * `formatQuery` to produce completely custom output formats.
+   */
   ruleGroupProcessor?: RuleGroupProcessor;
   /**
-  * In the "sql", "parameterized", "parameterized_named", and "jsonata" export
-  * formats, field names will be bracketed by this string. If an array of strings
-  * is passed, field names will be preceded by the first element and
-  * succeeded by the second element.
-  *
-  * Tip: Use `fieldIdentifierSeparator` to bracket identifiers individually within field names.
-  *
-  * @default '' // the empty string
-  *
-  * @example
-  * formatQuery(query, { format: 'sql', quoteFieldNamesWith: '"' })
-  * // `"First name" = 'Steve'`
-  *
-  * @example
-  * formatQuery(query, { format: 'sql', quoteFieldNamesWith: ['[', ']'] })
-  * // "[First name] = 'Steve'"
-  */
+   * In the "sql", "parameterized", "parameterized_named", and "jsonata" export
+   * formats, field names will be bracketed by this string. If an array of strings
+   * is passed, field names will be preceded by the first element and
+   * succeeded by the second element.
+   *
+   * Tip: Use `fieldIdentifierSeparator` to bracket identifiers individually within field names.
+   *
+   * @default '' // the empty string
+   *
+   * @example
+   * formatQuery(query, { format: 'sql', quoteFieldNamesWith: '"' })
+   * // `"First name" = 'Steve'`
+   *
+   * @example
+   * formatQuery(query, { format: 'sql', quoteFieldNamesWith: ['[', ']'] })
+   * // "[First name] = 'Steve'"
+   */
   quoteFieldNamesWith?: string | [string, string];
   /**
-  * When used in conjunction with the `quoteFieldNamesWith` option, field names will
-  * be split by this string, each part being individually processed as per the rules
-  * of the `quoteFieldNamesWith` configuration. The parts will then be re-joined
-  * by the same string.
-  *
-  * A common value for this option is `'.'`.
-  *
-  * A value of `''` (the empty string) will disable splitting/rejoining.
-  *
-  * @default ''
-  *
-  * @example
-  * formatQuery(query, {
-  *   format: 'sql',
-  *   quoteFieldNamesWith: ['[', ']'],
-  *   fieldIdentifierSeparator: '.',
-  * })
-  * // "[dbo].[Musicians].[First name] = 'Steve'"
-  */
+   * When used in conjunction with the `quoteFieldNamesWith` option, field names will
+   * be split by this string, each part being individually processed as per the rules
+   * of the `quoteFieldNamesWith` configuration. The parts will then be re-joined
+   * by the same string.
+   *
+   * A common value for this option is `'.'`.
+   *
+   * A value of `''` (the empty string) will disable splitting/rejoining.
+   *
+   * @default ''
+   *
+   * @example
+   * formatQuery(query, {
+   *   format: 'sql',
+   *   quoteFieldNamesWith: ['[', ']'],
+   *   fieldIdentifierSeparator: '.',
+   * })
+   * // "[dbo].[Musicians].[First name] = 'Steve'"
+   */
   fieldIdentifierSeparator?: string;
   /**
-  * Character to use for quoting string values in the SQL format.
-  * @default `'`
-  */
+   * Character to use for quoting string values in the SQL format.
+   * @default `'`
+   */
   quoteValuesWith?: string;
   /**
-  * Validator function for the entire query. Can be the same function passed
-  * as `validator` prop to {@link react-querybuilder!QueryBuilder QueryBuilder}.
-  */
+   * Validator function for the entire query. Can be the same function passed
+   * as `validator` prop to {@link react-querybuilder!QueryBuilder QueryBuilder}.
+   */
   validator?: QueryValidator;
   /**
-  * This can be the same {@link FullField} array passed to {@link react-querybuilder!QueryBuilder QueryBuilder}, but
-  * really all you need to provide is the `name` and `validator` for each field.
-  *
-  * The full field object from this array, where the field's identifying property
-  * matches the rule's `field`, will be passed to the rule processor.
-  */
+   * This can be the same {@link FullField} array passed to {@link react-querybuilder!QueryBuilder QueryBuilder}, but
+   * really all you need to provide is the `name` and `validator` for each field.
+   *
+   * The full field object from this array, where the field's identifying property
+   * matches the rule's `field`, will be passed to the rule processor.
+   */
   fields?: FlexibleOptionList<FullField>;
   /**
-  * This can be the same `getOperators` function passed to {@link react-querybuilder!QueryBuilder QueryBuilder}.
-  *
-  * The full operator object from this array, where the operator's identifying property
-  * matches the rule's `operator`, will be passed to the rule processor.
-  */
+   * This can be the same `getOperators` function passed to {@link react-querybuilder!QueryBuilder QueryBuilder}.
+   *
+   * The full operator object from this array, where the operator's identifying property
+   * matches the rule's `operator`, will be passed to the rule processor.
+   */
   getOperators?(field: string, misc: {
     fieldData: FullField;
   }): FlexibleOptionList<FullOperator> | null;
   /**
-  * This string will be inserted in place of invalid groups for non-JSON formats.
-  * Defaults to `'(1 = 1)'` for "sql"/"parameterized"/"parameterized_named" and
-  * `'$and:[{$expr:true}]'` for "mongodb".
-  */
+   * This can be the same `getParameters` function passed to {@link react-querybuilder!QueryBuilder QueryBuilder}.
+   * When provided, any rule whose `valueSource` is `"parameter"` and whose value (with any
+   * leading `paramPrefix` stripped) is not found in this list will be treated as invalid.
+   *
+   * As with the `getParameters` prop, prefer names _without_ the parameter prefix.
+   */
+  getParameters?(field?: string, operator?: string, misc?: {
+    fieldData: FullField;
+  }): FlexibleOptionList<FullOption>;
+  /**
+   * This string will be inserted in place of invalid groups for non-JSON formats.
+   * Defaults to `'(1 = 1)'` for "sql"/"parameterized"/"parameterized_named" and
+   * `'$and:[{$expr:true}]'` for "mongodb".
+   */
   fallbackExpression?: string;
   /**
-  * This string will be placed in front of named parameters (aka bind variables)
-  * when using the "parameterized_named" export format.
-  *
-  * @default ":"
-  */
+   * This string will be placed in front of named parameters (aka bind variables)
+   * when using the "parameterized_named" export format.
+   *
+   * @default ":"
+   */
   paramPrefix?: string;
   /**
-  * Maintains the parameter prefix in the `params` object keys when using the
-  * "parameterized_named" export format. Recommended when using SQLite.
-  *
-  * @default false
-  *
-  * @example
-  * console.log(formatQuery(query, {
-  *   format: "parameterized_named",
-  *   paramPrefix: "$",
-  *   paramsKeepPrefix: true
-  * }).params)
-  * // { $firstName: "Stev" }
-  * // Default (`paramsKeepPrefix` is `false`):
-  * // { firstName: "Stev" }
-  */
+   * Maintains the parameter prefix in the `params` object keys when using the
+   * "parameterized_named" export format. Recommended when using SQLite.
+   *
+   * @default false
+   *
+   * @example
+   * console.log(formatQuery(query, {
+   *   format: "parameterized_named",
+   *   paramPrefix: "$",
+   *   paramsKeepPrefix: true
+   * }).params)
+   * // { $firstName: "Stev" }
+   * // Default (`paramsKeepPrefix` is `false`):
+   * // { firstName: "Stev" }
+   */
   paramsKeepPrefix?: boolean;
   /**
-  * Renders parameter placeholders as a series of sequential numbers
-  * instead of '?' like the default. This option will respect the
-  * `paramPrefix` option like the 'parameterized_named' format.
-  *
-  * @default false
-  */
+   * Renders parameter placeholders as a series of sequential numbers
+   * instead of '?' like the default. This option will respect the
+   * `paramPrefix` option like the 'parameterized_named' format.
+   *
+   * @default false
+   */
   numberedParams?: boolean;
   /**
-  * Preserves the order of values for "between" and "notBetween" rules, even if a larger
-  * value comes before a smaller value (which will always evaluate to false).
-  */
+   * Preserves the order of values for "between" and "notBetween" rules, even if a larger
+   * value comes before a smaller value (which will always evaluate to false).
+   */
   preserveValueOrder?: boolean;
   /**
-  * Renders values as either `number`-types or unquoted strings, as
-  * appropriate and when possible. Each `string`-type value is evaluated
-  * against {@link numericRegex} to determine if it can be represented as a
-  * plain numeric value. If so, `parseFloat` is used to convert it to a number.
-  */
+   * Renders values as either `number`-types or unquoted strings, as
+   * appropriate and when possible. Each `string`-type value is evaluated
+   * against {@link numericRegex} to determine if it can be represented as a
+   * plain numeric value. If so, `parseFloat` is used to convert it to a number.
+   */
   parseNumbers?: ParseNumbersPropConfig;
   /**
-  * Any rules where the field is equal to this value will be ignored.
-  *
-  * @default '~'
-  */
+   * Any rules where the field is equal to this value will be ignored.
+   *
+   * @default '~'
+   */
   placeholderFieldName?: string;
   /**
-  * Any rules where the operator is equal to this value will be ignored.
-  *
-  * @default '~'
-  */
+   * Any rules where the operator is equal to this value will be ignored.
+   *
+   * @default '~'
+   */
   placeholderOperatorName?: string;
   /**
-  * Any rules where the value is equal to this value will be ignored.
-  *
-  * @default '~'
-  */
+   * Any rules where the value is equal to this value will be ignored.
+   *
+   * @default '~'
+   */
   placeholderValueName?: string;
   /**
-  * Operator to use when concatenating wildcard characters and field names in "sql" format.
-  * The ANSI standard is `||`, while SQL Server uses `+`. MySQL does not implement a concatenation
-  * operator by default, and therefore requires use of the `CONCAT` function.
-  *
-  * If `concatOperator` is set to `"CONCAT"` (case-insensitive), the `CONCAT` function will be
-  * used. Note that Oracle SQL does not support more than two values in the `CONCAT` function,
-  * so this option should not be used in that context. The default setting (`"||"`) is already
-  * compatible with Oracle SQL.
-  *
-  * @default '||'
-  */
+   * Operator to use when concatenating wildcard characters and field names in "sql" format.
+   * The ANSI standard is `||`, while SQL Server uses `+`. MySQL does not implement a concatenation
+   * operator by default, and therefore requires use of the `CONCAT` function.
+   *
+   * If `concatOperator` is set to `"CONCAT"` (case-insensitive), the `CONCAT` function will be
+   * used. Note that Oracle SQL does not support more than two values in the `CONCAT` function,
+   * so this option should not be used in that context. The default setting (`"||"`) is already
+   * compatible with Oracle SQL.
+   *
+   * @default '||'
+   */
   concatOperator?: "||" | "+" | "CONCAT" | (string & {});
   /**
-  * Option presets to maximize compatibility with various SQL dialects.
-  */
+   * Option presets to maximize compatibility with various SQL dialects.
+   */
   preset?: SQLPreset;
   /**
-  * Map of operators to their translations for the "natural_language" format. If the
-  * result can differ based on the `valueSource`, the key should map to an array where the
-  * second element represents the string to be used when `valueSource` is "field". The first
-  * element will be used in all other cases.
-  */
+   * Map of operators to their translations for the "natural_language" format. If the
+   * result can differ based on the `valueSource`, the key should map to an array where the
+   * second element represents the string to be used when `valueSource` is "field". The first
+   * element will be used in all other cases.
+   */
   operatorMap?: ExportOperatorMap;
   /**
-  * [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
-  * for the "natural_language" format. Can be abbreviated like "SVO" or spelled out like
-  * "subject-verb-object".
-  *
-  * - Subject = field
-  * - Verb = operator
-  * - Object = value
-  */
+   * [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
+   * for the "natural_language" format. Can be abbreviated like "SVO" or spelled out like
+   * "subject-verb-object".
+   *
+   * - Subject = field
+   * - Verb = operator
+   * - Object = value
+   */
   wordOrder?: ConstituentWordOrderString | Lowercase<ConstituentWordOrderString> | ({} & string);
   /**
-  * Translatable strings used by the "natural_language" format.
-  */
+   * Translatable strings used by the "natural_language" format.
+   */
   translations?: Partial<Record<NLTranslationKey, string>>;
   context?: Record<string, any>;
 }
 /**
-* Options object for {@link ValueProcessorByRule} functions.
-*
-* @group Export
-*/
+ * Options object for {@link ValueProcessorByRule} functions.
+ *
+ * @group Export
+ */
 interface ValueProcessorOptions extends FormatQueryOptions {
   valueProcessor?: ValueProcessorByRule;
   escapeQuotes?: boolean;
   /**
-  * The full field object, if `fields` was provided in the
-  * {@link formatQuery} options parameter.
-  */
+   * The full field object, if `fields` was provided in the
+   * {@link formatQuery} options parameter.
+   */
   fieldData?: FullField;
   /**
-  * Included for the "parameterized_named" format only. Keys of this object represent
-  * field names and values represent the current list of parameter names for that
-  * field based on the query rules processed up to that point. Use this list to
-  * ensure that parameter names generated by the custom rule processor are unique.
-  */
+   * Included for the "parameterized_named" format only. Keys of this object represent
+   * field names and values represent the current list of parameter names for that
+   * field based on the query rules processed up to that point. Use this list to
+   * ensure that parameter names generated by the custom rule processor are unique.
+   */
   fieldParamNames?: Record<string, string[]>;
   /**
-  * Included for the "parameterized_named" format only. Call this function with a
-  * field name to get a unique parameter name, as yet unused during query processing.
-  */
+   * Included for the "parameterized_named" format only. Call this function with a
+   * field name to get a unique parameter name, as yet unused during query processing.
+   */
   getNextNamedParam?: (field: string) => string;
   /**
-  * Additional prefix and suffix characters to wrap the value in. Useful for augmenting
-  * the default value processor results with special syntax (e.g., for dates or function
-  * calls).
-  */
+   * Additional prefix and suffix characters to wrap the value in. Useful for augmenting
+   * the default value processor results with special syntax (e.g., for dates or function
+   * calls).
+   */
   wrapValueWith?: [string, string];
   /**
-  * Parse numbers in the rule value.
-  *
-  * @default false
-  */
+   * Parse numbers in the rule value.
+   *
+   * @default false
+   */
   parseNumbers?: boolean;
 }
 /**
-* Options object curated by {@link formatQuery} and passed to a {@link RuleGroupProcessor}.
-*
-* @group Export
-*/
-interface FormatQueryFinalOptions extends Required<Except<FormatQueryOptions, "context" | "valueProcessor" | "validator" | "placeholderValueName" | "ruleGroupProcessor" | "parseNumbers">> {
+ * Options object curated by {@link formatQuery} and passed to a {@link RuleGroupProcessor}.
+ *
+ * @group Export
+ */
+interface FormatQueryFinalOptions extends Required<Except<FormatQueryOptions, "context" | "valueProcessor" | "validator" | "placeholderValueName" | "ruleGroupProcessor" | "parseNumbers" | "getParameters">> {
+  getParameters?: FormatQueryOptions["getParameters"];
   fields: FullOptionList<FullField>;
   getParseNumberBoolean: (inputType?: InputType | null) => boolean | undefined;
   parseNumbers?: ParseNumbersPropConfig | undefined;
@@ -1625,159 +1647,162 @@ interface FormatQueryFinalOptions extends Required<Except<FormatQueryOptions, "c
   context?: Record<string, unknown>;
 }
 /**
-* Function that produces a processed value for a given {@link RuleType}.
-*
-* @group Export
-*/
+ * Function that produces a processed value for a given {@link RuleType}.
+ *
+ * @group Export
+ */
 type ValueProcessorByRule = (rule: RuleType, options?: ValueProcessorOptions) => string;
 /**
-* Function that produces a processed value for a given `field`, `operator`, `value`,
-* and `valueSource`.
-*
-* @group Export
-*/
+ * Function that produces a processed value for a given `field`, `operator`, `value`,
+ * and `valueSource`.
+ *
+ * @group Export
+ */
 type ValueProcessorLegacy = (field: string, operator: string, value: any, valueSource?: ValueSource) => string;
 /**
-* Function to produce a result that {@link formatQuery} uses when processing a
-* {@link RuleType} object.
-*
-* See the default rule processor for each format to know what type to return.
-* | Format                   | Default rule processor                    |
-* | ------------------------ | ----------------------------------------- |
-* | `sql`                    | {@link defaultRuleProcessorSQL}           |
-* | `parameterized`          | {@link defaultRuleProcessorParameterized} |
-* | `parameterized_named`    | {@link defaultRuleProcessorParameterized} |
-* | `mongodb` _(deprecated)_ | {@link defaultRuleProcessorMongoDB}       |
-* | `mongodb_query`          | {@link defaultRuleProcessorMongoDBQuery}  |
-* | `cel`                    | {@link defaultRuleProcessorCEL}           |
-* | `spel`                   | {@link defaultRuleProcessorSpEL}          |
-* | `jsonlogic`              | {@link defaultRuleProcessorJsonLogic}     |
-* | `elasticsearch`          | {@link defaultRuleProcessorElasticSearch} |
-* | `jsonata`                | {@link defaultRuleProcessorJSONata}       |
-* | `natural_language`       | {@link defaultRuleProcessorNL}            |
-* | `ldap`                   | {@link defaultRuleProcessorLDAP}          |
-* | `drizzle`                | {@link defaultRuleProcessorDrizzle}       |
-* | `tanstack_db`            | {@link defaultRuleProcessorTanStackDB}    |
-* | `prisma`                 | {@link defaultRuleProcessorPrisma}        |
-* | `sequelize`              | {@link defaultRuleProcessorSequelize}     |
-* | `cypher`                 | {@link defaultRuleProcessorCypher}        |
-* | `sparql`                 | {@link defaultRuleProcessorSPARQL}        |
-* | `gremlin`                | {@link defaultRuleProcessorGremlin}       |
-*
-* @group Export
-*/
+ * Function to produce a result that {@link formatQuery} uses when processing a
+ * {@link RuleType} object.
+ *
+ * See the default rule processor for each format to know what type to return.
+ * | Format                   | Default rule processor                    |
+ * | ------------------------ | ----------------------------------------- |
+ * | `sql`                    | {@link defaultRuleProcessorSQL}           |
+ * | `parameterized`          | {@link defaultRuleProcessorParameterized} |
+ * | `parameterized_named`    | {@link defaultRuleProcessorParameterized} |
+ * | `mongodb` _(deprecated)_ | {@link defaultRuleProcessorMongoDB}       |
+ * | `mongodb_query`          | {@link defaultRuleProcessorMongoDBQuery}  |
+ * | `cel`                    | {@link defaultRuleProcessorCEL}           |
+ * | `spel`                   | {@link defaultRuleProcessorSpEL}          |
+ * | `jsonlogic`              | {@link defaultRuleProcessorJsonLogic}     |
+ * | `elasticsearch`          | {@link defaultRuleProcessorElasticSearch} |
+ * | `jsonata`                | {@link defaultRuleProcessorJSONata}       |
+ * | `natural_language`       | {@link defaultRuleProcessorNL}            |
+ * | `ldap`                   | {@link defaultRuleProcessorLDAP}          |
+ * | `drizzle`                | {@link defaultRuleProcessorDrizzle}       |
+ * | `tanstack_db`            | {@link defaultRuleProcessorTanStackDB}    |
+ * | `prisma`                 | {@link defaultRuleProcessorPrisma}        |
+ * | `sequelize`              | {@link defaultRuleProcessorSequelize}     |
+ * | `cypher`                 | {@link defaultRuleProcessorCypher}        |
+ * | `sparql`                 | {@link defaultRuleProcessorSPARQL}        |
+ * | `gremlin`                | {@link defaultRuleProcessorGremlin}       |
+ *
+ * @group Export
+ */
 type RuleProcessor = (rule: RuleType, options?: ValueProcessorOptions, meta?: {
   processedParams?: Record<string, any> | any[];
   context?: Record<string, any>;
 }) => any;
 /**
-* Function to produce a result that {@link formatQuery} uses when processing a
-* {@link RuleGroupType} or {@link RuleGroupTypeIC} object.
-*
-* See the default rule group processor for each format to know what type to return.
-* | Format                   | Default rule group processor                   |
-* | ------------------------ | ---------------------------------------------- |
-* | `sql`                    | {@link defaultRuleGroupProcessorSQL}           |
-* | `parameterized`          | {@link defaultRuleGroupProcessorParameterized} |
-* | `parameterized_named`    | {@link defaultRuleGroupProcessorParameterized} |
-* | `mongodb` _(deprecated)_ | {@link defaultRuleGroupProcessorMongoDB}       |
-* | `mongodb_query`          | {@link defaultRuleGroupProcessorMongoDBQuery}  |
-* | `cel`                    | {@link defaultRuleGroupProcessorCEL}           |
-* | `spel`                   | {@link defaultRuleGroupProcessorSpEL}          |
-* | `jsonlogic`              | {@link defaultRuleGroupProcessorJsonLogic}     |
-* | `elasticsearch`          | {@link defaultRuleGroupProcessorElasticSearch} |
-* | `jsonata`                | {@link defaultRuleGroupProcessorJSONata}       |
-* | `natural_language`       | {@link defaultRuleGroupProcessorNL}            |
-* | `ldap`                   | {@link defaultRuleGroupProcessorLDAP}          |
-* | `drizzle`                | {@link defaultRuleGroupProcessorDrizzle}       |
-* | `tanstack_db`            | {@link defaultRuleGroupProcessorTanStackDB}    |
-* | `prisma`                 | {@link defaultRuleGroupProcessorPrisma}        |
-* | `sequelize`              | {@link defaultRuleGroupProcessorSequelize}     |
-* | `cypher`                 | {@link defaultRuleGroupProcessorCypher}        |
-* | `sparql`                 | {@link defaultRuleGroupProcessorSPARQL}        |
-* | `gremlin`                | {@link defaultRuleGroupProcessorGremlin}       |
-* | `diagnostics`            | {@link defaultRuleGroupProcessorDiagnostics}   |
-*
-* @group Export
-*/
+ * Function to produce a result that {@link formatQuery} uses when processing a
+ * {@link RuleGroupType} or {@link RuleGroupTypeIC} object.
+ *
+ * See the default rule group processor for each format to know what type to return.
+ * | Format                   | Default rule group processor                   |
+ * | ------------------------ | ---------------------------------------------- |
+ * | `sql`                    | {@link defaultRuleGroupProcessorSQL}           |
+ * | `parameterized`          | {@link defaultRuleGroupProcessorParameterized} |
+ * | `parameterized_named`    | {@link defaultRuleGroupProcessorParameterized} |
+ * | `mongodb` _(deprecated)_ | {@link defaultRuleGroupProcessorMongoDB}       |
+ * | `mongodb_query`          | {@link defaultRuleGroupProcessorMongoDBQuery}  |
+ * | `cel`                    | {@link defaultRuleGroupProcessorCEL}           |
+ * | `spel`                   | {@link defaultRuleGroupProcessorSpEL}          |
+ * | `jsonlogic`              | {@link defaultRuleGroupProcessorJsonLogic}     |
+ * | `elasticsearch`          | {@link defaultRuleGroupProcessorElasticSearch} |
+ * | `jsonata`                | {@link defaultRuleGroupProcessorJSONata}       |
+ * | `natural_language`       | {@link defaultRuleGroupProcessorNL}            |
+ * | `ldap`                   | {@link defaultRuleGroupProcessorLDAP}          |
+ * | `drizzle`                | {@link defaultRuleGroupProcessorDrizzle}       |
+ * | `tanstack_db`            | {@link defaultRuleGroupProcessorTanStackDB}    |
+ * | `prisma`                 | {@link defaultRuleGroupProcessorPrisma}        |
+ * | `sequelize`              | {@link defaultRuleGroupProcessorSequelize}     |
+ * | `cypher`                 | {@link defaultRuleGroupProcessorCypher}        |
+ * | `sparql`                 | {@link defaultRuleGroupProcessorSPARQL}        |
+ * | `gremlin`                | {@link defaultRuleGroupProcessorGremlin}       |
+ * | `diagnostics`            | {@link defaultRuleGroupProcessorDiagnostics}   |
+ *
+ * @group Export
+ */
 type RuleGroupProcessor<TResult = unknown> = (ruleGroup: RuleGroupTypeAny, options: FormatQueryFinalOptions, meta?: {
   processedParams?: Record<string, any> | any[];
   context?: Record<string, any>;
 }) => TResult;
 /**
-* Rule validator for {@link formatQuery}.
-*
-* @group Export
-*/
+ * Rule validator for {@link formatQuery}.
+ *
+ * @group Export
+ */
 type FormatQueryValidateRule = (rule: RuleType) => readonly [boolean | ValidationResult | undefined, RuleValidator | undefined];
 /**
-* Object produced by {@link formatQuery} for the `"parameterized"` format.
-*
-* @group Export
-*/
+ * Object produced by {@link formatQuery} for the `"parameterized"` format.
+ *
+ * @group Export
+ */
 interface ParameterizedSQL {
   /** The SQL `WHERE` clause fragment with `?` placeholders for each value. */
   sql: string;
   /**
-  * Parameter values in the same order their respective placeholders
-  * appear in the `sql` string.
-  */
+   * Parameter values in the same order their respective placeholders
+   * appear in the `sql` string.
+   */
   params: any[];
 }
 /**
-* Object produced by {@link formatQuery} for the `"parameterized_named"` format.
-*
-* @group Export
-*/
+ * Object produced by {@link formatQuery} for the `"parameterized_named"` format.
+ *
+ * @group Export
+ */
 interface ParameterizedNamedSQL {
   /** The SQL `WHERE` clause fragment with bind variable placeholders for each value. */
   sql: string;
   /**
-  * Map of bind variable names from the `sql` string to the associated values.
-  */
+   * Map of bind variable names from the `sql` string to the associated values.
+   */
   params: Record<string, any>;
 }
 /**
-* A {@link RuleType} annotated with diagnostics results, as produced
-* by {@link formatQuery} for the `"diagnostics"` format.
-*
-* The generics mirror those of {@link RuleType}.
-*
-* @group Export
-*/
+ * A {@link RuleType} annotated with diagnostics results, as produced
+ * by {@link formatQuery} for the `"diagnostics"` format.
+ *
+ * The generics mirror those of {@link RuleType}.
+ *
+ * @group Export
+ */
 type RuleDiagnosticsResult<F extends string = string, O extends string = string, V = any, C extends string = string> = RuleType<F, O, V, C> & {
-  /** Whether the rule passed all validation checks. */valid: boolean;
+  /** Whether the rule passed all validation checks. */
+  valid: boolean;
   /**
-  * Reasons why the rule is invalid. Only present when
-  * the rule is invalid and specific reasons were provided
-  * by the validator.
-  */
-  reasons?: any[]; /** The path to this rule within the query tree. */
-  path: number[]; /** The nesting depth of this rule (`path.length`). */
+   * Reasons why the rule is invalid. Only present when
+   * the rule is invalid and specific reasons were provided
+   * by the validator.
+   */
+  reasons?: any[];
+  /** The path to this rule within the query tree. */
+  path: number[];
+  /** The nesting depth of this rule (`path.length`). */
   level: number;
 };
 /**
-* The type of the `rules` array in a {@link RuleGroupDiagnosticsResult}.
-*
-* @group Export
-*/
+ * The type of the `rules` array in a {@link RuleGroupDiagnosticsResult}.
+ *
+ * @group Export
+ */
 type RuleGroupDiagnosticsArray<RG extends RuleGroupDiagnosticsResult = RuleGroupDiagnosticsResult, R extends RuleDiagnosticsResult = RuleDiagnosticsResult> = RuleGroupArray<RG, R>;
 /**
-* A {@link RuleGroupType} annotated with diagnostics results, as produced
-* by {@link formatQuery} for the `"diagnostics"` format.
-*
-* The generics mirror those of {@link RuleGroupType}.
-*
-* @group Export
-*/
+ * A {@link RuleGroupType} annotated with diagnostics results, as produced
+ * by {@link formatQuery} for the `"diagnostics"` format.
+ *
+ * The generics mirror those of {@link RuleGroupType}.
+ *
+ * @group Export
+ */
 interface RuleGroupDiagnosticsResult<R extends RuleDiagnosticsResult = RuleDiagnosticsResult, C extends string = string> extends Omit<RuleGroupType<R, C>, "rules"> {
   /** Whether the group and all of its descendants are valid. */
   valid: boolean;
   /**
-  * Reasons why the group itself is invalid. Only present when
-  * the group is invalid and specific reasons were provided
-  * by the validator.
-  */
+   * Reasons why the group itself is invalid. Only present when
+   * the group is invalid and specific reasons were provided
+   * by the validator.
+   */
   reasons?: any[];
   /** The path to this group within the query tree. */
   path: number[];
@@ -1786,29 +1811,29 @@ interface RuleGroupDiagnosticsResult<R extends RuleDiagnosticsResult = RuleDiagn
   rules: RuleGroupDiagnosticsArray<RuleGroupDiagnosticsResult<R, C>, R>;
 }
 /**
-* The type of the `rules` array in a {@link RuleGroupICDiagnosticsResult}.
-*
-* Mirrors {@link RuleGroupICArray} but with diagnostics-annotated node types.
-*
-* @group Export
-*/
+ * The type of the `rules` array in a {@link RuleGroupICDiagnosticsResult}.
+ *
+ * Mirrors {@link RuleGroupICArray} but with diagnostics-annotated node types.
+ *
+ * @group Export
+ */
 type RuleGroupICDiagnosticsArray<RG extends RuleGroupICDiagnosticsResult = RuleGroupICDiagnosticsResult, R extends RuleDiagnosticsResult = RuleDiagnosticsResult, C extends string = string> = RuleGroupICArray<RG, R, C>;
 /**
-* A {@link RuleGroupTypeIC} annotated with diagnostics results, as produced
-* by {@link formatQuery} for the `"diagnostics"` format (independent combinators).
-*
-* The generics mirror those of {@link RuleGroupTypeIC}.
-*
-* @group Export
-*/
+ * A {@link RuleGroupTypeIC} annotated with diagnostics results, as produced
+ * by {@link formatQuery} for the `"diagnostics"` format (independent combinators).
+ *
+ * The generics mirror those of {@link RuleGroupTypeIC}.
+ *
+ * @group Export
+ */
 interface RuleGroupICDiagnosticsResult<R extends RuleDiagnosticsResult = RuleDiagnosticsResult, C extends string = string> extends Omit<RuleGroupTypeIC<R, C>, "rules"> {
   /** Whether the group and all of its descendants are valid. */
   valid: boolean;
   /**
-  * Reasons why the group itself is invalid. Only present when
-  * the group is invalid and specific reasons were provided
-  * by the validator.
-  */
+   * Reasons why the group itself is invalid. Only present when
+   * the group is invalid and specific reasons were provided
+   * by the validator.
+   */
   reasons?: any[];
   /** The path to this group within the query tree. */
   path: number[];
@@ -1817,10 +1842,10 @@ interface RuleGroupICDiagnosticsResult<R extends RuleDiagnosticsResult = RuleDia
   rules: RuleGroupICDiagnosticsArray<RuleGroupICDiagnosticsResult<R, C>, R, C>;
 }
 /**
-* A single diagnostic entry produced by the `"diagnostics"` format.
-*
-* @group Export
-*/
+ * A single diagnostic entry produced by the `"diagnostics"` format.
+ *
+ * @group Export
+ */
 interface DiagnosticEntry {
   /** The `id` of the rule or group this diagnostic pertains to. */
   id: string;
@@ -1831,22 +1856,22 @@ interface DiagnosticEntry {
   /** A human-readable description of the diagnostic. */
   message: string;
   /**
-  * Which check produced this diagnostic.
-  *
-  * - `"placeholder"` — a placeholder field, operator, or value
-  * - `"muted"` — a muted rule or group
-  * - `"query-validator"` — the query-level validator
-  * - `"field-validator"` — a field-level validator
-  * - `"type-check"` — value/type mismatch based on field `inputType`
-  * - `"field-check"` — field existence check against the `fields` config
-  */
+   * Which check produced this diagnostic.
+   *
+   * - `"placeholder"` — a placeholder field, operator, or value
+   * - `"muted"` — a muted rule or group
+   * - `"query-validator"` — the query-level validator
+   * - `"field-validator"` — a field-level validator
+   * - `"type-check"` — value/type mismatch based on field `inputType`
+   * - `"field-check"` — field existence check against the `fields` config
+   */
   source: "placeholder" | "muted" | "query-validator" | "field-validator" | "type-check" | "field-check";
 }
 /**
-* Aggregate statistics for the `"diagnostics"` format.
-*
-* @group Export
-*/
+ * Aggregate statistics for the `"diagnostics"` format.
+ *
+ * @group Export
+ */
 interface DiagnosticsStats {
   totalRules: number;
   totalGroups: number;
@@ -1856,10 +1881,10 @@ interface DiagnosticsStats {
   invalidGroups: number;
 }
 /**
-* Per-field summary entry for the `"diagnostics"` format.
-*
-* @group Export
-*/
+ * Per-field summary entry for the `"diagnostics"` format.
+ *
+ * @group Export
+ */
 interface DiagnosticsFieldSummaryEntry {
   /** Number of rules referencing this field. */
   ruleCount: number;
@@ -1867,10 +1892,10 @@ interface DiagnosticsFieldSummaryEntry {
   invalidCount: number;
 }
 /**
-* Top-level result of {@link formatQuery} for the `"diagnostics"` format.
-*
-* @group Export
-*/
+ * Top-level result of {@link formatQuery} for the `"diagnostics"` format.
+ *
+ * @group Export
+ */
 interface DiagnosticsResult {
   /** The annotated query tree with `valid`, `path`, and `level` on every node. */
   query: RuleGroupDiagnosticsResult | RuleGroupICDiagnosticsResult;
@@ -1882,64 +1907,70 @@ interface DiagnosticsResult {
   fieldSummary: Record<string, DiagnosticsFieldSummaryEntry>;
 }
 /**
-* @group Export
-*/
+ * @group Export
+ */
 interface RQBJsonLogicStartsWith {
   startsWith: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
 }
 /**
-* @group Export
-*/
+ * @group Export
+ */
 interface RQBJsonLogicEndsWith {
   endsWith: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
 }
 /**
-* JsonLogic rule object with additional operators generated by {@link formatQuery}
-* and accepted by {@link parseJsonLogic!parseJsonLogic}.
-*
-* @group Export
-*/
+ * @group Export
+ */
+interface RQBJsonLogicVar {
+  var: string;
+}
+/**
+ * JsonLogic rule object with additional operators generated by {@link formatQuery}
+ * and accepted by {@link parseJsonLogic!parseJsonLogic}.
+ *
+ * @group Export
+ */
 type RQBJsonLogic = RulesLogic<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith>;
 /**
-* Constituent word order (as array) for the "natural_language" format.
-*
-* - S (subject) = field
-* - V (verb) = operator
-* - O (object) = value
-*
-* @group Export
-*/
+ * Constituent word order (as array) for the "natural_language" format.
+ *
+ * - S (subject) = field
+ * - V (verb) = operator
+ * - O (object) = value
+ *
+ * @group Export
+ */
 type ConstituentWordOrder = ["S", "V", "O"] | ["S", "O", "V"] | ["O", "S", "V"] | ["O", "V", "S"] | ["V", "S", "O"] | ["V", "O", "S"];
 /**
-* Constituent word order (as string) for the "natural_language" format.
-*
-* - S (subject) = field
-* - V (verb) = operator
-* - O (object) = value
-*
-* @group Export
-*/
+ * Constituent word order (as string) for the "natural_language" format.
+ *
+ * - S (subject) = field
+ * - V (verb) = operator
+ * - O (object) = value
+ *
+ * @group Export
+ */
 type ConstituentWordOrderString = "SVO" | "SOV" | "OSV" | "OVS" | "VSO" | "VOS";
 type RepeatStrings<S extends string[], Depth extends number[] = []> = Depth["length"] extends 2 ? "" : "" | `_${S[number]}${RepeatStrings<S, [...Depth, 1]>}`;
 type ZeroOrMoreGroupVariants = RepeatStrings<["xor", "not"]>;
 /**
-* Rule group condition identifier for the "natural_language" format.
-*
-* @group Export
-*/
+ * Rule group condition identifier for the "natural_language" format.
+ *
+ * @group Export
+ */
 type GroupVariantCondition = "not" | "xor";
 /**
-* Keys for the `translations` config object used by the "natural_language" format.
-*
-* @group Export
-*/
+ * Keys for the `translations` config object used by the "natural_language" format.
+ *
+ * @group Export
+ */
 type NLTranslationKey = "and" | "or" | "true" | "false" | "ruleSeparator" | "betweenAnd" | "afterSubject" | "afterVerb" | "afterObject" | "listSeparator" | `groupPrefix${ZeroOrMoreGroupVariants}` | `groupSuffix${ZeroOrMoreGroupVariants}`;
 /**
-* `translations` config object for "natural_language" format.
-*
-* @group Export
-*/
+ * `translations` config object for "natural_language" format.
+ *
+ * @group Export
+ */
 type NLTranslations = Partial<Record<NLTranslationKey, string>>;
 //#endregion
-export { SetRequired as A, RuleGroupTypeIC as C, RuleGroupType as D, DefaultRuleGroupType as E, RuleType as O, RuleGroupTypeAny as S, DefaultOperatorName as T, ValueProcessorLegacy as _, ExportOperatorMap as a, ValueSources as b, NLTranslationKey as c, ParameterizedSQL as d, RQBJsonLogic as f, ValueProcessorByRule as g, SQLPreset as h, ExportObjectFormats as i, Except as j, OptionList as k, NLTranslations as l, RuleProcessor as m, DiagnosticsResult as n, FormatQueryOptions as o, RuleGroupProcessor as p, ExportFormat as r, GroupVariantCondition as s, ConstituentWordOrder as t, ParameterizedNamedSQL as u, ValueProcessorOptions as v, DefaultCombinatorName as w, DefaultRuleGroupTypeIC as x, FullField as y };
-//# sourceMappingURL=index-DlVg-QXo.d.ts.map
+export { DefaultOperatorName as A, FullField as C, RuleGroupTypeIC as D, RuleGroupTypeAny as E, OptionList as F, SetRequired as I, Except as L, RuleGroupType as M, RuleType as N, DefaultCombinatorName as O, ExpressionNode as P, Merge as R, ValueProcessorOptions as S, DefaultRuleGroupTypeIC as T, RuleGroupProcessor as _, DiagnosticsResult as a, ValueProcessorByRule as b, ExportOperatorMap as c, NLTranslationKey as d, NLTranslations as f, RQBJsonLogicVar as g, RQBJsonLogic as h, ConstituentWordOrder as i, DefaultRuleGroupType as j, DefaultCombinatorNameExtended as k, FormatQueryOptions as l, ParameterizedSQL as m, JsonLogicLessThanOrEqual as n, ExportFormat as o, ParameterizedNamedSQL as p, JsonLogicRulesLogic as r, ExportObjectFormats as s, JsonLogicLessThan as t, GroupVariantCondition as u, RuleProcessor as v, ValueSources as w, ValueProcessorLegacy as x, SQLPreset as y };
+//# sourceMappingURL=index-BSwFvkeI.d.ts.map