@react-querybuilder/core 8.22.5 → 8.23.0

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

@@ -1,4 +1,116 @@
+import { produce } from "immer";
 import { JsonLogicAll, JsonLogicAnd, JsonLogicDoubleNegation, JsonLogicEqual, JsonLogicGreaterThan, JsonLogicGreaterThanOrEqual, JsonLogicInArray, JsonLogicInString, JsonLogicLessThan, JsonLogicLessThanOrEqual, JsonLogicNegation, JsonLogicNone, JsonLogicNotEqual, JsonLogicOr, JsonLogicSome, JsonLogicStrictEqual, JsonLogicStrictNotEqual, JsonLogicVar, ReservedOperations as JsonLogicReservedOperations, RulesLogic, RulesLogic as JsonLogicRulesLogic } from "json-logic-js";
+//#region src/controlPropKeys.d.ts
+/**
+ * Runtime data describing the set of query builder controls and the props each one receives.
+ *
+ * These live in `@react-querybuilder/core` (not `react-querybuilder`) so that non-React ports
+ * can consume them without a React dependency.
+ *
+ * Nothing here can drift from the React implementation unnoticed:
+ * `react-querybuilder`'s `types/controlPropKeys.test.ts` gates {@link controlKeys} against
+ * `defaultControlElements` and `ControlElementsProp`, and every entry of
+ * {@link controlPropKeys} against the corresponding props interface—both at runtime and at
+ * compile time, in both directions.
+ */
+/**
+ * The name of every query builder control, alphabetized.
+ *
+ * @group Props
+ */
+declare const controlKeys: readonly ["actionElement", "addGroupAction", "addRuleAction", "cloneGroupAction", "cloneRuleAction", "combinatorSelector", "dragHandle", "fieldSelector", "inlineCombinator", "lockGroupAction", "lockRuleAction", "matchModeEditor", "muteGroupAction", "muteRuleAction", "notToggle", "operatorSelector", "removeGroupAction", "removeRuleAction", "rule", "ruleGroup", "ruleGroupBodyElements", "ruleGroupHeaderElements", "shiftActions", "undoRedoActions", "valueEditor", "valueSelector", "valueSourceSelector"];
+/**
+ * The name of a query builder control.
+ *
+ * @group Props
+ */
+type ControlKey = (typeof controlKeys)[number];
+/**
+ * The full set of prop names each default control receives. Ports can use this to declare
+ * every prop explicitly instead of relying on fall-through/attribute inheritance.
+ *
+ * Each array is the complete, alphabetized key set of the control's props interface in
+ * `react-querybuilder`. The lists are written out in full rather than composed from shared
+ * bases because `--isolatedDeclarations` cannot infer array types built with spreads. A
+ * compile-time gate in `react-querybuilder` (`types/controlPropKeys.test.ts`) fails the build
+ * if any list drifts from its interface in either direction.
+ *
+ * @group Props
+ */
+declare const controlPropKeys: {
+  readonly actionElement: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly addGroupAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly addRuleAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly cloneGroupAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly cloneRuleAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly combinatorSelector: readonly ["className", "context", "disabled", "handleOnChange", "level", "options", "path", "ruleGroup", "rules", "schema", "testID", "title", "validation", "value"];
+  readonly dragHandle: readonly ["className", "context", "disabled", "dragHandleAttributes", "label", "level", "path", "ruleOrGroup", "schema", "testID", "title", "validation"];
+  readonly fieldSelector: readonly ["className", "context", "disabled", "handleOnChange", "level", "operator", "options", "path", "rule", "schema", "testID", "title", "validation", "value"];
+  readonly inlineCombinator: readonly ["className", "component", "context", "disabled", "handleOnChange", "level", "options", "path", "ruleGroup", "rules", "schema", "testID", "title", "validation", "value"];
+  readonly lockGroupAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly lockRuleAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly matchModeEditor: readonly ["className", "classNames", "context", "disabled", "field", "fieldData", "handleOnChange", "level", "match", "numericEditorComponent", "options", "path", "rule", "schema", "selectorComponent", "testID", "thresholdPlaceholder", "title", "validation", "value"];
+  readonly muteGroupAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly muteRuleAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly notToggle: readonly ["checked", "className", "context", "disabled", "handleOnChange", "label", "level", "path", "ruleGroup", "schema", "testID", "title", "validation"];
+  readonly operatorSelector: readonly ["className", "context", "disabled", "field", "fieldData", "handleOnChange", "level", "options", "path", "rule", "schema", "testID", "title", "validation", "value"];
+  readonly removeGroupAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly removeRuleAction: readonly ["className", "context", "disabled", "disabledTranslation", "handleOnClick", "label", "level", "path", "ruleOrGroup", "rules", "schema", "testID", "title", "validation"];
+  readonly rule: readonly ["actions", "context", "disabled", "dndRef", "dragHandleAttributes", "dragMonitorId", "dragRef", "dropEffect", "dropMonitorId", "dropNotAllowed", "field", "groupItems", "id", "isDragging", "isOver", "operator", "parentDisabled", "parentMuted", "path", "rule", "schema", "shiftDownDisabled", "shiftUpDisabled", "translations", "value", "valueSource"];
+  readonly ruleGroup: readonly ["actions", "combinator", "context", "disabled", "dragHandleAttributes", "dragMonitorId", "dragRef", "dropEffect", "dropMonitorId", "dropNotAllowed", "dropRef", "groupItems", "id", "isDragging", "isOver", "not", "parentDisabled", "parentMuted", "path", "previewRef", "ruleGroup", "rules", "schema", "shiftDownDisabled", "shiftUpDisabled", "translations"];
+  readonly ruleGroupBodyElements: readonly ["accessibleDescription", "actions", "addGroup", "addRule", "classNames", "cloneGroup", "combinator", "context", "disabled", "dragHandleAttributes", "dragMonitorId", "dragRef", "dropEffect", "dropMonitorId", "dropNotAllowed", "dropRef", "groupItems", "id", "isDragging", "isOver", "muted", "not", "onCombinatorChange", "onGroupAdd", "onIndependentCombinatorChange", "onNotToggleChange", "outerClassName", "parentDisabled", "parentMuted", "path", "pathsMemo", "previewRef", "removeGroup", "ruleGroup", "rules", "schema", "shiftDownDisabled", "shiftGroupDown", "shiftGroupUp", "shiftUpDisabled", "toggleLockGroup", "toggleMuteGroup", "translations", "validationClassName", "validationResult"];
+  readonly ruleGroupHeaderElements: readonly ["accessibleDescription", "actions", "addGroup", "addRule", "classNames", "cloneGroup", "combinator", "context", "disabled", "dragHandleAttributes", "dragMonitorId", "dragRef", "dropEffect", "dropMonitorId", "dropNotAllowed", "dropRef", "groupItems", "id", "isDragging", "isOver", "muted", "not", "onCombinatorChange", "onGroupAdd", "onIndependentCombinatorChange", "onNotToggleChange", "outerClassName", "parentDisabled", "parentMuted", "path", "pathsMemo", "previewRef", "removeGroup", "ruleGroup", "rules", "schema", "shiftDownDisabled", "shiftGroupDown", "shiftGroupUp", "shiftUpDisabled", "toggleLockGroup", "toggleMuteGroup", "translations", "validationClassName", "validationResult"];
+  readonly shiftActions: readonly ["className", "context", "disabled", "labels", "level", "path", "ruleOrGroup", "schema", "shiftDown", "shiftDownDisabled", "shiftUp", "shiftUpDisabled", "testID", "title", "titles", "validation"];
+  readonly undoRedoActions: readonly ["className", "classNames", "context", "disabled", "labels", "level", "path", "ruleOrGroup", "schema", "testID", "title", "titles", "validation"];
+  readonly valueEditor: readonly ["className", "context", "disabled", "field", "fieldData", "handleOnChange", "inputType", "level", "listsAsArrays", "operator", "parseNumbers", "path", "rule", "schema", "selectorComponent", "separator", "skipHook", "testID", "title", "type", "validation", "value", "valueSource", "values"];
+  readonly valueSelector: readonly ["className", "context", "disabled", "handleOnChange", "level", "listsAsArrays", "multiple", "options", "path", "schema", "testID", "title", "validation", "value"];
+  readonly valueSourceSelector: readonly ["className", "context", "disabled", "field", "fieldData", "handleOnChange", "level", "options", "path", "rule", "schema", "testID", "title", "validation", "value"];
+};
+/**
+ * Which bulk override, if any, applies to each control: `"action"` for controls that a supplied
+ * `actionElement` replaces, `"selector"` for controls that a supplied `valueSelector` replaces,
+ * and `null` for controls that neither replaces.
+ *
+ * `actionElement` and `valueSelector` are themselves `null`—they are the _source_ of a bulk
+ * override, not a target of one.
+ *
+ * Replaces name-suffix sniffing (`key.endsWith('Action')`), which would silently misclassify a
+ * future control named e.g. `pathSelector`, and which disagrees between implementations about
+ * whether `shiftActions`/`undoRedoActions` (plural) match. They do not: neither receives the
+ * `actionElement` bulk override.
+ *
+ * @group Props
+ */
+declare const controlKind: {
+  readonly actionElement: null;
+  readonly addGroupAction: "action";
+  readonly addRuleAction: "action";
+  readonly cloneGroupAction: "action";
+  readonly cloneRuleAction: "action";
+  readonly combinatorSelector: "selector";
+  readonly dragHandle: null;
+  readonly fieldSelector: "selector";
+  readonly inlineCombinator: null;
+  readonly lockGroupAction: "action";
+  readonly lockRuleAction: "action";
+  readonly matchModeEditor: null;
+  readonly muteGroupAction: "action";
+  readonly muteRuleAction: "action";
+  readonly notToggle: null;
+  readonly operatorSelector: "selector";
+  readonly removeGroupAction: "action";
+  readonly removeRuleAction: "action";
+  readonly rule: null;
+  readonly ruleGroup: null;
+  readonly ruleGroupBodyElements: null;
+  readonly ruleGroupHeaderElements: null;
+  readonly shiftActions: null;
+  readonly undoRedoActions: null;
+  readonly valueEditor: null;
+  readonly valueSelector: null;
+  readonly valueSourceSelector: "selector";
+};
+//#endregion
 //#region ../../node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
@@ -3195,2334 +3307,2263 @@ declare const defaultMaxHistory = 50;
  */
 declare const defaultCoalesceMs = 500;
 //#endregion
-//#region src/utils/arrayUtils.d.ts
-/**
- * Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters
- * (characters preceded by a backslash) will not apply to the split, and the backslash will
- * be removed in the array element. Inverse of {@link joinWith}.
- *
- * @example
- * splitBy('this\\,\\,that,,the other,,,\\,')
- * // or
- * splitBy('this\\,\\,that,,the other,,,\\,', ',')
- * // would return
- * ['this,,that', '', 'the other', '', '', ',']
- */
-declare const splitBy: (str?: string, splitChar?: string) => string[];
+//#region src/utils/queryTools.d.ts
 /**
- * Joins an array of strings using the given character (see {@link defaultJoinChar}). When
- * the given character appears in an array element, a backslash will be added just before it
- * to distinguish it from the join character. Effectively the inverse of {@link splitBy}.
+ * Why a query tool returned the query unmodified. Query tools never throw; when they cannot
+ * carry out an operation they return the original query and report the reason through
+ * {@link AbortOptions.onAbort}.
  *
- * TIP: The join character can actually be a string of any length. Only the first character
- * will be searched for in the array elements and preceded by a backslash.
+ * `"same-location"` and `"no-change"` describe operations that were valid but had nothing to
+ * do, so they are not errors. Every other reason indicates a target that could not be used.
  *
- * @example
- * joinWith(['this,,that', '', 'the other', '', '', ','], ', ')
- * // would return
- * 'this\\,\\,that, , the other, , , \\,'
- */
-declare const joinWith: (strArr: unknown[], joinChar?: string) => string;
-type IsUnknown<T> = unknown extends T ? true : false;
-type Trimmed<T> = IsUnknown<T> extends true ? string : T;
-/**
- * Trims the value if it is a string. Otherwise returns the value as is.
- */
-declare const trimIfString: <T>(val: T) => Trimmed<T>;
-type ToArrayResult<T> = IsUnknown<T> extends true ? string[] : T extends readonly (infer U)[] ? Trimmed<U>[] : T extends string ? string[] : T extends number ? number[] : never[];
-/**
- * Splits a string by comma then trims each element. Arrays are returned as is except
- * any string elements are trimmed.
+ * @group Query Tools
  */
-declare const toArray: <T>(a: T, { retainEmptyStrings }?: {
-  retainEmptyStrings?: boolean;
-}) => ToArrayResult<T>;
+type AbortReason = "target-not-found" | "parent-not-found" | "parent-not-a-group" | "destination-not-found" | "root-not-allowed" | "not-a-combinator-slot" | "same-location" | "no-change" | "target-disabled" | "parent-disabled" | "max-levels-exceeded";
 /**
- * Determines if an array is free of `null`/`undefined`.
+ * Details about an aborted query tool operation.
+ *
+ * @group Query Tools
  */
-declare const nullFreeArray: <T>(arr: T[]) => arr is Exclude<T, null>[];
-//#endregion
-//#region ../../node_modules/clsx/clsx.d.mts
-type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
-type ClassDictionary = Record<string, any>;
-type ClassArray = ClassValue[];
-declare function clsx(...inputs: ClassValue[]): string;
-//#endregion
-//#region src/utils/convertQuery.d.ts
+interface AbortInfo {
+  /** Why the operation was aborted. */
+  reason: AbortReason;
+  /** The query tool that aborted. */
+  operation: "add" | "remove" | "update" | "move" | "insert" | "group";
+  /** The path or `id` that could not be used, when the reason relates to a specific target. */
+  pathOrID?: Path | string;
+}
 /**
- * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.
+ * Options that block a mutation before it is attempted.
  *
- * This function is idempotent: {@link RuleGroupType} queries will be
- * returned as-is.
+ * `disabled` is a property of the query itself, so honoring it is a matter of data integrity
+ * rather than presentation: a query saved with a locked rule should stay locked when it is
+ * loaded again. It is opt-in here only to preserve the existing behavior of the standalone
+ * query tools; {@link QueryManager} enables it by default.
  *
  * @group Query Tools
  */
-declare const convertFromIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupType<RG>;
+interface GuardOptions {
+  /**
+   * Abort when the target (or its parent, for `add`/`insert`) is disabled, either directly or
+   * by descending from a disabled group. Defaults to `false`.
+   *
+   * Updating a rule or group's own `disabled` property is always permitted, since it is the
+   * only way to re-enable it.
+   */
+  respectDisabled?: boolean;
+  /**
+   * Paths that are disabled without the corresponding rule or group carrying a `disabled`
+   * property, mirroring the array form of the `QueryBuilder` `disabled` prop. A path is treated
+   * as disabled if it appears here or descends from a path that does.
+   *
+   * Like the `disabled` property, this is only honored when `respectDisabled` is `true`, and
+   * updating a rule or group's own `disabled` property is still permitted.
+   */
+  disabledPaths?: Path[];
+  /** Abort every mutation, as though the entire query were disabled. Defaults to `false`. */
+  queryDisabled?: boolean;
+  /**
+   * The maximum depth at which a group may be added. A group whose parent path is already this
+   * deep is rejected by `add` and `insert`. Rules are unaffected. Defaults to `Infinity`.
+   */
+  maxLevels?: number;
+}
 /**
- * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.
- *
- * This function is idempotent: {@link RuleGroupTypeIC} queries will be
- * returned as-is.
+ * Options for reporting aborted query tool operations.
  *
  * @group Query Tools
  */
-declare const convertToIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupTypeIC<RG>;
+interface AbortOptions extends GuardOptions {
+  /**
+   * Called when the operation returns the query unmodified, with the reason why. Query tools
+   * never throw, so this is the only way to distinguish "the target was invalid" from
+   * "the operation had nothing to do".
+   */
+  onAbort?: (info: AbortInfo) => void;
+}
 /**
- * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit
- * operation, use {@link convertToIC}.
+ * Options shared by every query tool.
  *
  * @group Query Tools
  */
-declare function convertQuery(query: RuleGroupType): RuleGroupTypeIC;
+interface QueryToolOptions extends AbortOptions {
+  /**
+   * Set `false` to skip immer's auto-freeze on the returned query, e.g. when the query will be
+   * handed to a framework that wraps it in a proxy (Vue `reactive`, Solid stores) or otherwise
+   * needs to mutate it. Ignored by the `*InPlace` variants, which never freeze.
+   *
+   * @default true
+   */
+  freeze?: boolean;
+}
 /**
- * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit
- * operation, use {@link convertFromIC}.
+ * Whether a mutation targeting `pathOrID` is blocked by the given guards, and why.
+ * Returns `null` when the mutation may proceed.
+ *
+ * Exported so that callers which run their own logic before mutating—such as a UI layer that
+ * invokes a confirmation callback—can apply the same rules without duplicating them.
  *
  * @group Query Tools
  */
-declare function convertQuery(query: RuleGroupTypeIC): RuleGroupType;
-//#endregion
-//#region src/utils/deriveClassNames.d.ts
-/** Classname keys that have both a standard class and a `controlClassnames` entry. */
-type StandardClassnameKey = keyof typeof standardClassnames & keyof Classnames;
+declare const getGuardAbortReason: (query: RuleGroupTypeAny, pathOrID: Path | string | undefined, guards?: GuardOptions, { asParent }?: {
+  asParent?: boolean;
+}) => AbortReason | null;
 /**
- * A classname applied only when `when` returns true for the current state.
+ * Whether adding a group beneath `parentPath` would exceed `maxLevels`.
  *
- * `key` is used to look up both the standard classname and the corresponding `controlClassnames`
- * entry. Set `standardOnly` when the standard class is conditional but no custom class
- * corresponds to it.
+ * @group Query Tools
  */
-interface ClassnameCondition<S> {
-  key: StandardClassnameKey;
-  when: (state: S) => boolean | undefined;
-  standardOnly?: boolean;
-}
+declare const exceedsMaxLevels: (parentPath: Path | undefined, { maxLevels }?: GuardOptions) => boolean;
 /**
- * How one derived classname is composed: the `controlClassnames` keys that contribute to it (in
- * application order, after the standard classname), plus any state-dependent classes.
+ * Options for {@link add}.
+ *
+ * @group Query Tools
  */
-interface ClassnameSpec<S> {
-  sources: readonly (keyof Classnames)[];
-  conditions?: readonly ClassnameCondition<S>[];
-}
-/** Keys of the `classNames` object returned for a rule. */
-type RuleClassnameKey = "shiftActions" | "dragHandle" | "fields" | "matchMode" | "matchThreshold" | "operators" | "valueSource" | "value" | "cloneRule" | "lockRule" | "muteRule" | "removeRule" | "valueListItem";
-/** Keys of the `classNames` object returned for a rule group. */
-type RuleGroupClassnameKey = "header" | "shiftActions" | "undoRedoActions" | "undoAction" | "redoAction" | "dragHandle" | "combinators" | "notToggle" | "addRule" | "addGroup" | "cloneGroup" | "lockGroup" | "muteGroup" | "removeGroup" | "body";
-/** Drag-and-drop state that can contribute conditional classnames. */
-interface DndClassNameState {
-  isDragging?: boolean;
-  isOver?: boolean;
-  dropEffect?: "move" | "copy";
-  groupItems?: boolean;
-  dropNotAllowed?: boolean;
-}
-/** State that contributes conditional classnames to a rule's wrapper element. */
-interface RuleClassNameState extends DndClassNameState {
-  disabled?: boolean;
-  muted?: boolean;
-  hasSubQuery?: boolean;
-}
-/** State that contributes conditional classnames to the query builder's wrapper element. */
-interface QueryBuilderClassNameState {
-  disabled?: boolean;
-  validationResult?: boolean | ValidationMap;
+interface AddOptions extends QueryToolOptions {
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
+   * combinators), then the first combinator in this list will be inserted
+   * before the new rule/group if the parent group is not empty. This option
+   * is overridden by `combinatorPreceding`.
+   */
+  combinators?: OptionList;
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
+   * combinators), then this combinator will be inserted before the new rule/group
+   * if the parent group is not empty. This option will supersede `combinators`.
+   */
+  combinatorPreceding?: string;
+  /**
+   * ID generator.
+   */
+  idGenerator?: () => string;
 }
-/** Options common to every classname derivation. */
-interface DeriveClassNamesOptions {
-  /** The merged `controlClassnames` for the query builder. */
-  classNames: Partial<Classnames> | undefined;
-  /** When `true`, standard (`rule`, `ruleGroup-*`, etc.) classnames are omitted. */
-  suppressStandardClassnames?: boolean;
+interface AddMethod {
+  <RG extends RuleGroupTypeAny>(query: RG, ruleOrGroup: RG | RuleType, parentPathOrID: Path | string, options?: AddOptions): RG;
 }
 /**
- * Classnames for each element rendered by a rule. This is the framework-agnostic core of the
- * `classNames` object returned by the `useRule` hook.
+ * Adds a rule or group to a query without mutating the original query.
+ *
+ * @returns A new query with the rule or group added.
  *
  * @group Query Tools
  */
-declare const deriveRuleClassNames: (options: DeriveClassNamesOptions) => Record<RuleClassnameKey, string>;
+declare const add: AddMethod;
 /**
- * The classname for a single element of a rule, composed from the same table as
- * {@link deriveRuleClassNames}. Useful where only one is needed, such as the items of a
- * multi-value editor.
+ * Adds a rule or group to a query in place.
+ *
+ * @returns The query (mutated in place) with the rule or group added.
  *
  * @group Query Tools
  */
-declare const deriveRuleClassName: (key: RuleClassnameKey, options: DeriveClassNamesOptions) => string;
+declare const addInPlace: AddMethod;
 /**
- * Classnames for each element rendered by a rule group, including its conditionally-classed
- * `header`. This is the framework-agnostic core of the `classNames` object returned by the
- * `useRuleGroup` hook.
+ * Options for {@link update}.
  *
  * @group Query Tools
  */
-declare const deriveRuleGroupClassNames: (options: DeriveClassNamesOptions & DndClassNameState) => Record<RuleGroupClassnameKey, string>;
-/** Inputs common to every outer (wrapper) classname derivation. */
-interface OuterClassNameOptionsBase extends DeriveClassNamesOptions {
+interface UpdateOptions extends QueryToolOptions {
   /**
-   * Classnames contributed by the rule or group itself and its configuration, applied first.
-   * For a rule that is the rule/field/operator classnames; for a group, the group and combinator
-   * classnames.
+   * When updating the `field` of a rule, the rule's `operator`, `value`, and `valueSource`
+   * will be reset to their respective defaults. Defaults to `true`.
    */
-  leadingClassNames?: (Classname | null)[];
-  /** Appended last, as produced by `getValidationClassNames`. */
-  validationClassName?: Classname;
+  resetOnFieldChange?: boolean;
+  /**
+   * When updating the `operator` of a rule, the rule's `value` and `valueSource`
+   * will be reset to their respective defaults. Defaults to `false`.
+   */
+  resetOnOperatorChange?: boolean;
+  /**
+   * Determines the default operator name for a given field.
+   */
+  getRuleDefaultOperator?: (field: string) => string;
+  /**
+   * Determines the valid value sources for a given field and operator.
+   */
+  getValueSources?: (field: string, operator: string) => ValueSources | ValueSourceFlexibleOptions;
+  /**
+   * Gets the default value for a given rule, in case the value needs to be reset.
+   */
+  getRuleDefaultValue?: (rule: RuleType) => any;
+  /**
+   * Determines the valid match modes for a given field.
+   */
+  getMatchModes?: (field: string) => MatchModeOptions;
+}
+interface UpdateMethod {
+  /**
+   * Updates a single property of a rule or group.
+   */
+  <RG extends RuleGroupTypeAny>(query: RG, prop: UpdateableProperties, value: any, pathOrID: Path | string, options?: UpdateOptions): RG;
+  /**
+   * Updates multiple properties of a rule or group using parallel arrays of
+   * property names and corresponding values.
+   */
+  <RG extends RuleGroupTypeAny>(query: RG, props: UpdateableProperties[], values: any[], pathOrID: Path | string, options?: UpdateOptions): RG;
+  /**
+   * Updates multiple properties of a rule or group using a map of property
+   * names to their new values.
+   */
+  <RG extends RuleGroupTypeAny>(query: RG, props: UpdateValueMap, pathOrID: Path | string, options?: UpdateOptions): RG;
 }
-/** Inputs to {@link deriveRuleOuterClassName} and {@link deriveRuleGroupOuterClassName}. */
-interface OuterClassNameOptions extends OuterClassNameOptionsBase, RuleClassNameState {}
 /**
- * The outer (wrapper) classname for a rule, including every conditional state class.
+ * Updates one or more properties of a rule or group within a query without
+ * mutating the original query. Properties may be supplied individually
+ * (`prop`, `value`), as parallel arrays (`props`, `values`), or as a
+ * property-to-value map. For multi-property updates, `field`, `operator`, and
+ * `valueSource` are applied before `value`, so an explicit `value` is never
+ * reset by a change to one of those properties.
+ *
+ * @returns A new query with the rule or group properties updated.
  *
  * @group Query Tools
  */
-declare const deriveRuleOuterClassName: (options: OuterClassNameOptions) => string;
+declare const update: UpdateMethod;
 /**
- * The outer (wrapper) classname for a rule group, including every conditional state class.
+ * Updates one or more properties of a rule or group within a query in place.
+ * See {@link update} for the supported argument forms and ordering semantics.
  *
- * A group reflects fewer drag-and-drop states than a rule—`dndOver`, `dndCopy`,
- * `dndDropNotAllowed`, and `hasSubQuery` do not apply—so this is not interchangeable with
- * {@link deriveRuleOuterClassName}.
+ * @returns The query (mutated in place) with the rule or group properties updated.
  *
  * @group Query Tools
  */
-declare const deriveRuleGroupOuterClassName: (options: OuterClassNameOptions) => string;
+declare const updateInPlace: UpdateMethod;
 /**
- * The outer (wrapper) classname for the query builder itself, including the conditional
- * `disabled`, `valid`, and `invalid` state classes.
+ * Options for {@link remove}.
  *
  * @group Query Tools
  */
-declare const deriveQueryBuilderClassNames: (options: OuterClassNameOptionsBase & QueryBuilderClassNameState) => string;
-//#endregion
-//#region src/utils/defaultValidator.d.ts
-/**
- * This is an example validation function you can pass to {@link react-querybuilder!QueryBuilder QueryBuilder} in the
- * `validator` prop. It assumes that you want to validate groups, and has a no-op
- * for validating rules which you can replace with your own implementation.
- */
-declare const defaultValidator: QueryValidator;
-//#endregion
-//#region src/utils/deriveRuleContext.d.ts
-/**
- * Functions used by {@link deriveRuleContext} to resolve a rule's configuration. Each corresponds
- * to the `QueryBuilder` prop (or `useQueryBuilderSetup` output) of the same name.
- */
-interface RuleContextResolvers<F extends FullField = FullField> {
-  fields: OptionList<F>;
-  fieldMap: Partial<FullOptionRecord<FullField>>;
-  getInputType: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => InputType | null;
-  getMatchModes: (field: string, misc: {
-    fieldData: F;
-  }) => MatchModeOptions;
-  getOperators: (field: string, misc: {
-    fieldData: F;
-  }) => OptionList<FullOperator>;
-  getParameters: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => FlexibleOptionList<Option>;
-  getValueEditorType: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => ValueEditorType;
-  getValues: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => FlexibleOptionList<Option>;
-  getValueSources: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => ValueSourceFullOptions;
-  getSubQueryBuilderProps?: (field: string, misc: {
-    fieldData: F;
-  }) => Record<string, unknown>;
-}
-/**
- * Everything {@link deriveRuleContext} resolves for a single rule.
- */
-interface RuleContext<F extends FullField = FullField> {
-  fieldData: F;
-  hideValueControls: boolean;
-  inputType: InputType | null;
-  matchModes: MatchModeOptions;
-  operatorObject: FullOperator | undefined;
-  operators: OptionList<FullOperator>;
-  parameters: FlexibleOptionList<Option> | null;
-  validationResult: boolean | ValidationResult;
-  valueEditorType: ValueEditorType;
-  values: FlexibleOptionList<Option>;
-  valueSourceOptions: ValueSourceFullOptions;
-  valueSources: ValueSources;
-  subQueryBuilderProps: Record<string, unknown>;
+interface RemoveOptions extends QueryToolOptions {}
+interface RemoveMethod {
+  <RG extends RuleGroupTypeAny>(query: RG, pathOrID: Path | string, options?: RemoveOptions): RG;
 }
 /**
- * Resolves the field configuration for a rule's `field`, falling back to a minimal option object
- * when the field isn't present in the field map.
- */
-declare const getFieldData: (field: string, fieldMap: Partial<FullOptionRecord<FullField>>) => FullField;
-/**
- * The input type for a rule. A field's own `inputType` takes precedence over `getInputType`.
- */
-declare const getRuleInputType: <F extends FullField = FullField>(field: string, operator: string, fieldData: F, getInputType: RuleContextResolvers<F>["getInputType"]) => InputType | null;
-/**
- * Whether the value editor(s) should be hidden for an operator, based on its `arity`.
- */
-declare const hideValueControlsForOperator: (operatorObject?: FullOperator) => boolean;
-/**
- * The subset of a rule that determines its configuration. Accepting only these properties (rather
- * than the whole rule) lets React callers keep granular memoization dependencies, so editing a
- * rule's `value` doesn't recompute its operators, value sources, or option lists.
- */
-type RuleFacet = Pick<RuleType, "field" | "operator" | "valueSource">;
-/**
- * Value source options for a rule. A `valueSource` present on the rule but absent from the
- * configured list is appended, so the current selection is always representable.
- */
-declare const getRuleValueSourceOptions: <F extends FullField = FullField>(rule: RuleFacet, fieldData: F, getValueSources: RuleContextResolvers<F>["getValueSources"]) => ValueSourceFullOptions;
-/**
- * Normalizes the result of `getParameters` to a non-empty list or `null`.
- */
-declare const getParametersAsList: (parameters: FlexibleOptionList<Option>) => FlexibleOptionList<Option> | null;
-/**
- * The value editor type for a rule. `valueSource: "field"` always uses a select list, and
- * `valueSource: "parameter"` uses a (multi)select when parameters are available.
- */
-declare const getRuleValueEditorType: <F extends FullField = FullField>(rule: RuleFacet, fieldData: F, parametersAsList: FlexibleOptionList<Option> | null, getValueEditorType: RuleContextResolvers<F>["getValueEditorType"]) => ValueEditorType;
-/**
- * The option list presented by a rule's value editor, resolved from its `valueSource`.
- */
-declare const getRuleValues: <F extends FullField = FullField>(rule: RuleFacet, fieldData: F, fields: OptionList<F>, parametersAsList: FlexibleOptionList<Option> | null, getValues: RuleContextResolvers<F>["getValues"]) => FlexibleOptionList<Option>;
-/**
- * The validation result for a rule: the entry from a query-level {@link ValidationMap} if present,
- * otherwise the field's own `validator` result, otherwise `null`.
+ * Removes a rule or group from a query without mutating the original query.
+ *
+ * @returns A new query with the rule or group removed.
+ *
+ * @group Query Tools
  */
-declare const getRuleValidationResult: (rule: RuleType, fieldData: FullField, validationMap?: ValidationMap, id?: string) => boolean | ValidationResult;
+declare const remove: RemoveMethod;
 /**
- * Resolves everything about a single rule that depends on the field/operator configuration:
- * its field data, operators, value editor type, value list, value sources, match modes, and
- * validation result.
+ * Removes a rule or group from a query in place.
  *
- * This is the framework-agnostic core of the `useRule` hook, shared with
- * {@link QueryManager.getRuleContext} so that non-React implementations derive identical results.
- * It performs no memoization; callers are responsible for caching as appropriate.
+ * @returns The query (mutated in place) with the rule or group removed.
  *
  * @group Query Tools
  */
-declare const deriveRuleContext: <F extends FullField = FullField>(rule: RuleType, resolvers: RuleContextResolvers<F>, options?: {
-  validationMap?: ValidationMap;
-  id?: string;
-}) => RuleContext<F>;
+declare const removeInPlace: RemoveMethod;
 /**
- * Everything {@link deriveRuleGroupContext} resolves for a single rule group.
+ * Options for {@link move}.
+ *
+ * @group Query Tools
  */
-interface RuleGroupContext<C extends FullCombinator = FullCombinator> {
-  combinator: string;
-  combinatorObject: C | undefined;
-  combinators: FullOptionList<C>;
-  /** The `className` of the selected combinator, or `null` for independent combinators. */
-  combinatorBasedClassName: Classname | null;
-  independentCombinators: boolean;
-  validationResult: boolean | ValidationResult;
+interface MoveOptions extends QueryToolOptions {
+  /**
+   * When `true`, the source rule/group will not be removed from its original path.
+   */
+  clone?: boolean;
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query is using independent
+   * combinators), then the first combinator in this list will be inserted before
+   * the rule/group if necessary.
+   */
+  combinators?: OptionList;
+  /**
+   * ID generator.
+   */
+  idGenerator?: () => string;
+}
+interface MoveMethod {
+  <RG extends RuleGroupTypeAny>(query: RG, oldPathOrID: Path | string, newPath: Path | "up" | "down", options?: MoveOptions): RG;
 }
 /**
- * The effective combinator for a group: its own `combinator` when it has one, otherwise the
- * first configured combinator (which is the case for groups with independent combinators).
+ * Moves a rule or group from one path to another without mutating the original query.
+ * In the options parameter, pass `{ clone: true }` to copy instead of move.
  *
- * This intentionally covers only the current property-based API. The `RuleGroup` component
- * additionally falls back to its deprecated `combinator` prop; that fallback stays in the hook.
+ * @returns A new query with the rule or group moved or cloned.
+ *
+ * @group Query Tools
  */
-declare const getRuleGroupCombinator: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>) => string;
+declare const move: MoveMethod;
 /**
- * Resolves everything about a rule group that depends on the combinator configuration, plus its
- * validation result.
+ * Moves a rule or group from one path to another in place.
+ * In the options parameter, pass `{ clone: true }` to copy instead of move.
  *
- * Note that unlike {@link deriveRuleContext}, there is no field-level validator fallback—a
- * group's validation result comes only from the query-level {@link ValidationMap}.
+ * @returns The query (mutated in place) with the rule or group moved or cloned.
  *
  * @group Query Tools
  */
-declare const deriveRuleGroupContext: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>, options?: {
-  validationMap?: ValidationMap;
-  id?: string;
-}) => RuleGroupContext<C>;
-//#endregion
-//#region src/utils/deriveValueEditor.d.ts
+declare const moveInPlace: MoveMethod;
 /**
- * Whether an operator's value is a list of two bounds.
+ * Options for {@link insert}.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const isBetweenOperator: (operator: string) => boolean;
-/**
- * Determines whether a rule's `value` needs to be collapsed to a single element because it no
- * longer represents a list, and what it should become.
- *
- * This happens when the value is an array (or a comma-containing string in a `number` input,
- * which `<input type="number">` can't display) while the operator is not one of the multi-value
- * operators and the editor is not a multiselect—typically right after the operator changes from
- * `"in"` or `"between"` to something else.
+interface InsertOptions extends QueryToolOptions {
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
+   * combinators), then the first combinator in this list will be inserted
+   * before the new rule/group if the parent group is not empty. This option
+   * is overridden by `combinatorPreceding`.
+   */
+  combinators?: OptionList;
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
+   * combinators), then this combinator will be inserted before the new rule/group
+   * if the parent group is not empty and the new rule/group is not the first in the
+   * group (`path.at(-1) > 0`). This option will supersede `combinators`.
+   */
+  combinatorPreceding?: string;
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
+   * combinators), then this combinator will be inserted after the new rule/group
+   * if the parent group is not empty and the new rule/group is the first in the
+   * group (`path.at(-1) === 0`). This option will supersede `combinators`.
+   */
+  combinatorSucceeding?: string;
+  /**
+   * ID generator.
+   *
+   * @default generateID
+   */
+  idGenerator?: () => string;
+  /**
+   * When `true`, the new rule/group will replace the rule/group at `path`.
+   */
+  replace?: boolean;
+}
+interface InsertMethod {
+  <RG extends RuleGroupTypeAny>(query: RG, ruleOrGroup: RG | RuleType, path: number[], options?: InsertOptions): RG;
+}
+/**
+ * Inserts a rule or group into a query without mutating the original query.
  *
- * The React `useValueEditor` hook applies the result in an effect; other implementations may
- * apply it wherever is idiomatic.
+ * @returns A new query with the rule or group inserted.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const getValueEditorReset: ({ skipHook, type, operator, value, inputType }: {
-  skipHook?: boolean;
-  type?: string;
-  operator: string;
-  value: unknown;
-  inputType?: InputType | null;
-}) => {
-  reset: boolean;
-  value: unknown;
-};
+declare const insert: InsertMethod;
 /**
- * Produces the next value for a series of value editors when the editor at `index` changes.
+ * Inserts a rule or group into a query in place.
  *
- * For `between`/`notBetween`, editing the first bound guarantees an array of at least two
- * elements, seeding the second from the first available option. The result is a comma-joined
- * string unless `listsAsArrays` is `true`.
+ * @returns The query (mutated in place) with the rule or group inserted.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const getMultiValueUpdate: ({ value, index, valueAsArray, operator, values, listsAsArrays, parseNumberMethod }: {
-  value: unknown;
-  index: number;
-  valueAsArray: unknown[];
-  operator: string;
-  values?: any[];
-  listsAsArrays?: boolean;
-  parseNumberMethod?: ParseNumberMethod;
-}) => unknown;
+declare const insertInPlace: InsertMethod;
 /**
- * Coerces a value to a `bigint`, falling back to the parsed number when it can't be represented
- * as one (an empty string or a decimal, for example).
+ * Options for {@link group}.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const coerceBigIntValue: (value: unknown, parseNumberMethod?: ParseNumberMethod) => unknown;
+interface GroupOptions extends QueryToolOptions {
+  /**
+   * When `true`, the source rule/group will not be removed from its original path.
+   */
+  clone?: boolean;
+  /**
+   * If the query extends `RuleGroupTypeIC` (i.e. the query is using independent
+   * combinators), then the first combinator in this list will be inserted between
+   * the two rules/groups.
+   */
+  combinators?: OptionList;
+  /**
+   * ID generator.
+   */
+  idGenerator?: () => string;
+}
+interface GroupMethod {
+  <RG extends RuleGroupTypeAny>(query: RG, sourcePathOrID: Path | string, targetPathOrID: Path | string, options?: GroupOptions): RG;
+}
 /**
- * The `type` attribute an `<input>` should use for a rule. `bigint` values and the `in`/`notIn`
- * operators (whose value is a comma-separated list) both require a text input.
+ * Creates a new group at a target path with its `rules` array containing the current
+ * objects at the target path and the source path without mutating the original query.
+ * In the options parameter, pass `{ clone: true }` to copy the source rule/group instead of move.
  *
- * @group Value Editors
- */
-declare const coerceInputType: (inputType: InputType | null | undefined, operator: string) => InputType;
-/**
- * Produces the next value for a value selector. Multiselect values are normalized to an array
- * first, then comma-joined unless `listsAsArrays` is `true`. Single-select values pass through.
+ * @returns A new query with the rules or groups grouped.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const getValueSelectorUpdate: (value: string | string[], { multiple, listsAsArrays }?: {
-  multiple?: boolean;
-  listsAsArrays?: boolean;
-}) => string | string[];
+declare const group: GroupMethod;
 /**
- * Normalizes a value selector's current value for display. Multiselect values become an array of
- * strings so they match option names, which are always strings (e.g. `[42]` becomes `["42"]`).
+ * Creates a new group at a target path with its `rules` array containing the current
+ * objects at the target path and the source path in place.
+ * In the options parameter, pass `{ clone: true }` to copy the source rule/group instead of move.
  *
- * @group Value Editors
+ * @returns The query (mutated in place) with the rules or groups grouped.
+ *
+ * @group Query Tools
  */
-declare const normalizeValueSelectorValue: (value: unknown, multiple?: boolean) => any;
+declare const groupInPlace: GroupMethod;
 //#endregion
-//#region src/utils/filterFieldsByComparator.d.ts
+//#region src/utils/abortReasons.d.ts
 /**
- * For a given {@link FullField}, returns the `fields` list filtered for
- * other fields that match by `comparator`. Only fields *other than the
- * one in question* will ever be included, even if `comparator` is `null`
- * or `undefined`. If `comparator` is a string, fields with the same value
- * for that property will be included. If `comparator` is a function, each
- * field will be passed to the function along with the `operator` and fields
- * for which the function returns `true` will be included.
+ * Abort reasons that {@link QueryManager}'s `strict` mode treats as errors. The remaining
+ * reasons—`"same-location"` and `"no-change"`—describe valid operations that had nothing to do,
+ * so they are reported to `onInvalidTarget` but never throw.
  *
- * @group Option Lists
+ * Declared apart from `QueryManager` so the `@react-querybuilder/core/derivations` entry point can
+ * export it without putting the manager in its module graph.
+ *
+ * @group Query Tools
  */
-declare const filterFieldsByComparator: (field: FullField, fields: OptionList<FullField>, operator: string) => FullField[] | {
-  options: WithUnknownIndex<FullField>[];
-  label: string;
-}[];
+declare const strictAbortReasons: readonly AbortReason[];
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
+//#region src/utils/arrayUtils.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "cel" format.
+ * Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters
+ * (characters preceded by a backslash) will not apply to the split, and the backslash will
+ * be removed in the array element. Inverse of {@link joinWith}.
  *
- * @group Export
+ * @example
+ * splitBy('this\\,\\,that,,the other,,,\\,')
+ * // or
+ * splitBy('this\\,\\,that,,the other,,,\\,', ',')
+ * // would return
+ * ['this,,that', '', 'the other', '', '', ',']
  */
-declare const defaultRuleProcessorCEL: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorMongoDB.d.ts
+declare const splitBy: (str?: string, splitChar?: string) => string[];
 /**
- * Default rule processor used by {@link formatQuery} for "mongodb" format.
+ * Joins an array of strings using the given character (see {@link defaultJoinChar}). When
+ * the given character appears in an array element, a backslash will be added just before it
+ * to distinguish it from the join character. Effectively the inverse of {@link splitBy}.
  *
- * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
+ * TIP: The join character can actually be a string of any length. Only the first character
+ * will be searched for in the array elements and preceded by a backslash.
  *
- * @group Export
+ * @example
+ * joinWith(['this,,that', '', 'the other', '', '', ','], ', ')
+ * // would return
+ * 'this\\,\\,that, , the other, , , \\,'
  */
-declare const defaultRuleProcessorMongoDB: RuleProcessor;
+declare const joinWith: (strArr: unknown[], joinChar?: string) => string;
+type IsUnknown<T> = unknown extends T ? true : false;
+type Trimmed<T> = IsUnknown<T> extends true ? string : T;
+/**
+ * Trims the value if it is a string. Otherwise returns the value as is.
+ */
+declare const trimIfString: <T>(val: T) => Trimmed<T>;
+type ToArrayResult<T> = IsUnknown<T> extends true ? string[] : T extends readonly (infer U)[] ? Trimmed<U>[] : T extends string ? string[] : T extends number ? number[] : never[];
+/**
+ * Splits a string by comma then trims each element. Arrays are returned as is except
+ * any string elements are trimmed.
+ */
+declare const toArray: <T>(a: T, { retainEmptyStrings }?: {
+  retainEmptyStrings?: boolean;
+}) => ToArrayResult<T>;
+/**
+ * Determines if an array is free of `null`/`undefined`.
+ */
+declare const nullFreeArray: <T>(arr: T[]) => arr is Exclude<T, null>[];
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSpEL.d.ts
+//#region ../../node_modules/clsx/clsx.d.mts
+type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+declare function clsx(...inputs: ClassValue[]): string;
+//#endregion
+//#region src/utils/coalesce.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "spel" format.
+ * Determines whether a change should be absorbed into the current history entry instead of
+ * pushing a new one. This is the exact rule {@link QueryManager} applies when recording history,
+ * exposed so non-React implementations can manage their own history stacks without
+ * reimplementing (and drifting from) the semantics.
  *
- * @group Export
+ * A change coalesces only when all three hold:
+ * - the change is not structural (rules/groups added, removed, moved, or reordered)
+ * - its signature matches the previously recorded signature
+ * - it occurred within `coalesceMs` of the previous recording
+ *
+ * Note that {@link unchangedSignature} is not handled here. A change with no observable
+ * difference is never recorded at all, which is a separate decision made before this check.
+ *
+ * @param prevSig Signature of the previously recorded change, or `undefined` if there is none.
+ * @param nextSig Signature of the change being recorded, from {@link signatureOf}.
+ * @param prevAt Timestamp of the previous recording.
+ * @param now Timestamp of the change being recorded.
+ * @param coalesceMs Coalescing window in milliseconds.
  */
-declare const defaultRuleProcessorSpEL: RuleProcessor;
+declare const shouldCoalesce: (prevSig: string | undefined, nextSig: string, prevAt: number, now: number, coalesceMs?: number) => boolean;
 //#endregion
-//#region src/utils/formatQuery/defaultValueProcessorByRule.d.ts
+//#region src/utils/convertQuery.d.ts
 /**
- * Default value processor used by {@link formatQuery} for "sql" format.
+ * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.
  *
- * @group Export
+ * This function is idempotent: {@link RuleGroupType} queries will be
+ * returned as-is.
+ *
+ * @group Query Tools
  */
-declare const defaultValueProcessorByRule: ValueProcessorByRule;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.d.ts
+declare const convertFromIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupType<RG>;
 /**
- * Rule group processor used by {@link formatQuery} for "cel" format.
+ * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.
  *
- * @group Export
+ * This function is idempotent: {@link RuleGroupTypeIC} queries will be
+ * returned as-is.
+ *
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorCEL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.d.ts
+declare const convertToIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupTypeIC<RG>;
 /**
- * Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
+ * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit
+ * operation, use {@link convertToIC}.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const cypherCombinatorMap: {
-  and: "AND";
-  or: "OR";
-};
+declare function convertQuery(query: RuleGroupType): RuleGroupTypeIC;
 /**
- * Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
+ * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit
+ * operation, use {@link convertFromIC}.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorCypher: RuleGroupProcessor<string>;
+declare function convertQuery(query: RuleGroupTypeIC): RuleGroupType;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorDrizzle.d.ts
+//#region src/utils/deriveClassNames.d.ts
+/** Classname keys that have both a standard class and a `controlClassnames` entry. */
+type StandardClassnameKey = keyof typeof standardClassnames & keyof Classnames;
 /**
- * Minimal structural shape of Drizzle's `Operators` object. Declared locally so the public type
- * surface of this package never references `drizzle-orm`, which is an optional peer dependency.
- * (Referencing it would force consumers to install it to typecheck without `skipLibCheck`.)
+ * A classname applied only when `when` returns true for the current state.
  *
- * @group Export
+ * `key` is used to look up both the standard classname and the corresponding `controlClassnames`
+ * entry. Set `standardOnly` when the standard class is conditional but no custom class
+ * corresponds to it.
  */
-interface DrizzleOperatorsLike {
-  and: (...conditions: any[]) => any;
-  or: (...conditions: any[]) => any;
-  not: (...conditions: any[]) => any;
+interface ClassnameCondition<S> {
+  key: StandardClassnameKey;
+  when: (state: S) => boolean | undefined;
+  standardOnly?: boolean;
 }
 /**
- * Return type of {@link defaultRuleGroupProcessorDrizzle}—the function assignable to the `where`
- * property in the Drizzle relational queries API. The Drizzle `SQL` result type is inferred from
- * the caller's own operators object, so it stays exact without importing `drizzle-orm` here.
- *
- * @group Export
+ * How one derived classname is composed: the `controlClassnames` keys that contribute to it (in
+ * application order, after the standard classname), plus any state-dependent classes.
  */
-type DrizzleWhereCallback = <Ops extends DrizzleOperatorsLike>(columns: object, drizzleOperators: Ops) => ReturnType<Ops["and"]>;
+interface ClassnameSpec<S> {
+  sources: readonly (keyof Classnames)[];
+  conditions?: readonly ClassnameCondition<S>[];
+}
+/** Keys of the `classNames` object returned for a rule. */
+type RuleClassnameKey = "shiftActions" | "dragHandle" | "fields" | "matchMode" | "matchThreshold" | "operators" | "valueSource" | "value" | "cloneRule" | "lockRule" | "muteRule" | "removeRule" | "valueListItem";
+/** Keys of the `classNames` object returned for a rule group. */
+type RuleGroupClassnameKey = "header" | "shiftActions" | "undoRedoActions" | "undoAction" | "redoAction" | "dragHandle" | "combinators" | "notToggle" | "addRule" | "addGroup" | "cloneGroup" | "lockGroup" | "muteGroup" | "removeGroup" | "body";
+/** Drag-and-drop state that can contribute conditional classnames. */
+interface DndClassNameState {
+  isDragging?: boolean;
+  isOver?: boolean;
+  dropEffect?: "move" | "copy";
+  groupItems?: boolean;
+  dropNotAllowed?: boolean;
+}
+/** State that contributes conditional classnames to a rule's wrapper element. */
+interface RuleClassNameState extends DndClassNameState {
+  disabled?: boolean;
+  muted?: boolean;
+  hasSubQuery?: boolean;
+}
+/** State that contributes conditional classnames to the query builder's wrapper element. */
+interface QueryBuilderClassNameState {
+  disabled?: boolean;
+  validationResult?: boolean | ValidationMap;
+}
+/** Options common to every classname derivation. */
+interface DeriveClassNamesOptions {
+  /** The merged `controlClassnames` for the query builder. */
+  classNames: Partial<Classnames> | undefined;
+  /** When `true`, standard (`rule`, `ruleGroup-*`, etc.) classnames are omitted. */
+  suppressStandardClassnames?: boolean;
+}
 /**
- * Default rule group processor used by {@link formatQuery} for the "drizzle" format. The returned
- * function can be assigned to the `where` property in the Drizzle relational queries API.
- *
- * @example
- * const where = formatQuery(query, 'drizzle');
- * const results = db.query.users.findMany({ where });
- *
- * @returns Function that takes a Drizzle table config and an object of Drizzle operators.
+ * Classnames for each element rendered by a rule. This is the framework-agnostic core of the
+ * `classNames` object returned by the `useRule` hook.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorDrizzle: RuleGroupProcessor<DrizzleWhereCallback>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorElasticSearch.d.ts
+declare const deriveRuleClassNames: (options: DeriveClassNamesOptions) => Record<RuleClassnameKey, string>;
 /**
- * Rule group processor used by {@link formatQuery} for "elasticsearch" format.
+ * The classname for a single element of a rule, composed from the same table as
+ * {@link deriveRuleClassNames}. Useful where only one is needed, such as the items of a
+ * multi-value editor.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorElasticSearch: RuleGroupProcessor<Record<string, unknown>>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.d.ts
+declare const deriveRuleClassName: (key: RuleClassnameKey, options: DeriveClassNamesOptions) => string;
 /**
- * Rule group processor used by {@link formatQuery} for "gremlin" format.
- *
- * At the top level, filter rules produce chained `.has()` steps (implicit AND).
- * Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
- * `__` anonymous traversal prefixes.
+ * Classnames for each element rendered by a rule group, including its conditionally-classed
+ * `header`. This is the framework-agnostic core of the `classNames` object returned by the
+ * `useRuleGroup` hook.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorGremlin: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.d.ts
+declare const deriveRuleGroupClassNames: (options: DeriveClassNamesOptions & DndClassNameState) => Record<RuleGroupClassnameKey, string>;
+/** Inputs common to every outer (wrapper) classname derivation. */
+interface OuterClassNameOptionsBase extends DeriveClassNamesOptions {
+  /**
+   * Classnames contributed by the rule or group itself and its configuration, applied first.
+   * For a rule that is the rule/field/operator classnames; for a group, the group and combinator
+   * classnames.
+   */
+  leadingClassNames?: (Classname | null)[];
+  /** Appended last, as produced by `getValidationClassNames`. */
+  validationClassName?: Classname;
+}
+/** Inputs to {@link deriveRuleOuterClassName} and {@link deriveRuleGroupOuterClassName}. */
+interface OuterClassNameOptions extends OuterClassNameOptionsBase, RuleClassNameState {}
 /**
- * Rule group processor used by {@link formatQuery} for "jsonata" format.
+ * The outer (wrapper) classname for a rule, including every conditional state class.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorJSONata: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorJsonLogic.d.ts
+declare const deriveRuleOuterClassName: (options: OuterClassNameOptions) => string;
 /**
- * Rule group processor used by {@link formatQuery} for "jsonlogic" format.
+ * The outer (wrapper) classname for a rule group, including every conditional state class.
  *
- * @group Export
+ * A group reflects fewer drag-and-drop states than a rule—`dndOver`, `dndCopy`,
+ * `dndDropNotAllowed`, and `hasSubQuery` do not apply—so this is not interchangeable with
+ * {@link deriveRuleOuterClassName}.
+ *
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorJsonLogic: RuleGroupProcessor<RQBJsonLogic>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorLDAP.d.ts
+declare const deriveRuleGroupOuterClassName: (options: OuterClassNameOptions) => string;
 /**
- * Rule group processor used by {@link formatQuery} for "ldap" format.
+ * The outer (wrapper) classname for the query builder itself, including the conditional
+ * `disabled`, `valid`, and `invalid` state classes.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorLDAP: RuleGroupProcessor<string>;
+declare const deriveQueryBuilderClassNames: (options: OuterClassNameOptionsBase & QueryBuilderClassNameState) => string;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDB.d.ts
+//#region src/utils/defaultValidator.d.ts
 /**
- * Rule group processor used by {@link formatQuery} for "mongodb" format.
- *
- * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
- *
- * @group Export
+ * This is an example validation function you can pass to {@link react-querybuilder!QueryBuilder QueryBuilder} in the
+ * `validator` prop. It assumes that you want to validate groups, and has a no-op
+ * for validating rules which you can replace with your own implementation.
  */
-declare const defaultRuleGroupProcessorMongoDB: RuleGroupProcessor<string>;
+declare const defaultValidator: QueryValidator;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDBQuery.d.ts
+//#region src/utils/deriveRuleContext.d.ts
 /**
- * Default fallback object used by {@link formatQuery} for "mongodb_query" format.
- *
- * @group Export
+ * Functions used by {@link deriveRuleContext} to resolve a rule's configuration. Each corresponds
+ * to the `QueryBuilder` prop (or `useQueryBuilderSetup` output) of the same name.
  */
-declare const mongoDbFallback: {
-  readonly $and: readonly [{
-    readonly $expr: true;
-  }];
-};
+interface RuleContextResolvers<F extends FullField = FullField> {
+  fields: OptionList<F>;
+  fieldMap: Partial<FullOptionRecord<FullField>>;
+  getInputType: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => InputType | null;
+  getMatchModes: (field: string, misc: {
+    fieldData: F;
+  }) => MatchModeOptions;
+  getOperators: (field: string, misc: {
+    fieldData: F;
+  }) => OptionList<FullOperator>;
+  getParameters: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<Option>;
+  getValueEditorType: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => ValueEditorType;
+  getValues: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<Option>;
+  getValueSources: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => ValueSourceFullOptions;
+  getSubQueryBuilderProps?: (field: string, misc: {
+    fieldData: F;
+  }) => Record<string, unknown>;
+}
 /**
- * Rule group processor used by {@link formatQuery} for "mongodb_query" format.
- *
- * @group Export
+ * Everything {@link deriveRuleContext} resolves for a single rule.
  */
-declare const defaultRuleGroupProcessorMongoDBQuery: RuleGroupProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorNL.d.ts
+interface RuleContext<F extends FullField = FullField> {
+  fieldData: F;
+  hideValueControls: boolean;
+  inputType: InputType | null;
+  matchModes: MatchModeOptions;
+  operatorObject: FullOperator | undefined;
+  operators: OptionList<FullOperator>;
+  parameters: FlexibleOptionList<Option> | null;
+  validationResult: boolean | ValidationResult;
+  valueEditorType: ValueEditorType;
+  values: FlexibleOptionList<Option>;
+  valueSourceOptions: ValueSourceFullOptions;
+  valueSources: ValueSources;
+  subQueryBuilderProps: Record<string, unknown>;
+}
 /**
- * Rule group processor used by {@link formatQuery} for "natural_language" format.
- *
- * @group Export
+ * Resolves the field configuration for a rule's `field`, falling back to a minimal option object
+ * when the field isn't present in the field map.
  */
-declare const defaultRuleGroupProcessorNL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorParameterized.d.ts
+declare const getFieldData: (field: string, fieldMap: Partial<FullOptionRecord<FullField>>) => FullField;
 /**
- * Rule group processor used by {@link formatQuery} for "parameterized" and
- * "parameterized_named" formats.
- *
- * @group Export
+ * The input type for a rule. A field's own `inputType` takes precedence over `getInputType`.
  */
-declare const defaultRuleGroupProcessorParameterized: RuleGroupProcessor<ParameterizedSQL | ParameterizedNamedSQL>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorPrisma.d.ts
+declare const getRuleInputType: <F extends FullField = FullField>(field: string, operator: string, fieldData: F, getInputType: RuleContextResolvers<F>["getInputType"]) => InputType | null;
 /**
- * Default fallback object used by {@link formatQuery} for "prisma" format.
- *
- * @group Export
+ * Whether the value editor(s) should be hidden for an operator, based on its `arity`.
  */
-declare const prismaFallback: {};
+declare const hideValueControlsForOperator: (operatorObject?: FullOperator) => boolean;
 /**
- * Rule group processor used by {@link formatQuery} for "prisma" format.
- *
- * @group Export
+ * The subset of a rule that determines its configuration. Accepting only these properties (rather
+ * than the whole rule) lets React callers keep granular memoization dependencies, so editing a
+ * rule's `value` doesn't recompute its operators, value sources, or option lists.
  */
-declare const defaultRuleGroupProcessorPrisma: RuleGroupProcessor<Record<string, unknown> | undefined>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSequelize.d.ts
+type RuleFacet = Pick<RuleType, "field" | "operator" | "valueSource">;
 /**
- * Structural stand-in for Sequelize's `WhereOptions`. Declared locally so the public type surface
- * of this package never references `sequelize`, which is an optional peer dependency.
- * (Referencing it would force consumers to install it to typecheck without `skipLibCheck`.)
- * Assignable to `WhereOptions` at the call site, e.g. `Model.findAll({ where })`.
- *
- * @group Export
+ * Value source options for a rule. A `valueSource` present on the rule but absent from the
+ * configured list is appended, so the current selection is always representable.
  */
-interface SequelizeWhereOptionsLike {
-  [key: string | symbol]: unknown;
-}
+declare const getRuleValueSourceOptions: <F extends FullField = FullField>(rule: RuleFacet, fieldData: F, getValueSources: RuleContextResolvers<F>["getValueSources"]) => ValueSourceFullOptions;
 /**
- * Rule group processor used by {@link formatQuery} for "sequelize" format.
- *
- * @group Export
+ * Normalizes the result of `getParameters` to a non-empty list or `null`.
  */
-declare const defaultRuleGroupProcessorSequelize: RuleGroupProcessor<SequelizeWhereOptionsLike | undefined>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.d.ts
+declare const getParametersAsList: (parameters: FlexibleOptionList<Option>) => FlexibleOptionList<Option> | null;
 /**
- * Rule group processor used by {@link formatQuery} for "sparql" format.
+ * The value editor type for a rule. `valueSource: "field"` always uses a select list, and
+ * `valueSource: "parameter"` uses a (multi)select when parameters are available.
+ */
+declare const getRuleValueEditorType: <F extends FullField = FullField>(rule: RuleFacet, fieldData: F, parametersAsList: FlexibleOptionList<Option> | null, getValueEditorType: RuleContextResolvers<F>["getValueEditorType"]) => ValueEditorType;
+/**
+ * The option list presented by a rule's value editor, resolved from its `valueSource`.
+ */
+declare const getRuleValues: <F extends FullField = FullField>(rule: RuleFacet, fieldData: F, fields: OptionList<F>, parametersAsList: FlexibleOptionList<Option> | null, getValues: RuleContextResolvers<F>["getValues"]) => FlexibleOptionList<Option>;
+/**
+ * The validation result for a rule: the entry from a query-level {@link ValidationMap} if present,
+ * otherwise the field's own `validator` result, otherwise `null`.
+ */
+declare const getRuleValidationResult: (rule: RuleType, fieldData: FullField, validationMap?: ValidationMap, id?: string) => boolean | ValidationResult;
+/**
+ * Resolves everything about a single rule that depends on the field/operator configuration:
+ * its field data, operators, value editor type, value list, value sources, match modes, and
+ * validation result.
  *
- * SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
+ * This is the framework-agnostic core of the `useRule` hook, shared with
+ * {@link QueryManager.getRuleContext} so that non-React implementations derive identical results.
+ * It performs no memoization; callers are responsible for caching as appropriate.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorSPARQL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSpEL.d.ts
+declare const deriveRuleContext: <F extends FullField = FullField>(rule: RuleType, resolvers: RuleContextResolvers<F>, options?: {
+  validationMap?: ValidationMap;
+  id?: string;
+}) => RuleContext<F>;
 /**
- * Default rule processor used by {@link formatQuery} for "spel" format.
+ * Everything {@link deriveRuleGroupContext} resolves for a single rule group.
+ */
+interface RuleGroupContext<C extends FullCombinator = FullCombinator> {
+  combinator: string;
+  combinatorObject: C | undefined;
+  combinators: FullOptionList<C>;
+  /** The `className` of the selected combinator, or `null` for independent combinators. */
+  combinatorBasedClassName: Classname | null;
+  independentCombinators: boolean;
+  validationResult: boolean | ValidationResult;
+}
+/**
+ * The effective combinator for a group: its own `combinator` when it has one, otherwise the
+ * first configured combinator (which is the case for groups with independent combinators).
  *
- * @group Export
+ * This intentionally covers only the current property-based API. The `RuleGroup` component
+ * additionally falls back to its deprecated `combinator` prop; that fallback stays in the hook.
  */
-declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.d.ts
+declare const getRuleGroupCombinator: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>) => string;
 /**
- * Default rule processor used by {@link formatQuery} for "sql" format.
+ * Resolves everything about a rule group that depends on the combinator configuration, plus its
+ * validation result.
  *
- * @group Export
+ * Note that unlike {@link deriveRuleContext}, there is no field-level validator fallback—a
+ * group's validation result comes only from the query-level {@link ValidationMap}.
+ *
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
+declare const deriveRuleGroupContext: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>, options?: {
+  validationMap?: ValidationMap;
+  id?: string;
+}) => RuleGroupContext<C>;
 //#endregion
-//#region src/utils/formatQuery/tanStackDbTypes.d.ts
+//#region src/utils/deriveValueEditor.d.ts
 /**
- * Return type of the TanStack DB where-callback. Intentionally `unknown`: TanStack DB's own
- * `WhereCallback` returns `any`, so a precise type constrains nothing at the call site, and
- * naming `@tanstack/db` here would drag an optional peer dependency into the published types.
+ * Whether an operator's value is a list of two bounds.
+ *
+ * @group Value Editors
  */
-type TanStackDbWhereCallbackReturnType = unknown;
-type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
+declare const isBetweenOperator: (operator: string) => boolean;
 /**
- * Default rule group processor used by {@link formatQuery} for the "tanstack_db" format.
- * Returns a `WhereCallback` suitable for TanStack DB's `.where()` method.
+ * Determines whether a rule's `value` needs to be collapsed to a single element because it no
+ * longer represents a list, and what it should become.
  *
- * @example
- * const where = formatQuery(query, { format: 'tanstack_db', context: { tanstackDb: tsdb } });
- * const results = useLiveQuery(q => q.from({ todo: todosCollection }).where(where));
+ * This happens when the value is an array (or a comma-containing string in a `number` input,
+ * which `<input type="number">` can't display) while the operator is not one of the multi-value
+ * operators and the editor is not a multiselect—typically right after the operator changes from
+ * `"in"` or `"between"` to something else.
  *
- * @group Export
+ * The React `useValueEditor` hook applies the result in an effect; other implementations may
+ * apply it wherever is idiomatic.
+ *
+ * @group Value Editors
  */
-declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
+declare const getValueEditorReset: ({ skipHook, type, operator, value, inputType }: {
+  skipHook?: boolean;
+  type?: string;
+  operator: string;
+  value: unknown;
+  inputType?: InputType | null;
+}) => {
+  reset: boolean;
+  value: unknown;
+};
 /**
- * Rule group processor used by {@link formatQuery} for "diagnostics" format.
+ * Produces the next value for a series of value editors when the editor at `index` changes.
  *
- * Produces a {@link DiagnosticsResult} containing an annotated copy of the query
- * tree (`query`) with `valid`, `reasons`, `path`, and `level` properties on every
- * rule and group; a flat `diagnostics` array; aggregate `stats`; and a per-field
- * `fieldSummary`.
+ * For `between`/`notBetween`, editing the first bound guarantees an array of at least two
+ * elements, seeding the second from the first available option. The result is a comma-joined
+ * string unless `listsAsArrays` is `true`.
  *
- * @group Export
+ * @group Value Editors
  */
-declare const defaultRuleGroupProcessorDiagnostics: RuleGroupProcessor<DiagnosticsResult>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorCypher.d.ts
+declare const getMultiValueUpdate: ({ value, index, valueAsArray, operator, values, listsAsArrays, parseNumberMethod }: {
+  value: unknown;
+  index: number;
+  valueAsArray: unknown[];
+  operator: string;
+  values?: any[];
+  listsAsArrays?: boolean;
+  parseNumberMethod?: ParseNumberMethod;
+}) => unknown;
 /**
- * Default rule processor used by {@link formatQuery} for "cypher" and "gql" formats.
+ * Coerces a value to a `bigint`, falling back to the parsed number when it can't be represented
+ * as one (an empty string or a decimal, for example).
  *
- * @group Export
+ * @group Value Editors
  */
-declare const defaultRuleProcessorCypher: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorDrizzle.d.ts
+declare const coerceBigIntValue: (value: unknown, parseNumberMethod?: ParseNumberMethod) => unknown;
 /**
- * Default rule processor used by {@link formatQuery} for the "drizzle" format.
+ * The `type` attribute an `<input>` should use for a rule. `bigint` values and the `in`/`notIn`
+ * operators (whose value is a comma-separated list) both require a text input.
  *
- * @group Export
+ * @group Value Editors
  */
-declare const defaultRuleProcessorDrizzle: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.d.ts
+declare const coerceInputType: (inputType: InputType | null | undefined, operator: string) => InputType;
 /**
- * Default rule processor used by {@link formatQuery} for "elasticsearch" format.
+ * Produces the next value for a value selector. Multiselect values are normalized to an array
+ * first, then comma-joined unless `listsAsArrays` is `true`. Single-select values pass through.
  *
- * @group Export
+ * @group Value Editors
  */
-declare const defaultRuleProcessorElasticSearch: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorGremlin.d.ts
+declare const getValueSelectorUpdate: (value: string | string[], { multiple, listsAsArrays }?: {
+  multiple?: boolean;
+  listsAsArrays?: boolean;
+}) => string | string[];
 /**
- * Default rule processor used by {@link formatQuery} for "gremlin" format.
+ * Normalizes a value selector's current value for display. Multiselect values become an array of
+ * strings so they match option names, which are always strings (e.g. `[42]` becomes `["42"]`).
  *
- * Each rule becomes a `.has()` step (or `.hasNot()`/`.has()` for null checks).
+ * @group Value Editors
+ */
+declare const normalizeValueSelectorValue: (value: unknown, multiple?: boolean) => any;
+//#endregion
+//#region src/utils/filterFieldsByComparator.d.ts
+/**
+ * For a given {@link FullField}, returns the `fields` list filtered for
+ * other fields that match by `comparator`. Only fields *other than the
+ * one in question* will ever be included, even if `comparator` is `null`
+ * or `undefined`. If `comparator` is a string, fields with the same value
+ * for that property will be included. If `comparator` is a function, each
+ * field will be passed to the function along with the `operator` and fields
+ * for which the function returns `true` will be included.
  *
- * @group Export
+ * @group Option Lists
  */
-declare const defaultRuleProcessorGremlin: RuleProcessor;
+declare const filterFieldsByComparator: (field: FullField, fields: OptionList<FullField>, operator: string) => FullField[] | {
+  options: WithUnknownIndex<FullField>[];
+  label: string;
+}[];
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorJSONata.d.ts
+//#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "jsonata" format.
+ * Default rule processor used by {@link formatQuery} for "cel" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorJSONata: RuleProcessor;
+declare const defaultRuleProcessorCEL: RuleProcessor;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorJsonLogic.d.ts
+//#region src/utils/formatQuery/defaultRuleProcessorMongoDB.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "jsonlogic" format.
+ * Default rule processor used by {@link formatQuery} for "mongodb" format.
+ *
+ * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorJsonLogic: RuleProcessor;
+declare const defaultRuleProcessorMongoDB: RuleProcessor;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorLDAP.d.ts
+//#region src/utils/formatQuery/defaultRuleProcessorSpEL.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "ldap" format.
+ * Default rule processor used by {@link formatQuery} for "spel" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorLDAP: RuleProcessor;
+declare const defaultRuleProcessorSpEL: RuleProcessor;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorMongoDBQuery.d.ts
+//#region src/utils/formatQuery/defaultValueProcessorByRule.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "mongodb_query" format.
+ * Default value processor used by {@link formatQuery} for "sql" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorMongoDBQuery: RuleProcessor;
+declare const defaultValueProcessorByRule: ValueProcessorByRule;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorNL.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.d.ts
 /**
- * Default operator map used by {@link formatQuery} for "natural_language" format.
+ * Rule group processor used by {@link formatQuery} for "cel" format.
  *
  * @group Export
  */
-declare const defaultExportOperatorMap: ExportOperatorMap;
+declare const defaultRuleGroupProcessorCEL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.d.ts
 /**
- * Default operator processor used by {@link formatQuery} for "natural_language" format.
+ * Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
  *
  * @group Export
  */
-declare const defaultOperatorProcessorNL: RuleProcessor;
+declare const cypherCombinatorMap: {
+  and: "AND";
+  or: "OR";
+};
 /**
- * Default rule processor used by {@link formatQuery} for "natural_language" format.
+ * Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
  *
  * @group Export
  */
-declare const defaultRuleProcessorNL: RuleProcessor;
+declare const defaultRuleGroupProcessorCypher: RuleGroupProcessor<string>;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorParameterized.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorDrizzle.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "parameterized" and
- * "parameterized_named" formats.
+ * Minimal structural shape of Drizzle's `Operators` object. Declared locally so the public type
+ * surface of this package never references `drizzle-orm`, which is an optional peer dependency.
+ * (Referencing it would force consumers to install it to typecheck without `skipLibCheck`.)
  *
  * @group Export
  */
-declare const defaultRuleProcessorParameterized: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorPrisma.d.ts
+interface DrizzleOperatorsLike {
+  and: (...conditions: any[]) => any;
+  or: (...conditions: any[]) => any;
+  not: (...conditions: any[]) => any;
+}
 /**
- * Default rule processor used by {@link formatQuery} for "prisma" format.
+ * Return type of {@link defaultRuleGroupProcessorDrizzle}—the function assignable to the `where`
+ * property in the Drizzle relational queries API. The Drizzle `SQL` result type is inferred from
+ * the caller's own operators object, so it stays exact without importing `drizzle-orm` here.
  *
  * @group Export
  */
-declare const defaultRuleProcessorPrisma: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSequelize.d.ts
+type DrizzleWhereCallback = <Ops extends DrizzleOperatorsLike>(columns: object, drizzleOperators: Ops) => ReturnType<Ops["and"]>;
 /**
- * Default rule processor used by {@link formatQuery} for the "sequelize" format.
+ * Default rule group processor used by {@link formatQuery} for the "drizzle" format. The returned
+ * function can be assigned to the `where` property in the Drizzle relational queries API.
  *
- * @group Export
- */
-declare const defaultRuleProcessorSequelize: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSPARQL.d.ts
-/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
+ * @example
+ * const where = formatQuery(query, 'drizzle');
+ * const results = db.query.users.findMany({ where });
+ *
+ * @returns Function that takes a Drizzle table config and an object of Drizzle operators.
  *
  * @group Export
  */
-declare const sparqlVar: (name: string) => string;
+declare const defaultRuleGroupProcessorDrizzle: RuleGroupProcessor<DrizzleWhereCallback>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorElasticSearch.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "sparql" format.
+ * Rule group processor used by {@link formatQuery} for "elasticsearch" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorSPARQL: RuleProcessor;
+declare const defaultRuleGroupProcessorElasticSearch: RuleGroupProcessor<Record<string, unknown>>;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSQL.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.d.ts
 /**
- * Default operator processor used by {@link formatQuery} for "sql" and "parameterized*" formats.
+ * Rule group processor used by {@link formatQuery} for "gremlin" format.
+ *
+ * At the top level, filter rules produce chained `.has()` steps (implicit AND).
+ * Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
+ * `__` anonymous traversal prefixes.
  *
  * @group Export
  */
-declare const defaultOperatorProcessorSQL: RuleProcessor;
+declare const defaultRuleGroupProcessorGremlin: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "sql" format.
+ * Rule group processor used by {@link formatQuery} for "jsonata" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorSQL: RuleProcessor;
+declare const defaultRuleGroupProcessorJSONata: RuleGroupProcessor<string>;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorJsonLogic.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
+ * Rule group processor used by {@link formatQuery} for "jsonlogic" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorTanStackDB: RuleProcessor;
+declare const defaultRuleGroupProcessorJsonLogic: RuleGroupProcessor<RQBJsonLogic>;
 //#endregion
-//#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorLDAP.d.ts
 /**
- * Default value processor used by {@link formatQuery} for "natural_language" format.
+ * Rule group processor used by {@link formatQuery} for "ldap" format.
  *
  * @group Export
  */
-declare const defaultValueProcessorNL: ValueProcessorByRule;
+declare const defaultRuleGroupProcessorLDAP: RuleGroupProcessor<string>;
 //#endregion
-//#region src/utils/formatQuery/formatQuery.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDB.d.ts
 /**
- * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
+ * Rule group processor used by {@link formatQuery} for "mongodb" format.
+ *
+ * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
  *
  * @group Export
  */
-declare const sqlDialectPresets: Record<SQLPreset, FormatQueryOptions>;
+declare const defaultRuleGroupProcessorMongoDB: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDBQuery.d.ts
 /**
- * A collection of option presets for {@link formatQuery}.
+ * Default fallback object used by {@link formatQuery} for "mongodb_query" format.
  *
  * @group Export
  */
-declare const formatQueryOptionPresets: Record<string, FormatQueryOptions>;
+declare const mongoDbFallback: {
+  readonly $and: readonly [{
+    readonly $expr: true;
+  }];
+};
 /**
- * Generates a formatted (indented two spaces) JSON string from a query object.
+ * Rule group processor used by {@link formatQuery} for "mongodb_query" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny): string;
+declare const defaultRuleGroupProcessorMongoDBQuery: RuleGroupProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorNL.d.ts
 /**
- * Generates a result based on the provided rule group processor.
+ * Rule group processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare function formatQuery<TResult = unknown>(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
-  ruleGroupProcessor: RuleGroupProcessor<TResult>;
-}): TResult;
+declare const defaultRuleGroupProcessorNL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorParameterized.d.ts
 /**
- * Generates a {@link index!ParameterizedSQL ParameterizedSQL} object from a query object.
+ * Rule group processor used by {@link formatQuery} for "parameterized" and
+ * "parameterized_named" formats.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized" | (FormatQueryOptions & {
-  format: "parameterized";
-})): ParameterizedSQL;
+declare const defaultRuleGroupProcessorParameterized: RuleGroupProcessor<ParameterizedSQL | ParameterizedNamedSQL>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorPrisma.d.ts
 /**
- * Generates a {@link index!ParameterizedNamedSQL ParameterizedNamedSQL} object from a query object.
+ * Default fallback object used by {@link formatQuery} for "prisma" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized_named" | (FormatQueryOptions & {
-  format: "parameterized_named";
-})): ParameterizedNamedSQL;
+declare const prismaFallback: {};
 /**
- * Generates a {@link index!RQBJsonLogic JsonLogic} object from a query object.
+ * Rule group processor used by {@link formatQuery} for "prisma" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonlogic" | (FormatQueryOptions & {
-  format: "jsonlogic";
-})): RQBJsonLogic;
+declare const defaultRuleGroupProcessorPrisma: RuleGroupProcessor<Record<string, unknown> | undefined>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSequelize.d.ts
 /**
- * Generates an ElasticSearch query object from an RQB query object.
- *
- * NOTE: Support for the ElasticSearch format is experimental.
- * You may have better results exporting "sql" format then using
- * [ElasticSearch SQL](https://www.elastic.co/guide/en/elasticsearch/reference/current/xpack-sql.html).
+ * Structural stand-in for Sequelize's `WhereOptions`. Declared locally so the public type surface
+ * of this package never references `sequelize`, which is an optional peer dependency.
+ * (Referencing it would force consumers to install it to typecheck without `skipLibCheck`.)
+ * Assignable to `WhereOptions` at the call site, e.g. `Model.findAll({ where })`.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "elasticsearch" | (FormatQueryOptions & {
-  format: "elasticsearch";
-})): Record<string, any>;
+interface SequelizeWhereOptionsLike {
+  [key: string | symbol]: unknown;
+}
 /**
- * Generates a MongoDB query object from an RQB query object.
- *
- * This is equivalent to the "mongodb" format, but returns a JSON object
- * instead of a string.
+ * Rule group processor used by {@link formatQuery} for "sequelize" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb_query" | (FormatQueryOptions & {
-  format: "mongodb_query";
-})): Record<string, any>;
+declare const defaultRuleGroupProcessorSequelize: RuleGroupProcessor<SequelizeWhereOptionsLike | undefined>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.d.ts
 /**
- * Generates a JSON.stringify'd MongoDB query object from an RQB query object.
- *
- * This is equivalent to the "mongodb_query" format, but returns a string
- * instead of a JSON object.
+ * Rule group processor used by {@link formatQuery} for "sparql" format.
  *
- * @deprecated Use the "mongodb_query" format for greater flexibility.
+ * SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb" | (FormatQueryOptions & {
-  format: "mongodb";
-})): string;
+declare const defaultRuleGroupProcessorSPARQL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSpEL.d.ts
 /**
- * Generates a Prisma ORM query object from an RQB query object.
+ * Default rule processor used by {@link formatQuery} for "spel" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "prisma" | (FormatQueryOptions & {
-  format: "prisma";
-})): Record<string, any>;
+declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.d.ts
 /**
- * Generates a Drizzle ORM query function from an RQB query object. The function can
- * be assigned to the `where` property in the Drizzle relational queries API.
+ * Default rule processor used by {@link formatQuery} for "sql" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (FormatQueryOptions & {
-  format: "drizzle";
-})): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
+declare const defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/tanStackDbTypes.d.ts
 /**
- * Generates a TanStack DB WhereCallback from an RQB query object. The callback can
- * be passed directly to TanStack DB's `.where()` method.
- *
- * @group Export
+ * Return type of the TanStack DB where-callback. Intentionally `unknown`: TanStack DB's own
+ * `WhereCallback` returns `any`, so a precise type constrains nothing at the call site, and
+ * naming `@tanstack/db` here would drag an optional peer dependency into the published types.
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
-  format: "tanstack_db";
-})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
+type TanStackDbWhereCallbackReturnType = unknown;
+type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
 /**
- * be assigned to the `where` property in the Sequelize query functions.
+ * Default rule group processor used by {@link formatQuery} for the "tanstack_db" format.
+ * Returns a `WhereCallback` suitable for TanStack DB's `.where()` method.
+ *
+ * @example
+ * const where = formatQuery(query, { format: 'tanstack_db', context: { tanstackDb: tsdb } });
+ * const results = useLiveQuery(q => q.from({ todo: todosCollection }).where(where));
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "sequelize" | (FormatQueryOptions & {
-  format: "sequelize";
-})): ReturnType<typeof defaultRuleGroupProcessorSequelize>;
+declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
 /**
- * Generates a JSONata query string from an RQB query object.
+ * Rule group processor used by {@link formatQuery} for "diagnostics" format.
  *
- * NOTE: Either `parseNumbers: "strict-limited"` or `parseNumbers: true`
- * are recommended for this format.
+ * Produces a {@link DiagnosticsResult} containing an annotated copy of the query
+ * tree (`query`) with `valid`, `reasons`, `path`, and `level` properties on every
+ * rule and group; a flat `diagnostics` array; aggregate `stats`; and a per-field
+ * `fieldSummary`.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonata" | (FormatQueryOptions & {
-  format: "jsonata";
-})): string;
+declare const defaultRuleGroupProcessorDiagnostics: RuleGroupProcessor<DiagnosticsResult>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorCypher.d.ts
 /**
- * Generates an LDAP query string from an RQB query object.
+ * Default rule processor used by {@link formatQuery} for "cypher" and "gql" formats.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "ldap" | (FormatQueryOptions & {
-  format: "ldap";
-})): string;
+declare const defaultRuleProcessorCypher: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorDrizzle.d.ts
 /**
- * Generates a {@link DiagnosticsResult} from a query object, containing an annotated
- * query tree, a flat diagnostics array, aggregate stats, and a per-field summary.
+ * Default rule processor used by {@link formatQuery} for the "drizzle" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "diagnostics" | (FormatQueryOptions & {
-  format: "diagnostics";
-})): DiagnosticsResult;
+declare const defaultRuleProcessorDrizzle: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.d.ts
 /**
- * Generates a formatted (indented two spaces) JSON string from a query object.
+ * Default rule processor used by {@link formatQuery} for "elasticsearch" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions): string;
+declare const defaultRuleProcessorElasticSearch: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorGremlin.d.ts
 /**
- * Generates a query string in the requested format.
+ * Default rule processor used by {@link formatQuery} for "gremlin" format.
+ *
+ * Each rule becomes a `.has()` step (or `.hasNot()`/`.has()` for null checks).
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: Exclude<ExportFormat, ExportObjectFormats>): string;
+declare const defaultRuleProcessorGremlin: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorJSONata.d.ts
 /**
- * Generates a query string in the requested format.
+ * Default rule processor used by {@link formatQuery} for "jsonata" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
-  format: Exclude<ExportFormat, ExportObjectFormats>;
-}): string;
+declare const defaultRuleProcessorJSONata: RuleProcessor;
 //#endregion
-//#region src/utils/formatQuery/utils.d.ts
+//#region src/utils/formatQuery/defaultRuleProcessorJsonLogic.d.ts
 /**
- * Maps a {@link DefaultOperatorName} to a SQL operator.
+ * Default rule processor used by {@link formatQuery} for "jsonlogic" format.
  *
  * @group Export
  */
-declare const mapSQLOperator: (rqbOperator: string) => string;
+declare const defaultRuleProcessorJsonLogic: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorLDAP.d.ts
 /**
- * Returns a preset-aware SQL string-concatenation function. Emits `CONCAT(a, b, ...)` when
- * `concatOperator` is `"CONCAT"` (case-insensitive), otherwise joins with the infix operator
- * (e.g. `a || b`, `a + b`).
+ * Default rule processor used by {@link formatQuery} for "ldap" format.
  *
  * @group Export
  */
-declare const getSQLConcat: (concatOperator?: string) => (...values: string[]) => string;
-/**
- * Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
- * → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
- * yield `['', '']`.
+declare const defaultRuleProcessorLDAP: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorMongoDBQuery.d.ts
+/**
+ * Default rule processor used by {@link formatQuery} for "mongodb_query" format.
  *
  * @group Export
  */
-declare const getLikeWildcards: (operatorLC: string) => [string, string];
+declare const defaultRuleProcessorMongoDBQuery: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorNL.d.ts
 /**
- * Wraps an already-serialized SQL fragment (a quoted field name or an expression) with the
- * `LIKE` wildcards for the given (lowercase) string-match operator, concatenating the literal
- * `%` markers via the preset-aware {@link getSQLConcat}. Returns the fragment untouched for
- * operators without wildcards.
+ * Default operator map used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const wrapLikeFragment: (fragment: string, operatorLC: string, { concatOperator, quoteValuesWith, wrapValueWith }?: {
-  concatOperator?: string;
-  quoteValuesWith?: string;
-  wrapValueWith?: [string, string];
-}) => string;
+declare const defaultExportOperatorMap: ExportOperatorMap;
 /**
- * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
+ * Default operator processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const mongoOperators: {
-  "=": string;
-  "!=": string;
-  "<": string;
-  "<=": string;
-  ">": string;
-  ">=": string;
-  in: string;
-  notin: string;
-  notIn: string;
-};
+declare const defaultOperatorProcessorNL: RuleProcessor;
 /**
- * Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
+ * Default rule processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const prismaOperators: {
-  "=": string;
-  "!=": string;
-  "<": string;
-  "<=": string;
-  ">": string;
-  ">=": string;
-  in: string;
-  notin: string;
-};
+declare const defaultRuleProcessorNL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorParameterized.d.ts
 /**
- * Maps a {@link DefaultCombinatorName} to a CEL combinator.
+ * Default rule processor used by {@link formatQuery} for "parameterized" and
+ * "parameterized_named" formats.
  *
  * @group Export
  */
-declare const celCombinatorMap: {
-  and: "&&";
-  or: "||";
-};
+declare const defaultRuleProcessorParameterized: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorPrisma.d.ts
 /**
- * Register these operators with `jsonLogic` before applying the result
- * of `formatQuery(query, 'jsonlogic')`.
- *
- * @example
- * ```
- * for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {
- *   jsonLogic.add_operation(op, func);
- * }
- * jsonLogic.apply({ "startsWith": [{ "var": "firstName" }, "Stev"] }, data);
- * ```
+ * Default rule processor used by {@link formatQuery} for "prisma" format.
  *
  * @group Export
  */
-declare const jsonLogicAdditionalOperators: Record<"startsWith" | "endsWith", (a: string, b: string) => boolean>;
+declare const defaultRuleProcessorPrisma: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSequelize.d.ts
 /**
- * Returns a new query object with all `string`-type `value` properties converted
- * to `number` where appropriate.
- *
- * Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
+ * Default rule processor used by {@link formatQuery} for the "sequelize" format.
  *
  * @group Export
  */
-declare const numerifyValues: (rg: RuleGroupTypeAny, options: SetRequired<FormatQueryOptions, "fields">) => RuleGroupTypeAny;
-/**
- * Determines whether a value is _anything_ except an empty `string` or `NaN`.
+declare const defaultRuleProcessorSequelize: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSPARQL.d.ts
+/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
  *
  * @group Export
  */
-declare const isValidValue: (value: unknown) => boolean;
+declare const sparqlVar: (name: string) => string;
 /**
- * Determines whether {@link formatQuery} should render the given value as a number.
- * As long as `parseNumbers` is `true`, `number` and `bigint` values will return `true` and
- * `string` values will return `true` if they test positive against {@link numericRegex}.
+ * Default rule processor used by {@link formatQuery} for "sparql" format.
  *
  * @group Export
  */
-declare const shouldRenderAsNumber: (value: unknown, parseNumbers?: boolean) => boolean;
+declare const defaultRuleProcessorSPARQL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSQL.d.ts
 /**
- * Used by {@link formatQuery} to determine whether the given value processor is a
- * "legacy" value processor by counting the number of arguments. Legacy value
- * processors take 3 arguments (not counting any arguments with default values), while
- * rule-based value processors take no more than 2 arguments.
+ * Default operator processor used by {@link formatQuery} for "sql" and "parameterized*" formats.
  *
  * @group Export
  */
-declare const isValueProcessorLegacy: (valueProcessor: ValueProcessorLegacy | ValueProcessorByRule) => valueProcessor is ValueProcessorLegacy;
+declare const defaultOperatorProcessorSQL: RuleProcessor;
 /**
- * Converts the `quoteFieldNamesWith` option into an array of two strings.
- * If the option is a string, the array elements are both that string.
- *
- * @default
- * ['', '']
+ * Default rule processor used by {@link formatQuery} for "sql" format.
  *
  * @group Export
  */
-declare const getQuoteFieldNamesWithArray: (quoteFieldNamesWith?: null | string | [string, string]) => [string, string];
+declare const defaultRuleProcessorSQL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
 /**
- * Given a field name and relevant {@link ValueProcessorOptions}, returns the field name
- * wrapped in the configured quote character(s).
+ * Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
  *
  * @group Export
  */
-declare const getQuotedFieldName: (fieldName: string, { quoteFieldNamesWith, fieldIdentifierSeparator }: ValueProcessorOptions) => string;
+declare const defaultRuleProcessorTanStackDB: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
 /**
- * Given a [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
- * like "svo" or "sov", returns a permutation of `["S", "V", "O"]` based on the first occurrence of
- * each letter in the input string (case insensitive). This widens the valid input from abbreviations
- * like "svo" to more expressive strings like "subject-verb-object" or "sub ver obj". Any missing
- * letters are appended in the default order "SVO" (e.g., "object" would yield `["O", "S", "V"]`).
+ * Default value processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const normalizeConstituentWordOrder: (input: string) => ConstituentWordOrder;
+declare const defaultValueProcessorNL: ValueProcessorByRule;
+//#endregion
+//#region src/utils/formatQuery/formatQuery.d.ts
 /**
- * Prefixes a named-parameter value with the given `paramPrefix` unless the value already
- * begins with it. Used by {@link formatQuery} to render rules whose `valueSource` is
- * `"parameter"` (e.g. `"p1"` with prefix `":"` → `":p1"`; `":p1"` → `":p1"`).
+ * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
  *
  * @group Export
  */
-declare const withParamPrefix: (value: unknown, paramPrefix?: string) => string;
+declare const sqlDialectPresets: Record<SQLPreset, FormatQueryOptions>;
 /**
- * Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
- * {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
+ * A collection of option presets for {@link formatQuery}.
  *
  * @group Export
  */
-declare const stripParamPrefix: (value: unknown, paramPrefix?: string) => string;
+declare const formatQueryOptionPresets: Record<string, FormatQueryOptions>;
 /**
- * Default translations used by {@link formatQuery} for "natural_language" format.
+ * Generates a formatted (indented two spaces) JSON string from a query object.
  *
  * @group Export
  */
-declare const defaultNLTranslations: NLTranslations;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny): string;
 /**
- * Used by {@link formatQuery} to get a translation based on certain conditions
- * for the "natural_language" format.
+ * Generates a result based on the provided rule group processor.
  *
  * @group Export
  */
-declare const getNLTranslataion: (key: NLTranslationKey, translations: NLTranslations, conditions?: GroupVariantCondition[]) => string;
-type ProcessedMatchMode = {
-  mode: "all";
-  threshold?: number | null | undefined;
-} | {
-  mode: "none";
-  threshold?: number | null | undefined;
-} | {
-  mode: "some";
-  threshold?: number | null | undefined;
-} | {
-  mode: "atleast";
-  threshold: number;
-} | {
-  mode: "atmost";
-  threshold: number;
-} | {
-  mode: "exactly";
-  threshold: number;
-};
+declare function formatQuery<TResult = unknown>(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
+  ruleGroupProcessor: RuleGroupProcessor<TResult>;
+}): TResult;
 /**
- * Transforms
- * - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
- * - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
+ * Generates a {@link index!ParameterizedSQL ParameterizedSQL} object from a query object.
  *
- * Returns:
- * - Processed `{ mode, threshold }` object for valid subqueries
- * - `null` if match mode is not applicable for the rule
- * - `false` if match mode is valid, but either
- *   1. `threshold` is required and invalid, or
- *   2. `value` is not a valid rule group.
+ * @group Export
  */
-declare const processMatchMode: (rule: RuleType) => null | false | ProcessedMatchMode;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized" | (FormatQueryOptions & {
+  format: "parameterized";
+})): ParameterizedSQL;
 /**
- * Base alias assigned to the element binding of a subquery generated for a rule's
- * {@link MatchMode `match` mode} (e.g. `unnest(field) as elem_alias`).
+ * Generates a {@link index!ParameterizedNamedSQL ParameterizedNamedSQL} object from a query object.
+ *
+ * @group Export
  */
-declare const subqueryElementAliasBase = "elem_alias";
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized_named" | (FormatQueryOptions & {
+  format: "parameterized_named";
+})): ParameterizedNamedSQL;
 /**
- * Returns the element alias for a subquery at the given nesting depth. Depth 0 (the common,
- * non-nested case) uses {@link subqueryElementAliasBase} unchanged; deeper levels are suffixed
- * with the depth, so a subquery nested within a subquery cannot shadow its parent's binding.
- *
- * Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
+ * Generates a {@link index!RQBJsonLogic JsonLogic} object from a query object.
  *
  * @group Export
  */
-declare const getSubqueryElementAlias: (subqueryDepth?: number) => string;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonlogic" | (FormatQueryOptions & {
+  format: "jsonlogic";
+})): RQBJsonLogic;
 /**
- * "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
- * objects with a `$bigint` property having a value of a string representation of
- * the actual `bigint`-type value.
+ * Generates an ElasticSearch query object from an RQB query object.
  *
- * Inverse of {@link bigIntJsonParseReviver}.
+ * NOTE: Support for the ElasticSearch format is experimental.
+ * You may have better results exporting "sql" format then using
+ * [ElasticSearch SQL](https://www.elastic.co/guide/en/elasticsearch/reference/current/xpack-sql.html).
  *
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+ * @group Export
  */
-declare const bigIntJsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "elasticsearch" | (FormatQueryOptions & {
+  format: "elasticsearch";
+})): Record<string, any>;
 /**
- * "Reviver" method for JSON.parse's second argument. Converts objects having a single
- * `$bigint: string` property to an actual `bigint` value.
+ * Generates a MongoDB query object from an RQB query object.
  *
- * Inverse of {@link bigIntJsonStringifyReplacer}.
+ * This is equivalent to the "mongodb" format, but returns a JSON object
+ * instead of a string.
  *
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+ * @group Export
  */
-declare const bigIntJsonParseReviver: (_key: string, value: unknown) => unknown;
-//#endregion
-//#region src/utils/formatQuery/index.d.ts
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb_query" | (FormatQueryOptions & {
+  format: "mongodb_query";
+})): Record<string, any>;
 /**
- * Default value processor used by {@link formatQuery} for "sql" format.
+ * Generates a JSON.stringify'd MongoDB query object from an RQB query object.
  *
- * @deprecated Prefer {@link defaultValueProcessorByRule}.
+ * This is equivalent to the "mongodb_query" format, but returns a string
+ * instead of a JSON object.
+ *
+ * @deprecated Use the "mongodb_query" format for greater flexibility.
  *
  * @group Export
  */
-declare const defaultValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb" | (FormatQueryOptions & {
+  format: "mongodb";
+})): string;
 /**
- * @deprecated Prefer {@link defaultRuleProcessorMongoDB}.
+ * Generates a Prisma ORM query object from an RQB query object.
  *
  * @group Export
  */
-declare const defaultMongoDBValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "prisma" | (FormatQueryOptions & {
+  format: "prisma";
+})): Record<string, any>;
 /**
- * @deprecated Prefer {@link defaultRuleProcessorCEL}.
+ * Generates a Drizzle ORM query function from an RQB query object. The function can
+ * be assigned to the `where` property in the Drizzle relational queries API.
  *
  * @group Export
  */
-declare const defaultCELValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (FormatQueryOptions & {
+  format: "drizzle";
+})): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
 /**
- * @deprecated Prefer {@link defaultRuleProcessorSpEL}.
+ * Generates a TanStack DB WhereCallback from an RQB query object. The callback can
+ * be passed directly to TanStack DB's `.where()` method.
  *
  * @group Export
  */
-declare const defaultSpELValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
+  format: "tanstack_db";
+})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
 /**
- * @deprecated Renamed to {@link defaultRuleProcessorCEL}.
+ * be assigned to the `where` property in the Sequelize query functions.
  *
  * @group Export
  */
-declare const defaultValueProcessorCELByRule: RuleProcessor;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "sequelize" | (FormatQueryOptions & {
+  format: "sequelize";
+})): ReturnType<typeof defaultRuleGroupProcessorSequelize>;
 /**
- * @deprecated Renamed to {@link defaultRuleProcessorMongoDB}.
+ * Generates a JSONata query string from an RQB query object.
+ *
+ * NOTE: Either `parseNumbers: "strict-limited"` or `parseNumbers: true`
+ * are recommended for this format.
  *
  * @group Export
  */
-declare const defaultValueProcessorMongoDBByRule: RuleProcessor;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonata" | (FormatQueryOptions & {
+  format: "jsonata";
+})): string;
 /**
- * @deprecated Renamed to {@link defaultRuleProcessorSpEL}.
+ * Generates an LDAP query string from an RQB query object.
  *
  * @group Export
  */
-declare const defaultValueProcessorSpELByRule: RuleProcessor;
-//#endregion
-//#region src/utils/generateAccessibleDescription.d.ts
-declare const generateAccessibleDescription: AccessibleDescriptionGenerator;
-//#endregion
-//#region src/utils/generateID.d.ts
-type UUID = `${string}-${string}-${string}-${string}-${string}`;
-declare const uuidV4regex: RegExp;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "ldap" | (FormatQueryOptions & {
+  format: "ldap";
+})): string;
 /**
- * Default `id` generator. Generates a valid v4 UUID. Uses `crypto.randomUUID()`
- * when available, otherwise uses an alternate method based on `getRandomValues`.
- * The returned string is guaranteed to match this regex:
- * ```
- * /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
- * ```
- * @returns Valid v4 UUID
+ * Generates a {@link DiagnosticsResult} from a query object, containing an annotated
+ * query tree, a flat diagnostics array, aggregate stats, and a per-field summary.
+ *
+ * @group Export
  */
-declare let generateID: () => UUID;
-//#endregion
-//#region src/utils/getMatchModesUtil.d.ts
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "diagnostics" | (FormatQueryOptions & {
+  format: "diagnostics";
+})): DiagnosticsResult;
 /**
- * Utility function to get the match modes array for the given
- * field. If the field definition does not define a `matchModes`
- * property, the `getMatchModes` prop is used. Returns
- * `FullOption<MatchMode>[]` of all match modes by default.
+ * Generates a formatted (indented two spaces) JSON string from a query object.
+ *
+ * @group Export
  */
-declare const getMatchModesUtil: <F extends FullField>(fieldData: F, getMatchModes?: (field: GetOptionIdentifierType<F>, misc: {
-  fieldData: F;
-}) => boolean | MatchMode[] | FlexibleOption<MatchMode>[]) => MatchModeOptions;
-//#endregion
-//#region src/utils/getParseNumberMethod.d.ts
-declare const getParseNumberMethod: ({ parseNumbers, inputType }: {
-  parseNumbers?: ParseNumbersPropConfig;
-  inputType?: InputType | null;
-}) => ParseNumberMethod;
-//#endregion
-//#region src/utils/getRuleDefaultValue.d.ts
-/** Options for {@link getRuleDefaultValue}. */
-interface GetRuleDefaultValueOptions<F extends FullField = FullField> {
-  /** Resolved field configuration for `rule.field` (e.g. `fieldMap[rule.field] ?? {}`). */
-  fieldData: F;
-  /** Full field list, used to seed a comparator-valid field when `valueSource` is `'field'`. */
-  fields: FullOptionList<F>;
-  /** Resolves the editor type for the field/operator (drives select/radio/checkbox defaults). */
-  getValueEditorType: (field: string, operator: string, meta: {
-    fieldData: F;
-  }) => ValueEditorType;
-  /** Resolves the value option list for the field/operator. */
-  getValues: (field: string, operator: string, meta: {
-    fieldData: F;
-  }) => FullOptionList<Option>;
-  /** Optional escape hatch overriding the computed default. */
-  getDefaultValue?: (rule: RuleType, meta: {
-    fieldData: F;
-  }) => unknown;
-  /** Named parameter options, used to seed a default when `valueSource` is `'parameter'`. */
-  getParameters?: (field: string, operator: string, meta: {
-    fieldData: F;
-  }) => FullOptionList<Option> | null;
-  /** When `true`, multi-value defaults are arrays instead of comma-joined strings. */
-  listsAsArrays?: boolean;
-}
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions): string;
 /**
- * Computes the default `value` for a rule given its `field`/`operator`/`valueSource`, mirroring
- * the precedence the {@link react-querybuilder!QueryBuilder QueryBuilder} applies: a field's
- * `defaultValue`, then a `getDefaultValue` override, then a value derived from the field/operator's
- * value list and editor type (first option for `select`/`radio`, `false` for `checkbox`, paired for
- * `between`/`notBetween`), or a comparator-valid field when `valueSource` is `'field'`. Falls back
- * to `''`.
+ * Generates a query string in the requested format.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const getRuleDefaultValue$1: <F extends FullField = FullField>(rule: RuleType, options: GetRuleDefaultValueOptions<F>) => unknown;
-//#endregion
-//#region src/utils/getValidationClassNames.d.ts
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: Exclude<ExportFormat, ExportObjectFormats>): string;
 /**
- * Gets the standard classname for valid or invalid components
- * based on the given validation result.
+ * Generates a query string in the requested format.
+ *
+ * @group Export
  */
-declare const getValidationClassNames: (validationResult: boolean | ValidationResult) => "" | (typeof standardClassnames)["valid"] | (typeof standardClassnames)["invalid"];
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
+  format: Exclude<ExportFormat, ExportObjectFormats>;
+}): string;
 //#endregion
-//#region src/utils/getValueSourcesUtil.d.ts
+//#region src/utils/formatQuery/utils.d.ts
 /**
- * Utility function to get the value sources array for the given
- * field and operator. If the field definition does not define a
- * `valueSources` property, the `getValueSources` prop is used.
- * Returns `[FullOption<"value">]` by default.
+ * Maps a {@link DefaultOperatorName} to a SQL operator.
+ *
+ * @group Export
  */
-declare const getValueSourcesUtil: <F extends FullField, O extends string>(fieldData: F, operator: string, getValueSources?: (field: GetOptionIdentifierType<F>, operator: O, misc: {
-  fieldData: F;
-}) => ValueSources | ValueSourceFlexibleOptions) => ValueSourceFullOptions;
-//#endregion
-//#region src/utils/isRuleGroup.d.ts
+declare const mapSQLOperator: (rqbOperator: string) => string;
 /**
- * Determines if an object is a {@link RuleType} (only checks for a `field` property).
+ * Returns a preset-aware SQL string-concatenation function. Emits `CONCAT(a, b, ...)` when
+ * `concatOperator` is `"CONCAT"` (case-insensitive), otherwise joins with the infix operator
+ * (e.g. `a || b`, `a + b`).
+ *
+ * @group Export
  */
-declare const isRuleType: (s: unknown) => s is RuleType;
+declare const getSQLConcat: (concatOperator?: string) => (...values: string[]) => string;
 /**
- * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
+ * Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
+ * → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
+ * yield `['', '']`.
+ *
+ * @group Export
  */
-declare const isRuleGroup: (rg: unknown) => rg is RuleGroupTypeAny;
+declare const getLikeWildcards: (operatorLC: string) => [string, string];
 /**
- * Determines if an object is a {@link RuleGroupType}.
+ * Wraps an already-serialized SQL fragment (a quoted field name or an expression) with the
+ * `LIKE` wildcards for the given (lowercase) string-match operator, concatenating the literal
+ * `%` markers via the preset-aware {@link getSQLConcat}. Returns the fragment untouched for
+ * operators without wildcards.
+ *
+ * @group Export
  */
-declare const isRuleGroupType: (rg: unknown) => rg is RuleGroupType;
+declare const wrapLikeFragment: (fragment: string, operatorLC: string, { concatOperator, quoteValuesWith, wrapValueWith }?: {
+  concatOperator?: string;
+  quoteValuesWith?: string;
+  wrapValueWith?: [string, string];
+}) => string;
 /**
- * Determines if an object is a {@link RuleGroupTypeIC}.
+ * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
+ *
+ * @group Export
  */
-declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
-//#endregion
-//#region src/utils/isRuleOrGroupValid.d.ts
+declare const mongoOperators: {
+  "=": string;
+  "!=": string;
+  "<": string;
+  "<=": string;
+  ">": string;
+  ">=": string;
+  in: string;
+  notin: string;
+  notIn: string;
+};
 /**
- * Determines if an object is useful as a validation result.
+ * Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
+ *
+ * @group Export
  */
-declare const isValidationResult: (vr?: ValidationResult) => vr is ValidationResult;
+declare const prismaOperators: {
+  "=": string;
+  "!=": string;
+  "<": string;
+  "<=": string;
+  ">": string;
+  ">=": string;
+  in: string;
+  notin: string;
+};
 /**
- * Determines if a rule or group is valid based on a validation result (if defined)
- * or a validator function. Returns `true` if neither are defined and the `muted`
- * property is not `true`.
+ * Maps a {@link DefaultCombinatorName} to a CEL combinator.
+ *
+ * @group Export
  */
-declare const isRuleOrGroupValid: (rg: RuleType | RuleGroupTypeAny, validationResult?: boolean | ValidationResult, validator?: RuleValidator) => boolean;
-//#endregion
-//#region src/utils/mergeAnyTranslations.d.ts
+declare const celCombinatorMap: {
+  and: "&&";
+  or: "||";
+};
 /**
- * Merges any number of partial translations into a single definition.
+ * Register these operators with `jsonLogic` before applying the result
+ * of `formatQuery(query, 'jsonlogic')`.
+ *
+ * @example
+ * ```
+ * for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {
+ *   jsonLogic.add_operation(op, func);
+ * }
+ * jsonLogic.apply({ "startsWith": [{ "var": "firstName" }, "Stev"] }, data);
+ * ```
+ *
+ * @group Export
  */
-declare const mergeAnyTranslations: (base: Record<string, Record<string, unknown>>, ...otherTranslations: (Record<string, Record<string, unknown>> | undefined)[]) => Record<string, Record<string, unknown>>;
-declare const mergeAnyTranslation: (el: string, keyPropContextMap: Record<string, [unknown, unknown]>, defaults?: Record<string, Record<string, unknown>>) => Record<string, Record<string, unknown>> | undefined;
-//#endregion
-//#region src/utils/mergeClassnames.d.ts
-type MergeClassnamesParams = (Partial<Classnames> | undefined)[];
+declare const jsonLogicAdditionalOperators: Record<"startsWith" | "endsWith", (a: string, b: string) => boolean>;
 /**
- * Merges a list of partial {@link Classnames} definitions into a single definition.
+ * Returns a new query object with all `string`-type `value` properties converted
+ * to `number` where appropriate.
+ *
+ * Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
+ *
+ * @group Export
  */
-declare const mergeClassnames: (...args: MergeClassnamesParams) => Classnames;
-//#endregion
-//#region src/utils/misc.d.ts
+declare const numerifyValues: (rg: RuleGroupTypeAny, options: SetRequired<FormatQueryOptions, "fields">) => RuleGroupTypeAny;
 /**
- * Converts a value to lowercase if it's a string, otherwise returns the value as is.
+ * Determines whether a value is _anything_ except an empty `string` or `NaN`.
+ *
+ * @group Export
  */
-declare const lc: <T>(v: T) => T;
+declare const isValidValue: (value: unknown) => boolean;
 /**
- * Regex matching numeric strings. Passes for positive/negative integers, decimals,
- * and E notation, with optional surrounding whitespace.
+ * Determines whether {@link formatQuery} should render the given value as a number.
+ * As long as `parseNumbers` is `true`, `number` and `bigint` values will return `true` and
+ * `string` values will return `true` if they test positive against {@link numericRegex}.
+ *
+ * @group Export
  */
-declare const numericRegex: RegExp;
+declare const shouldRenderAsNumber: (value: unknown, parseNumbers?: boolean) => boolean;
 /**
- * Determines if a variable is a plain old JavaScript object, aka POJO.
+ * Used by {@link formatQuery} to determine whether the given value processor is a
+ * "legacy" value processor by counting the number of arguments. Legacy value
+ * processors take 3 arguments (not counting any arguments with default values), while
+ * rule-based value processors take no more than 2 arguments.
+ *
+ * @group Export
  */
-declare const isPojo: (obj: unknown) => obj is Record<string, any>;
+declare const isValueProcessorLegacy: (valueProcessor: ValueProcessorLegacy | ValueProcessorByRule) => valueProcessor is ValueProcessorLegacy;
 /**
- * Simple helper to determine whether a value is null, undefined, or an empty string.
+ * Converts the `quoteFieldNamesWith` option into an array of two strings.
+ * If the option is a string, the array elements are both that string.
+ *
+ * @default
+ * ['', '']
+ *
+ * @group Export
  */
-declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefined | "";
-//#endregion
-//#region src/utils/objectUtils.d.ts
+declare const getQuoteFieldNamesWithArray: (quoteFieldNamesWith?: null | string | [string, string]) => [string, string];
 /**
- * Original looked like this (not sure why template string is used):
- * ```
- * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
- * ```
+ * Given a field name and relevant {@link ValueProcessorOptions}, returns the field name
+ * wrapped in the configured quote character(s).
+ *
+ * @group Export
  */
-type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
+declare const getQuotedFieldName: (fieldName: string, { quoteFieldNamesWith, fieldIdentifierSeparator }: ValueProcessorOptions) => string;
 /**
- * A strongly-typed version of `Object.keys()`.
+ * Given a [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
+ * like "svo" or "sov", returns a permutation of `["S", "V", "O"]` based on the first occurrence of
+ * each letter in the input string (case insensitive). This widens the valid input from abbreviations
+ * like "svo" to more expressive strings like "subject-verb-object" or "sub ver obj". Any missing
+ * letters are appended in the default order "SVO" (e.g., "object" would yield `["O", "S", "V"]`).
  *
- * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+ * @group Export
  */
-declare const objectKeys: <Type extends object>(value: Type) => Array<ObjectKeys<Type>>;
+declare const normalizeConstituentWordOrder: (input: string) => ConstituentWordOrder;
 /**
- * A strongly-typed version of `Object.entries()`.
+ * Prefixes a named-parameter value with the given `paramPrefix` unless the value already
+ * begins with it. Used by {@link formatQuery} to render rules whose `valueSource` is
+ * `"parameter"` (e.g. `"p1"` with prefix `":"` → `":p1"`; `":p1"` → `":p1"`).
  *
- * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
+ * @group Export
  */
-declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value: Type) => Array<[ObjectKeys<Type>, Type[ObjectKeys<Type>]]>;
+declare const withParamPrefix: (value: unknown, paramPrefix?: string) => string;
 /**
- * Returns `true` if the key could cause prototype pollution when used
- * as a property name in bracket-notation assignment.
+ * Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
+ * {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
+ *
+ * @group Export
  */
-declare const isUnsafeKey: (key: unknown) => boolean;
-//#endregion
-//#region src/utils/optionResolvers.d.ts
+declare const stripParamPrefix: (value: unknown, paramPrefix?: string) => string;
 /**
- * Options shared by the resolvers below that produce a normalized option list.
+ * Default translations used by {@link formatQuery} for "natural_language" format.
+ *
+ * @group Export
  */
-interface ResolveOptionListOptions {
-  /**
-   * Prepended as an empty placeholder option when `autoSelectOption` is `false`. Supplied by the
-   * `translations` prop in React; omit it where translations don't apply.
-   */
-  placeholder?: Placeholder;
-  /** Properties applied to every option in the resulting list. */
-  baseOption?: Record<string, unknown>;
-  /** When `false`, an empty placeholder option is prepended. */
-  autoSelectOption?: boolean;
-}
+declare const defaultNLTranslations: NLTranslations;
 /**
- * Resolves the operator list for a field, applying the same precedence as the `QueryBuilder`
- * component: the field's own `operators`, then the `getOperators` callback, then the
- * query-level operator list.
+ * Used by {@link formatQuery} to get a translation based on certain conditions
+ * for the "natural_language" format.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const resolveOperatorList: <F extends FullField = FullField, O extends FullOperator = FullOperator>({ field, fieldData, getOperators, operators, placeholder, baseOption, autoSelectOption }: {
-  field: string;
-  fieldData: F;
-  getOperators?: (field: string, misc: {
-    fieldData: F;
-  }) => FlexibleOptionList<O> | null;
-  operators: FullOptionList<O>;
-} & ResolveOptionListOptions) => FullOptionList<O>;
+declare const getNLTranslataion: (key: NLTranslationKey, translations: NLTranslations, conditions?: GroupVariantCondition[]) => string;
+type ProcessedMatchMode = {
+  mode: "all";
+  threshold?: number | null | undefined;
+} | {
+  mode: "none";
+  threshold?: number | null | undefined;
+} | {
+  mode: "some";
+  threshold?: number | null | undefined;
+} | {
+  mode: "atleast";
+  threshold: number;
+} | {
+  mode: "atmost";
+  threshold: number;
+} | {
+  mode: "exactly";
+  threshold: number;
+};
 /**
- * Resolves the default operator for a field, applying the same precedence as the `QueryBuilder`
- * component: the field's own `defaultOperator`, then the `getDefaultOperator` option (a string or
- * a function), then the first available operator.
+ * Transforms
+ * - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
+ * - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
  *
- * @group Option Lists
+ * Returns:
+ * - Processed `{ mode, threshold }` object for valid subqueries
+ * - `null` if match mode is not applicable for the rule
+ * - `false` if match mode is valid, but either
+ *   1. `threshold` is required and invalid, or
+ *   2. `value` is not a valid rule group.
  */
-declare const resolveDefaultOperator: <F extends FullField = FullField>({ field, fieldData, getDefaultOperator, getOperators }: {
-  field: string;
-  fieldData: F;
-  getDefaultOperator?: string | ((field: string, misc: {
-    fieldData: F;
-  }) => string);
-  /** Produces the operator list for the field, i.e. {@link resolveOperatorList} already bound. */
-  getOperators: (field: string, misc: {
-    fieldData: F;
-  }) => FullOptionList<FullOperator>;
-}) => string;
+declare const processMatchMode: (rule: RuleType) => null | false | ProcessedMatchMode;
 /**
- * Resolves the value editor type for a field/operator pair, applying the same precedence as the
- * `QueryBuilder` component: the field's own `valueEditorType` (a string or a function of the
- * operator), then the `getValueEditorType` callback, then `"text"`.
- *
- * @group Option Lists
+ * Base alias assigned to the element binding of a subquery generated for a rule's
+ * {@link MatchMode `match` mode} (e.g. `unnest(field) as elem_alias`).
  */
-declare const resolveValueEditorType: <F extends FullField = FullField>({ field, operator, fieldData, getValueEditorType }: {
-  field: string;
-  operator: string;
-  fieldData: F;
-  getValueEditorType?: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => ValueEditorType;
-}) => ValueEditorType;
+declare const subqueryElementAliasBase = "elem_alias";
 /**
- * Resolves the value option list for a field/operator pair, applying the same precedence as the
- * `QueryBuilder` component: the field's own `values`, then the `getValues` callback, then an
- * empty list.
+ * Returns the element alias for a subquery at the given nesting depth. Depth 0 (the common,
+ * non-nested case) uses {@link subqueryElementAliasBase} unchanged; deeper levels are suffixed
+ * with the depth, so a subquery nested within a subquery cannot shadow its parent's binding.
  *
- * @group Option Lists
+ * Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
+ *
+ * @group Export
  */
-declare const resolveValueList: <F extends FullField = FullField>({ field, operator, fieldData, getValues, placeholder, baseOption, autoSelectOption }: {
-  field: string;
-  operator: string;
-  fieldData: F;
-  getValues?: (field: string, operator: string, misc: {
-    fieldData: F;
-  }) => FlexibleOptionList<Option> | null;
-} & ResolveOptionListOptions) => FullOptionList<Option>;
-//#endregion
-//#region src/utils/optGroupUtils.d.ts
+declare const getSubqueryElementAlias: (subqueryDepth?: number) => string;
 /**
- * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
- * into a {@link FullOption}. Full options are left unchanged.
+ * "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
+ * objects with a `$bigint` property having a value of a string representation of
+ * the actual `bigint`-type value.
  *
- * @group Option Lists
+ * Inverse of {@link bigIntJsonParseReviver}.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
  */
-declare function toFullOption<Opt extends BaseOption>(opt: Opt | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt>;
+declare const bigIntJsonStringifyReplacer: (_key: string, value: unknown) => unknown;
 /**
- * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
- * Lists of full options are left unchanged.
+ * "Reviver" method for JSON.parse's second argument. Converts objects having a single
+ * `$bigint: string` property to an actual `bigint` value.
  *
- * @group Option Lists
+ * Inverse of {@link bigIntJsonStringifyReplacer}.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
  */
-declare function toFullOptionList<Opt extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt>;
+declare const bigIntJsonParseReviver: (_key: string, value: unknown) => unknown;
+//#endregion
+//#region src/utils/formatQuery/index.d.ts
 /**
- * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
- * Lists of full options are left unchanged.
+ * Default value processor used by {@link formatQuery} for "sql" format.
  *
- * @group Option Lists
+ * @deprecated Prefer {@link defaultValueProcessorByRule}.
+ *
+ * @group Export
  */
-declare function toFullOptionMap<OptMap extends BaseOptionMap>(optMap: OptMap, baseProperties?: Record<string, unknown>): OptMap extends BaseOptionMap<infer V, infer K> ? Partial<Record<K, ToFullOption<V>>> : never;
+declare const defaultValueProcessor: ValueProcessorLegacy;
 /**
- * @deprecated Renamed to {@link uniqByIdentifier}.
+ * @deprecated Prefer {@link defaultRuleProcessorMongoDB}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const uniqByName: <T extends {
-  name: string;
-  value?: string;
-} | {
-  name?: string;
-  value: string;
-}>(originalArray: T[]) => T[];
+declare const defaultMongoDBValueProcessor: ValueProcessorLegacy;
 /**
- * Generates a new array of objects with duplicates removed based
- * on the identifying property (`value` or `name`)
+ * @deprecated Prefer {@link defaultRuleProcessorCEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const uniqByIdentifier: <T extends RequireAtLeastOne$1<{
-  name: string;
-  value: string;
-}, "name" | "value">>(originalArray: T[]) => T[];
+declare const defaultCELValueProcessor: ValueProcessorLegacy;
 /**
- * Determines if an {@link OptionList} is an {@link OptionGroup} array.
+ * @deprecated Prefer {@link defaultRuleProcessorSpEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const isOptionGroupArray: (arr: unknown) => arr is OptionGroup<BaseOption>[];
+declare const defaultSpELValueProcessor: ValueProcessorLegacy;
 /**
- * Determines if an array is a flat array of {@link FlexibleOption}.
+ * @deprecated Renamed to {@link defaultRuleProcessorCEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const isFlexibleOptionArray: (arr: unknown) => arr is FlexibleOption[];
+declare const defaultValueProcessorCELByRule: RuleProcessor;
 /**
- * Determines if an array is a flat array of {@link FullOption}.
+ * @deprecated Renamed to {@link defaultRuleProcessorMongoDB}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const isFullOptionArray: (arr: unknown) => arr is FullOption[];
+declare const defaultValueProcessorMongoDBByRule: RuleProcessor;
 /**
- * Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
+ * @deprecated Renamed to {@link defaultRuleProcessorSpEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const isFlexibleOptionGroupArray: (arr: unknown, { allowEmpty }?: {
-  allowEmpty?: boolean;
-}) => arr is FlexibleOptionGroup[];
+declare const defaultValueProcessorSpELByRule: RuleProcessor;
+//#endregion
+//#region src/utils/generateAccessibleDescription.d.ts
 /**
- * Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.
+ * The default `accessibleDescriptionGenerator`. Produces the `aria-label` for a rule group:
+ * `"Query builder"` for the root group, `"Rule group at path 0-1"` for any other.
  *
- * @group Option Lists
+ * @group Accessibility
  */
-declare const isFullOptionGroupArray: (arr: unknown, { allowEmpty }?: {
-  allowEmpty?: boolean;
-}) => arr is OptionGroup<FullOption>[];
+declare const generateAccessibleDescription: AccessibleDescriptionGenerator;
+//#endregion
+//#region src/utils/generateID.d.ts
+type UUID = `${string}-${string}-${string}-${string}-${string}`;
+declare const uuidV4regex: RegExp;
 /**
- * Gets the option from an {@link OptionList} with the given `name`. Handles
- * {@link Option} arrays as well as {@link OptionGroup} arrays.
- *
- * @group Option Lists
+ * Default `id` generator. Generates a valid v4 UUID. Uses `crypto.randomUUID()`
+ * when available, otherwise uses an alternate method based on `getRandomValues`.
+ * The returned string is guaranteed to match this regex:
+ * ```
+ * /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
+ * ```
+ * @returns Valid v4 UUID
  */
-declare function getOption<OptType extends FullOption>(arr: FullOptionList<OptType>, name: string): OptType | undefined;
-declare function getOption<OptType extends ValueOption>(arr: FlexibleOptionList<OptType>, name: string): OptType | undefined;
-declare function getOption<OptType extends Option>(arr: FlexibleOptionList<OptType>, name: string): OptType | undefined;
+declare let generateID: () => UUID;
+//#endregion
+//#region src/utils/immerInstances.d.ts
 /**
- * Gets the first option from an {@link OptionList}.
+ * Globally enables or disables immer's auto-freeze, i.e. the deep freeze applied to every query
+ * returned by {@link add}, {@link update}, {@link remove}, {@link move}, {@link insert}, and
+ * {@link group}.
  *
- * @group Option Lists
- */
-declare function getFirstOption<Opt extends FullOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-declare function getFirstOption<Opt extends ValueOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-declare function getFirstOption<Opt extends Option>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-/**
- * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
- * If the array is already flat, it is returned as is.
+ * Re-exported from immer so that consumers mixing these tools with their own `produce` calls can
+ * switch both at once. Prefer the per-call `freeze` option, or the {@link QueryManager} option of
+ * the same name, when the change should not be process-wide. A per-call `freeze: false` wins
+ * regardless of this setting; a per-call `freeze: true` does not re-enable freezing once this has
+ * turned it off, since it selects immer's default instance.
  *
- * @group Option Lists
+ * @group Query Tools
  */
-declare const toFlatOptionArray: <T extends FullOption>(arr: FullOptionList<T>) => T[];
+declare const setAutoFreeze: (autoFreeze: boolean) => void;
+//#endregion
+//#region src/utils/getMatchModesUtil.d.ts
 /**
- * Generates a new {@link OptionGroup} array with duplicates
- * removed based on the identifying property (`value` or `name`).
- *
- * @group Option Lists
+ * Utility function to get the match modes array for the given
+ * field. If the field definition does not define a `matchModes`
+ * property, the `getMatchModes` prop is used. Returns
+ * `FullOption<MatchMode>[]` of all match modes by default.
  */
-declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptionGroup<T>[]) => OptionGroup<ToFullOption<T>>[];
+declare const getMatchModesUtil: <F extends FullField>(fieldData: F, getMatchModes?: (field: GetOptionIdentifierType<F>, misc: {
+  fieldData: F;
+}) => boolean | MatchMode[] | FlexibleOption<MatchMode>[]) => MatchModeOptions;
+//#endregion
+//#region src/utils/getParseNumberMethod.d.ts
+declare const getParseNumberMethod: ({ parseNumbers, inputType }: {
+  parseNumbers?: ParseNumbersPropConfig;
+  inputType?: InputType | null;
+}) => ParseNumberMethod;
+//#endregion
+//#region src/utils/getRuleDefaultValue.d.ts
+/** Options for {@link getRuleDefaultValue}. */
+interface GetRuleDefaultValueOptions<F extends FullField = FullField> {
+  /** Resolved field configuration for `rule.field` (e.g. `fieldMap[rule.field] ?? {}`). */
+  fieldData: F;
+  /** Full field list, used to seed a comparator-valid field when `valueSource` is `'field'`. */
+  fields: FullOptionList<F>;
+  /** Resolves the editor type for the field/operator (drives select/radio/checkbox defaults). */
+  getValueEditorType: (field: string, operator: string, meta: {
+    fieldData: F;
+  }) => ValueEditorType;
+  /** Resolves the value option list for the field/operator. */
+  getValues: (field: string, operator: string, meta: {
+    fieldData: F;
+  }) => FullOptionList<Option>;
+  /** Optional escape hatch overriding the computed default. */
+  getDefaultValue?: (rule: RuleType, meta: {
+    fieldData: F;
+  }) => unknown;
+  /** Named parameter options, used to seed a default when `valueSource` is `'parameter'`. */
+  getParameters?: (field: string, operator: string, meta: {
+    fieldData: F;
+  }) => FullOptionList<Option> | null;
+  /** When `true`, multi-value defaults are arrays instead of comma-joined strings. */
+  listsAsArrays?: boolean;
+}
 /**
- * Generates a new {@link Option} or {@link OptionGroup} array with duplicates
- * removed based on the identifier property (`value` or `name`).
+ * Computes the default `value` for a rule given its `field`/`operator`/`valueSource`, mirroring
+ * the precedence the {@link react-querybuilder!QueryBuilder QueryBuilder} applies: a field's
+ * `defaultValue`, then a `getDefaultValue` override, then a value derived from the field/operator's
+ * value list and editor type (first option for `select`/`radio`, `false` for `checkbox`, paired for
+ * `between`/`notBetween`), or a comparator-valid field when `valueSource` is `'field'`. Falls back
+ * to `''`.
  *
  * @group Option Lists
  */
-declare const uniqOptList: <T extends BaseOption>(originalArray: FlexibleOptionList<T>) => WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[];
-interface PreparedOptionList<O extends FullOption> {
-  defaultOption: FullOption;
-  optionList: FullOptionList<O>;
-  optionsMap: Partial<FullOptionRecord<FullOption>>;
-}
-interface PrepareOptionListParams<O extends FullOption> {
-  placeholder?: Placeholder;
-  optionList?: FlexibleOptionListProp<O> | BaseOptionMap<O>;
-  baseOption?: Record<string, unknown>;
-  labelMap?: Record<string, string>;
-  autoSelectOption?: boolean;
-}
-declare const prepareOptionList: <O extends FullOption>(props: PrepareOptionListParams<O>) => PreparedOptionList<O>;
+declare const getRuleDefaultValue$1: <F extends FullField = FullField>(rule: RuleType, options: GetRuleDefaultValueOptions<F>) => unknown;
 //#endregion
-//#region src/utils/parseNumber.d.ts
+//#region src/utils/getValidationClassNames.d.ts
 /**
- * Options object for {@link parseNumber}.
+ * Gets the standard classname for valid or invalid components
+ * based on the given validation result.
  */
-interface ParseNumberOptions {
-  parseNumbers?: ParseNumberMethod;
-  /**
-   * Generates a `bigint` value if the string represents a valid integer
-   * outside the safe boundaries of the `number` type.
-   */
-  bigIntOnOverflow?: boolean;
-}
+declare const getValidationClassNames: (validationResult: boolean | ValidationResult) => "" | (typeof standardClassnames)["valid"] | (typeof standardClassnames)["invalid"];
+//#endregion
+//#region src/utils/getValueSourcesUtil.d.ts
 /**
- * Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is "native",
- * otherwise uses [`numeric-quantity`](https://jakeboone02.github.io/numeric-quantity/).
- * If that returns `NaN`, the string is returned unchanged. Numeric values are returned
- * as-is regardless of the `parseNumbers` option.
+ * Utility function to get the value sources array for the given
+ * field and operator. If the field definition does not define a
+ * `valueSources` property, the `getValueSources` prop is used.
+ * Returns `[FullOption<"value">]` by default.
  */
-declare const parseNumber: (val: unknown, { parseNumbers, bigIntOnOverflow }?: ParseNumberOptions) => any;
+declare const getValueSourcesUtil: <F extends FullField, O extends string>(fieldData: F, operator: string, getValueSources?: (field: GetOptionIdentifierType<F>, operator: O, misc: {
+  fieldData: F;
+}) => ValueSources | ValueSourceFlexibleOptions) => ValueSourceFullOptions;
 //#endregion
-//#region src/utils/pathUtils.d.ts
+//#region src/utils/isRuleGroup.d.ts
 /**
- * Return type for {@link findPath}.
+ * Determines if an object is a {@link RuleType} (only checks for a `field` property).
  */
-type FindPathReturnType = RuleGroupTypeAny | RuleType | null;
+declare const isRuleType: (s: unknown) => s is RuleType;
 /**
- * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
- * at the given path within a query.
+ * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
  */
-declare const findPath: (path: Path, query: RuleGroupTypeAny) => FindPathReturnType;
+declare const isRuleGroup: (rg: unknown) => rg is RuleGroupTypeAny;
 /**
- * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
- * with the given `id` within a query.
+ * Determines if an object is a {@link RuleGroupType}.
  */
-declare const findID: (id: string, query: RuleGroupTypeAny) => FindPathReturnType;
+declare const isRuleGroupType: (rg: unknown) => rg is RuleGroupType;
 /**
- * Returns the {@link Path} of the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
- * with the given `id` within a query.
+ * Determines if an object is a {@link RuleGroupTypeIC}.
  */
-declare const getPathOfID: (id: string, query: RuleGroupTypeAny) => Path | null;
+declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
+//#endregion
+//#region src/utils/isRuleOrGroupValid.d.ts
 /**
- * Truncates the last element of an array and returns the result as a new array.
+ * Determines if an object is useful as a validation result.
  */
-declare const getParentPath: (path: Path) => Path;
+declare const isValidationResult: (vr?: ValidationResult) => vr is ValidationResult;
 /**
- * Determines if two paths (each `Path`) are equivalent.
+ * Determines if a rule or group is valid based on a validation result (if defined)
+ * or a validator function. Returns `true` if neither are defined and the `muted`
+ * property is not `true`.
  */
-declare const pathsAreEqual: (path1: Path, path2: Path) => boolean;
+declare const isRuleOrGroupValid: (rg: RuleType | RuleGroupTypeAny, validationResult?: boolean | ValidationResult, validator?: RuleValidator) => boolean;
+//#endregion
+//#region src/utils/mergeAnyTranslations.d.ts
 /**
- * Determines if the first path is an ancestor of the second path. The first path must
- * be shorter and exactly match the second path up through the length of the first path.
+ * Merges any number of partial translations into a single definition.
  */
-declare const isAncestor: (maybeAncestor: Path, path: Path) => boolean;
+declare const mergeAnyTranslations: (base: Record<string, Record<string, unknown>>, ...otherTranslations: (Record<string, Record<string, unknown>> | undefined)[]) => Record<string, Record<string, unknown>>;
+declare const mergeAnyTranslation: (el: string, keyPropContextMap: Record<string, [unknown, unknown]>, defaults?: Record<string, Record<string, unknown>>) => Record<string, Record<string, unknown>> | undefined;
+//#endregion
+//#region src/utils/mergeClassnames.d.ts
+type MergeClassnamesParams = (Partial<Classnames> | undefined)[];
 /**
- * Finds the deepest/longest path that two paths have in common.
+ * Merges a list of partial {@link Classnames} definitions into a single definition.
  */
-declare const getCommonAncestorPath: (path1: Path, path2: Path) => Path;
+declare const mergeClassnames: (...args: MergeClassnamesParams) => Classnames;
+//#endregion
+//#region src/utils/misc.d.ts
 /**
- * Determines if the rule or group at the specified path is either disabled itself
- * or disabled by an ancestor group.
+ * Converts a value to lowercase if it's a string, otherwise returns the value as is.
  */
-declare const pathIsDisabled: (path: Path, query: RuleGroupTypeAny) => boolean;
+declare const lc: <T>(v: T) => T;
 /**
- * Determines if the rule or group at the specified path is disabled by `disabledPaths`—the array
- * form of the `QueryBuilder` `disabled` prop, which disables nodes by position rather than by a
- * `disabled` property on the node itself. A path is disabled if it appears in `disabledPaths` or
- * descends from a path that does.
- *
- * @group Paths
+ * Regex matching numeric strings. Passes for positive/negative integers, decimals,
+ * and E notation, with optional surrounding whitespace.
  */
-declare const pathIsDisabledByPaths: (path: Path, disabledPaths?: Path[]) => boolean;
-/** The path of a child rule or group, and whether it is disabled. */ interface PathInfo {
-  path: Path;
-  disabled: boolean;
-}
+declare const numericRegex: RegExp;
 /**
- * Builds the {@link PathInfo} for each child of a group at `path`. A child is disabled if its
- * parent is disabled or if its own path appears in `disabledPaths`.
- *
- * @group Paths
+ * Determines if a variable is a plain old JavaScript object, aka POJO.
  */
-declare const derivePathInfo: (path: Path, childCount: number, { disabled, disabledPaths }?: {
-  disabled?: boolean;
-  disabledPaths?: Path[];
-}) => PathInfo[];
-//#endregion
-//#region src/utils/preferProp.d.ts
+declare const isPojo: (obj: unknown) => obj is Record<string, any>;
 /**
- * For given default, prop, and context values, return the first provided of prop,
- * context, and default, in that order.
+ * Simple helper to determine whether a value is null, undefined, or an empty string.
  */
-declare const preferProp: (def: boolean, prop?: boolean, context?: boolean, doNotFinalize?: boolean) => boolean;
+declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefined | "";
+//#endregion
+//#region src/utils/objectUtils.d.ts
 /**
- * For given default, prop, and context values, return the first provided of prop,
- * context, and default, in that order.
+ * Original looked like this (not sure why template string is used):
+ * ```
+ * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+ * ```
  */
-declare const preferAnyProp: (def?: any, prop?: any, context?: any) => any;
+type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
 /**
- * For a given set of defaults, props, and context values, return the first provided of prop,
- * context, and default—in that order—for each property in the defaults object.
+ * A strongly-typed version of `Object.keys()`.
+ *
+ * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
  */
-declare const preferFlagProps: (props?: QueryBuilderFlags, contextVals?: QueryBuilderFlags, finalize?: boolean) => QueryBuilderFlags;
-//#endregion
-//#region src/utils/prepareQueryObjects.d.ts
+declare const objectKeys: <Type extends object>(value: Type) => Array<ObjectKeys<Type>>;
 /**
- * Options for {@link prepareRule}/{@link prepareRuleGroup}.
+ * A strongly-typed version of `Object.entries()`.
+ *
+ * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
  */
-interface PreparerOptions {
-  idGenerator?: () => string;
-}
+declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value: Type) => Array<[ObjectKeys<Type>, Type[ObjectKeys<Type>]]>;
 /**
- * Ensures that a rule is valid by adding an `id` property if it does not already exist.
+ * Returns `true` if the key could cause prototype pollution when used
+ * as a property name in bracket-notation assignment.
  */
-declare const prepareRule: (rule: RuleType, { idGenerator }?: PreparerOptions) => RuleType;
+declare const isUnsafeKey: (key: unknown) => boolean;
+//#endregion
+//#region src/utils/optionResolvers.d.ts
 /**
- * Ensures that a rule group is valid by recursively adding an `id` property to the group itself
- * and all its rules and subgroups where one does not already exist.
- */
-declare const prepareRuleGroup: <RG extends RuleGroupTypeAny>(queryObject: RG, { idGenerator }?: PreparerOptions) => RG;
-/**
- * Ensures that a rule or group is valid. See {@link prepareRule} and {@link prepareRuleGroup}.
- */
-declare const prepareRuleOrGroup: (rg: RuleGroupTypeAny | RuleType, { idGenerator }?: PreparerOptions) => RuleGroupType | RuleGroupTypeIC | RuleType;
-/**
- * Resolves the query a query builder should render from the available sources, in precedence
- * order: the controlled `query`, then whatever is already in the store, then the uncontrolled
- * `defaultQuery`, then a freshly created empty group.
- *
- * The result is prepared with {@link prepareRuleGroup} unless it already has an `id`, which is
- * taken to mean it has been prepared before—most often because the caller is passing back the
- * object it received from `onQueryChange`.
- *
- * @group Query Tools
- */
-declare const resolveCandidateQuery: <RG extends RuleGroupTypeAny>(sources: {
-  query?: RG;
-  storeQuery?: RG;
-  defaultQuery?: RG;
-  fallbackQuery: RG;
-}, options?: {
-  idGenerator?: () => string;
-}) => RG;
-//#endregion
-//#region src/utils/queryActions.d.ts
-/**
- * Confirmation callbacks invoked before a mutation is applied. Their return values are
- * interpreted differently depending on the operation:
- *
- * - `onAddRule`/`onAddGroup` may return `true` to proceed, a falsy value to cancel, or a
- *   _replacement rule/group_ to add instead of the one provided.
- * - `onMoveRule`/`onMoveGroup`/`onGroupRule`/`onGroupGroup` may return `true` to proceed, a
- *   falsy value to cancel, or a _replacement query_ to apply instead of the computed one.
- * - `onRemove` is boolean only.
- *
- * @group Query Tools
- */
-interface QueryActionCallbacks {
-  onAddRule?: (rule: RuleType, parentPath: Path, query: any, context?: any) => RuleType | boolean;
-  onAddGroup?: (ruleGroup: any, parentPath: Path, query: any, context?: any) => RuleGroupTypeAny | boolean;
-  onRemove?: (ruleOrGroup: any, path: Path, query: any, context?: any) => boolean;
-  onMoveRule?: (...args: any[]) => RuleGroupTypeAny | boolean;
-  onMoveGroup?: (...args: any[]) => RuleGroupTypeAny | boolean;
-  onGroupRule?: (...args: any[]) => RuleGroupTypeAny | boolean;
-  onGroupGroup?: (...args: any[]) => RuleGroupTypeAny | boolean;
-}
-/**
- * Configuration for {@link createQueryActions}.
- *
- * @group Query Tools
- */
-interface QueryActionsConfig extends QueryActionCallbacks {
-  /** Identifier included in every log payload. */
-  qbId?: string;
-  combinators?: OptionList;
-  idGenerator?: () => string;
-  /** The maximum depth at which groups may be added. Defaults to `Infinity`. */
-  maxLevels?: number;
-  /** Abort every mutation, as though the entire query were disabled. */
-  queryDisabled?: boolean;
-  /**
-   * Honor `disabled` properties within the query. Defaults to `true`, matching the
-   * `QueryBuilder` component; a node's own `disabled` property can always be changed.
-   */
-  respectDisabled?: boolean;
-  /**
-   * Paths disabled by position rather than by a `disabled` property on the node itself, mirroring
-   * the array form of the `QueryBuilder` `disabled` prop. Honored only when `respectDisabled` is
-   * `true`; as with the `disabled` property, a node's own `disabled` can always be changed.
-   */
-  disabledPaths?: Path[];
-  resetOnFieldChange?: boolean;
-  resetOnOperatorChange?: boolean;
-  getRuleDefaultOperator?: (field: string) => string;
-  getValueSources?: (field: string, operator: string) => ValueSourceFullOptions;
-  getRuleDefaultValue?: (rule: RuleType) => any;
-  getMatchModes?: (field: string) => MatchModeOptions;
-  /** Receives a structured event for every action, applied or aborted. */
-  onLog?: (payload: Record<string, any>) => void;
-}
-/**
- * The six mutations a query builder performs. Each takes the current query and returns the next
- * one, or `undefined` when the mutation was aborted—because the target is disabled, a
- * confirmation callback declined, or a depth limit was reached.
- *
- * @group Query Tools
- */
-interface QueryActionHandlers {
-  addRule: (query: any, rule: RuleType, parentPath: Path, context?: any) => any;
-  addGroup: (query: any, ruleGroup: any, parentPath: Path, context?: any) => any;
-  propChange: (query: any, prop: UpdateableProperties, value: any, path: Path) => any;
-  removeRuleOrGroup: (query: any, path: Path, context?: any) => any;
-  moveRule: (query: any, oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any) => any;
-  groupRule: (query: any, sourcePath: Path, targetPath: Path, clone?: boolean, context?: any) => any;
-}
-/**
- * Builds the query builder's six mutation handlers as pure functions of the current query.
- *
- * This is the framework-agnostic core of the action handlers in `useQueryBuilderSchema`. It owns
- * the policy that surrounds the query tools—disabled gating, the confirmation callback protocol,
- * `maxLevels`, and debug logging—so an implementation only has to supply its own storage: read
- * the current query, call the action, and apply a non-`undefined` result.
- *
- * @group Query Tools
- */
-declare const createQueryActions: (config?: QueryActionsConfig) => QueryActionHandlers;
-//#endregion
-//#region src/utils/queryTools.d.ts
-/**
- * Why a query tool returned the query unmodified. Query tools never throw; when they cannot
- * carry out an operation they return the original query and report the reason through
- * {@link AbortOptions.onAbort}.
- *
- * `"same-location"` and `"no-change"` describe operations that were valid but had nothing to
- * do, so they are not errors. Every other reason indicates a target that could not be used.
- *
- * @group Query Tools
- */
-type AbortReason = "target-not-found" | "parent-not-found" | "parent-not-a-group" | "destination-not-found" | "root-not-allowed" | "not-a-combinator-slot" | "same-location" | "no-change" | "target-disabled" | "parent-disabled" | "max-levels-exceeded";
-/**
- * Details about an aborted query tool operation.
- *
- * @group Query Tools
- */
-interface AbortInfo {
-  /** Why the operation was aborted. */
-  reason: AbortReason;
-  /** The query tool that aborted. */
-  operation: "add" | "remove" | "update" | "move" | "insert" | "group";
-  /** The path or `id` that could not be used, when the reason relates to a specific target. */
-  pathOrID?: Path | string;
-}
-/**
- * Options that block a mutation before it is attempted.
- *
- * `disabled` is a property of the query itself, so honoring it is a matter of data integrity
- * rather than presentation: a query saved with a locked rule should stay locked when it is
- * loaded again. It is opt-in here only to preserve the existing behavior of the standalone
- * query tools; {@link QueryManager} enables it by default.
- *
- * @group Query Tools
- */
-interface GuardOptions {
-  /**
-   * Abort when the target (or its parent, for `add`/`insert`) is disabled, either directly or
-   * by descending from a disabled group. Defaults to `false`.
-   *
-   * Updating a rule or group's own `disabled` property is always permitted, since it is the
-   * only way to re-enable it.
-   */
-  respectDisabled?: boolean;
-  /**
-   * Paths that are disabled without the corresponding rule or group carrying a `disabled`
-   * property, mirroring the array form of the `QueryBuilder` `disabled` prop. A path is treated
-   * as disabled if it appears here or descends from a path that does.
-   *
-   * Like the `disabled` property, this is only honored when `respectDisabled` is `true`, and
-   * updating a rule or group's own `disabled` property is still permitted.
-   */
-  disabledPaths?: Path[];
-  /** Abort every mutation, as though the entire query were disabled. Defaults to `false`. */
-  queryDisabled?: boolean;
-  /**
-   * The maximum depth at which a group may be added. A group whose parent path is already this
-   * deep is rejected by `add` and `insert`. Rules are unaffected. Defaults to `Infinity`.
-   */
-  maxLevels?: number;
-}
-/**
- * Options for reporting aborted query tool operations.
- *
- * @group Query Tools
+ * Options shared by the resolvers below that produce a normalized option list.
  */
-interface AbortOptions extends GuardOptions {
+interface ResolveOptionListOptions {
   /**
-   * Called when the operation returns the query unmodified, with the reason why. Query tools
-   * never throw, so this is the only way to distinguish "the target was invalid" from
-   * "the operation had nothing to do".
+   * Prepended as an empty placeholder option when `autoSelectOption` is `false`. Supplied by the
+   * `translations` prop in React; omit it where translations don't apply.
    */
-  onAbort?: (info: AbortInfo) => void;
+  placeholder?: Placeholder;
+  /** Properties applied to every option in the resulting list. */
+  baseOption?: Record<string, unknown>;
+  /** When `false`, an empty placeholder option is prepended. */
+  autoSelectOption?: boolean;
 }
 /**
- * Whether a mutation targeting `pathOrID` is blocked by the given guards, and why.
- * Returns `null` when the mutation may proceed.
- *
- * Exported so that callers which run their own logic before mutating—such as a UI layer that
- * invokes a confirmation callback—can apply the same rules without duplicating them.
+ * Resolves the operator list for a field, applying the same precedence as the `QueryBuilder`
+ * component: the field's own `operators`, then the `getOperators` callback, then the
+ * query-level operator list.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const getGuardAbortReason: (query: RuleGroupTypeAny, pathOrID: Path | string | undefined, guards?: GuardOptions, { asParent }?: {
-  asParent?: boolean;
-}) => AbortReason | null;
+declare const resolveOperatorList: <F extends FullField = FullField, O extends FullOperator = FullOperator>({ field, fieldData, getOperators, operators, placeholder, baseOption, autoSelectOption }: {
+  field: string;
+  fieldData: F;
+  getOperators?: (field: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<O> | null;
+  operators: FullOptionList<O>;
+} & ResolveOptionListOptions) => FullOptionList<O>;
 /**
- * Whether adding a group beneath `parentPath` would exceed `maxLevels`.
+ * Resolves the default operator for a field, applying the same precedence as the `QueryBuilder`
+ * component: the field's own `defaultOperator`, then the `getDefaultOperator` option (a string or
+ * a function), then the first available operator.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const exceedsMaxLevels: (parentPath: Path | undefined, { maxLevels }?: GuardOptions) => boolean;
+declare const resolveDefaultOperator: <F extends FullField = FullField>({ field, fieldData, getDefaultOperator, getOperators }: {
+  field: string;
+  fieldData: F;
+  getDefaultOperator?: string | ((field: string, misc: {
+    fieldData: F;
+  }) => string);
+  /** Produces the operator list for the field, i.e. {@link resolveOperatorList} already bound. */
+  getOperators: (field: string, misc: {
+    fieldData: F;
+  }) => FullOptionList<FullOperator>;
+}) => string;
 /**
- * Options for {@link add}.
+ * Resolves the value editor type for a field/operator pair, applying the same precedence as the
+ * `QueryBuilder` component: the field's own `valueEditorType` (a string or a function of the
+ * operator), then the `getValueEditorType` callback, then `"text"`.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-interface AddOptions extends AbortOptions {
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
-   * combinators), then the first combinator in this list will be inserted
-   * before the new rule/group if the parent group is not empty. This option
-   * is overridden by `combinatorPreceding`.
-   */
-  combinators?: OptionList;
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
-   * combinators), then this combinator will be inserted before the new rule/group
-   * if the parent group is not empty. This option will supersede `combinators`.
-   */
-  combinatorPreceding?: string;
-  /**
-   * ID generator.
-   */
-  idGenerator?: () => string;
-}
-interface AddMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, ruleOrGroup: RG | RuleType, parentPathOrID: Path | string, options?: AddOptions): RG;
-}
+declare const resolveValueEditorType: <F extends FullField = FullField>({ field, operator, fieldData, getValueEditorType }: {
+  field: string;
+  operator: string;
+  fieldData: F;
+  getValueEditorType?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => ValueEditorType;
+}) => ValueEditorType;
 /**
- * Adds a rule or group to a query without mutating the original query.
- *
- * @returns A new query with the rule or group added.
+ * Resolves the value option list for a field/operator pair, applying the same precedence as the
+ * `QueryBuilder` component: the field's own `values`, then the `getValues` callback, then an
+ * empty list.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const add: AddMethod;
+declare const resolveValueList: <F extends FullField = FullField>({ field, operator, fieldData, getValues, placeholder, baseOption, autoSelectOption }: {
+  field: string;
+  operator: string;
+  fieldData: F;
+  getValues?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<Option> | null;
+} & ResolveOptionListOptions) => FullOptionList<Option>;
+//#endregion
+//#region src/utils/optGroupUtils.d.ts
 /**
- * Adds a rule or group to a query in place.
- *
- * @returns The query (mutated in place) with the rule or group added.
+ * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
+ * into a {@link FullOption}. Full options are left unchanged.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const addInPlace: AddMethod;
+declare function toFullOption<Opt extends BaseOption>(opt: Opt | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt>;
 /**
- * Options for {@link update}.
+ * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
+ * Lists of full options are left unchanged.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-interface UpdateOptions extends AbortOptions {
-  /**
-   * When updating the `field` of a rule, the rule's `operator`, `value`, and `valueSource`
-   * will be reset to their respective defaults. Defaults to `true`.
-   */
-  resetOnFieldChange?: boolean;
-  /**
-   * When updating the `operator` of a rule, the rule's `value` and `valueSource`
-   * will be reset to their respective defaults. Defaults to `false`.
-   */
-  resetOnOperatorChange?: boolean;
-  /**
-   * Determines the default operator name for a given field.
-   */
-  getRuleDefaultOperator?: (field: string) => string;
-  /**
-   * Determines the valid value sources for a given field and operator.
-   */
-  getValueSources?: (field: string, operator: string) => ValueSources | ValueSourceFlexibleOptions;
-  /**
-   * Gets the default value for a given rule, in case the value needs to be reset.
-   */
-  getRuleDefaultValue?: (rule: RuleType) => any;
-  /**
-   * Determines the valid match modes for a given field.
-   */
-  getMatchModes?: (field: string) => MatchModeOptions;
-}
-interface UpdateMethod {
-  /**
-   * Updates a single property of a rule or group.
-   */
-  <RG extends RuleGroupTypeAny>(query: RG, prop: UpdateableProperties, value: any, pathOrID: Path | string, options?: UpdateOptions): RG;
-  /**
-   * Updates multiple properties of a rule or group using parallel arrays of
-   * property names and corresponding values.
-   */
-  <RG extends RuleGroupTypeAny>(query: RG, props: UpdateableProperties[], values: any[], pathOrID: Path | string, options?: UpdateOptions): RG;
-  /**
-   * Updates multiple properties of a rule or group using a map of property
-   * names to their new values.
-   */
-  <RG extends RuleGroupTypeAny>(query: RG, props: UpdateValueMap, pathOrID: Path | string, options?: UpdateOptions): RG;
-}
+declare function toFullOptionList<Opt extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt>;
 /**
- * Updates one or more properties of a rule or group within a query without
- * mutating the original query. Properties may be supplied individually
- * (`prop`, `value`), as parallel arrays (`props`, `values`), or as a
- * property-to-value map. For multi-property updates, `field`, `operator`, and
- * `valueSource` are applied before `value`, so an explicit `value` is never
- * reset by a change to one of those properties.
- *
- * @returns A new query with the rule or group properties updated.
+ * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
+ * Lists of full options are left unchanged.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const update: UpdateMethod;
+declare function toFullOptionMap<OptMap extends BaseOptionMap>(optMap: OptMap, baseProperties?: Record<string, unknown>): OptMap extends BaseOptionMap<infer V, infer K> ? Partial<Record<K, ToFullOption<V>>> : never;
 /**
- * Updates one or more properties of a rule or group within a query in place.
- * See {@link update} for the supported argument forms and ordering semantics.
- *
- * @returns The query (mutated in place) with the rule or group properties updated.
+ * @deprecated Renamed to {@link uniqByIdentifier}.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const updateInPlace: UpdateMethod;
+declare const uniqByName: <T extends {
+  name: string;
+  value?: string;
+} | {
+  name?: string;
+  value: string;
+}>(originalArray: T[]) => T[];
 /**
- * Options for {@link remove}.
+ * Generates a new array of objects with duplicates removed based
+ * on the identifying property (`value` or `name`)
  *
- * @group Query Tools
+ * @group Option Lists
  */
-interface RemoveOptions extends AbortOptions {}
-interface RemoveMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, pathOrID: Path | string, options?: RemoveOptions): RG;
-}
+declare const uniqByIdentifier: <T extends RequireAtLeastOne$1<{
+  name: string;
+  value: string;
+}, "name" | "value">>(originalArray: T[]) => T[];
 /**
- * Removes a rule or group from a query without mutating the original query.
- *
- * @returns A new query with the rule or group removed.
+ * Determines if an {@link OptionList} is an {@link OptionGroup} array.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const remove: RemoveMethod;
+declare const isOptionGroupArray: (arr: unknown) => arr is OptionGroup<BaseOption>[];
 /**
- * Removes a rule or group from a query in place.
- *
- * @returns The query (mutated in place) with the rule or group removed.
+ * Determines if an array is a flat array of {@link FlexibleOption}.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const removeInPlace: RemoveMethod;
+declare const isFlexibleOptionArray: (arr: unknown) => arr is FlexibleOption[];
 /**
- * Options for {@link move}.
+ * Determines if an array is a flat array of {@link FullOption}.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-interface MoveOptions extends AbortOptions {
-  /**
-   * When `true`, the source rule/group will not be removed from its original path.
-   */
-  clone?: boolean;
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query is using independent
-   * combinators), then the first combinator in this list will be inserted before
-   * the rule/group if necessary.
-   */
-  combinators?: OptionList;
-  /**
-   * ID generator.
-   */
-  idGenerator?: () => string;
-}
-interface MoveMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, oldPathOrID: Path | string, newPath: Path | "up" | "down", options?: MoveOptions): RG;
-}
+declare const isFullOptionArray: (arr: unknown) => arr is FullOption[];
 /**
- * Moves a rule or group from one path to another without mutating the original query.
- * In the options parameter, pass `{ clone: true }` to copy instead of move.
- *
- * @returns A new query with the rule or group moved or cloned.
+ * Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const move: MoveMethod;
+declare const isFlexibleOptionGroupArray: (arr: unknown, { allowEmpty }?: {
+  allowEmpty?: boolean;
+}) => arr is FlexibleOptionGroup[];
 /**
- * Moves a rule or group from one path to another in place.
- * In the options parameter, pass `{ clone: true }` to copy instead of move.
- *
- * @returns The query (mutated in place) with the rule or group moved or cloned.
+ * Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const moveInPlace: MoveMethod;
+declare const isFullOptionGroupArray: (arr: unknown, { allowEmpty }?: {
+  allowEmpty?: boolean;
+}) => arr is OptionGroup<FullOption>[];
 /**
- * Options for {@link insert}.
+ * Gets the option from an {@link OptionList} with the given `name`. Handles
+ * {@link Option} arrays as well as {@link OptionGroup} arrays.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-interface InsertOptions extends AbortOptions {
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
-   * combinators), then the first combinator in this list will be inserted
-   * before the new rule/group if the parent group is not empty. This option
-   * is overridden by `combinatorPreceding`.
-   */
-  combinators?: OptionList;
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
-   * combinators), then this combinator will be inserted before the new rule/group
-   * if the parent group is not empty and the new rule/group is not the first in the
-   * group (`path.at(-1) > 0`). This option will supersede `combinators`.
-   */
-  combinatorPreceding?: string;
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
-   * combinators), then this combinator will be inserted after the new rule/group
-   * if the parent group is not empty and the new rule/group is the first in the
-   * group (`path.at(-1) === 0`). This option will supersede `combinators`.
-   */
-  combinatorSucceeding?: string;
-  /**
-   * ID generator.
-   *
-   * @default generateID
-   */
-  idGenerator?: () => string;
-  /**
-   * When `true`, the new rule/group will replace the rule/group at `path`.
-   */
-  replace?: boolean;
-}
-interface InsertMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, ruleOrGroup: RG | RuleType, path: number[], options?: InsertOptions): RG;
-}
+declare function getOption<OptType extends FullOption>(arr: FullOptionList<OptType>, name: string): OptType | undefined;
+declare function getOption<OptType extends ValueOption>(arr: FlexibleOptionList<OptType>, name: string): OptType | undefined;
+declare function getOption<OptType extends Option>(arr: FlexibleOptionList<OptType>, name: string): OptType | undefined;
 /**
- * Inserts a rule or group into a query without mutating the original query.
- *
- * @returns A new query with the rule or group inserted.
+ * Gets the first option from an {@link OptionList}.
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const insert: InsertMethod;
+declare function getFirstOption<Opt extends FullOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
+declare function getFirstOption<Opt extends ValueOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
+declare function getFirstOption<Opt extends Option>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
 /**
- * Inserts a rule or group into a query in place.
+ * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
+ * If the array is already flat, it is returned as is.
  *
- * @returns The query (mutated in place) with the rule or group inserted.
+ * @group Option Lists
+ */
+declare const toFlatOptionArray: <T extends FullOption>(arr: FullOptionList<T>) => T[];
+/**
+ * Generates a new {@link OptionGroup} array with duplicates
+ * removed based on the identifying property (`value` or `name`).
  *
- * @group Query Tools
+ * @group Option Lists
  */
-declare const insertInPlace: InsertMethod;
+declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptionGroup<T>[]) => OptionGroup<ToFullOption<T>>[];
 /**
- * Options for {@link group}.
+ * Generates a new {@link Option} or {@link OptionGroup} array with duplicates
+ * removed based on the identifier property (`value` or `name`).
  *
- * @group Query Tools
+ * @group Option Lists
  */
-interface GroupOptions extends AbortOptions {
-  /**
-   * When `true`, the source rule/group will not be removed from its original path.
-   */
-  clone?: boolean;
-  /**
-   * If the query extends `RuleGroupTypeIC` (i.e. the query is using independent
-   * combinators), then the first combinator in this list will be inserted between
-   * the two rules/groups.
-   */
-  combinators?: OptionList;
-  /**
-   * ID generator.
-   */
-  idGenerator?: () => string;
+declare const uniqOptList: <T extends BaseOption>(originalArray: FlexibleOptionList<T>) => WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[];
+/** Result of {@link prepareOptionList}. */
+interface PreparedOptionList<O extends FullOption> {
+  defaultOption: FullOption;
+  optionList: FullOptionList<O>;
+  optionsMap: Partial<FullOptionRecord<O>>;
 }
-interface GroupMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, sourcePathOrID: Path | string, targetPathOrID: Path | string, options?: GroupOptions): RG;
+/** Parameters for {@link prepareOptionList}. */
+interface PrepareOptionListParams<O extends FullOption> {
+  placeholder?: Placeholder;
+  optionList?: FlexibleOptionListProp<O> | BaseOptionMap<O>;
+  baseOption?: Record<string, unknown>;
+  labelMap?: Record<string, string>;
+  autoSelectOption?: boolean;
 }
 /**
- * Creates a new group at a target path with its `rules` array containing the current
- * objects at the target path and the source path without mutating the original query.
- * In the options parameter, pass `{ clone: true }` to copy the source rule/group instead of move.
+ * Normalizes any accepted option list shape—array, option groups, or a record—into a
+ * `FullOptionList`, applying `baseOption` properties and (when `autoSelectOption` is `false`)
+ * a leading placeholder option. Also returns the flattened lookup map and the option that
+ * should be selected by default.
  *
- * @returns A new query with the rules or groups grouped.
+ * Note: `labelMap` overrides only apply to array/option group input (where string options are
+ * expanded); record input derives labels from the record values themselves.
  *
- * @group Query Tools
+ * This is the same normalization `<QueryBuilder />` applies to `fields`, `operators`,
+ * `combinators`, and value lists, so a non-React implementation resolves options identically.
+ *
+ * @group Option Lists
  */
-declare const group: GroupMethod;
+declare const prepareOptionList: <O extends FullOption>(props: PrepareOptionListParams<O>) => PreparedOptionList<O>;
+//#endregion
+//#region src/utils/pathUtils.d.ts
 /**
- * Creates a new group at a target path with its `rules` array containing the current
- * objects at the target path and the source path in place.
- * In the options parameter, pass `{ clone: true }` to copy the source rule/group instead of move.
+ * Return type for {@link findPath}.
+ */
+type FindPathReturnType = RuleGroupTypeAny | RuleType | null;
+/**
+ * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
+ * at the given path within a query.
+ */
+declare const findPath: (path: Path, query: RuleGroupTypeAny) => FindPathReturnType;
+/**
+ * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
+ * with the given `id` within a query.
+ */
+declare const findID: (id: string, query: RuleGroupTypeAny) => FindPathReturnType;
+/**
+ * Returns the {@link Path} of the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
+ * with the given `id` within a query.
+ */
+declare const getPathOfID: (id: string, query: RuleGroupTypeAny) => Path | null;
+/**
+ * Truncates the last element of an array and returns the result as a new array.
+ */
+declare const getParentPath: (path: Path) => Path;
+/**
+ * Determines if two paths (each `Path`) are equivalent.
+ */
+declare const pathsAreEqual: (path1: Path, path2: Path) => boolean;
+/**
+ * Determines if the first path is an ancestor of the second path. The first path must
+ * be shorter and exactly match the second path up through the length of the first path.
+ */
+declare const isAncestor: (maybeAncestor: Path, path: Path) => boolean;
+/**
+ * Finds the deepest/longest path that two paths have in common.
+ */
+declare const getCommonAncestorPath: (path1: Path, path2: Path) => Path;
+/**
+ * Determines if the rule or group at the specified path is either disabled itself
+ * or disabled by an ancestor group.
+ */
+declare const pathIsDisabled: (path: Path, query: RuleGroupTypeAny) => boolean;
+/**
+ * Determines if the rule or group at the specified path is disabled by `disabledPaths`—the array
+ * form of the `QueryBuilder` `disabled` prop, which disables nodes by position rather than by a
+ * `disabled` property on the node itself. A path is disabled if it appears in `disabledPaths` or
+ * descends from a path that does.
  *
- * @returns The query (mutated in place) with the rules or groups grouped.
+ * @group Paths
+ */
+declare const pathIsDisabledByPaths: (path: Path, disabledPaths?: Path[]) => boolean;
+/** The path of a child rule or group, and whether it is disabled. */ interface PathInfo {
+  path: Path;
+  disabled: boolean;
+}
+/**
+ * Builds the {@link PathInfo} for each child of a group at `path`. A child is disabled if its
+ * parent is disabled or if its own path appears in `disabledPaths`.
  *
- * @group Query Tools
+ * @group Paths
  */
-declare const groupInPlace: GroupMethod;
+declare const derivePathInfo: (path: Path, childCount: number, { disabled, disabledPaths }?: {
+  disabled?: boolean;
+  disabledPaths?: Path[];
+}) => PathInfo[];
 //#endregion
 //#region src/utils/transformQuery.d.ts
 /**
@@ -5638,14 +5679,6 @@ declare function transformQuery(query: RuleGroupType, options?: TransformQueryOp
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
 //#region src/utils/QueryManager.d.ts
-/**
- * Abort reasons that {@link QueryManager}'s `strict` mode treats as errors. The remaining
- * reasons—`"same-location"` and `"no-change"`—describe valid operations that had nothing to do,
- * so they are reported to `onInvalidTarget` but never throw.
- *
- * @group Query Tools
- */
-declare const strictAbortReasons: readonly AbortReason[];
 /**
  * Thrown by {@link QueryManager} methods in `strict` mode when an operation cannot be carried
  * out because its target could not be used.
@@ -5678,6 +5711,27 @@ interface StrictOptions {
    */
   onInvalidTarget?: (info: AbortInfo) => void;
 }
+/**
+ * The `getDefaultField` option: either a field name or a function that picks one.
+ *
+ * Named separately from {@link QueryManagerOptions} so callers building the option value
+ * conditionally can annotate the intermediate. TypeScript cannot reconcile the two arms of a
+ * ternary against an inline union, which otherwise forces a cast.
+ *
+ * @group Query Tools
+ */
+type DefaultFieldProp<F extends FullField = FullField> = string | ((fieldsData: FullOptionList<F>) => string);
+/**
+ * The `getDefaultOperator` option: either an operator name or a function that picks one.
+ *
+ * Named separately from {@link QueryManagerOptions} for the same reason as
+ * {@link DefaultFieldProp}.
+ *
+ * @group Query Tools
+ */
+type DefaultOperatorProp<F extends FullField = FullField> = string | ((field: string, misc: {
+  fieldData: F;
+}) => string);
 /**
  * Options for {@link QueryManager}. Mirrors the subset of
  * {@link react-querybuilder!QueryBuilder QueryBuilder} props that affect query
@@ -5713,11 +5767,9 @@ interface QueryManagerOptions<F extends FullField = FullField, O extends FullOpe
    */
   translations?: Partial<BaseTranslations<unknown>>;
   /** The default `field` for rules created by {@link QueryManager.createRule}. */
-  getDefaultField?: string | ((fieldsData: FullOptionList<F>) => string);
+  getDefaultField?: DefaultFieldProp<F>;
   /** The default `operator` for a given field. */
-  getDefaultOperator?: string | ((field: string, misc: {
-    fieldData: F;
-  }) => string);
+  getDefaultOperator?: DefaultOperatorProp<F>;
   /** Overrides the computed default `value` for a new rule. */
   getDefaultValue?: (rule: RuleType, misc: {
     fieldData: F;
@@ -5809,6 +5861,19 @@ interface QueryManagerOptions<F extends FullField = FullField, O extends FullOpe
    * `"same-location"` and `"no-change"`. Can be overridden per call.
    */
   onInvalidTarget?: (info: AbortInfo) => void;
+  /**
+   * Deep-freeze everything the manager hands out—the query, the field list, the field map, and
+   * the combinator list—so accidental mutation throws in strict mode. Defaults to `true`.
+   *
+   * Pass `false` when the manager's output is handed to a framework that wraps objects in
+   * proxies (Vue `reactive`, Solid stores) or otherwise needs to mutate them. This also disables
+   * immer's auto-freeze for mutations made through the manager.
+   *
+   * The shallow copy returned by {@link QueryManager.getOptions} is frozen either way: it is a
+   * one-level copy that no framework proxy is placed inside, so freezing it costs nothing and
+   * still prevents callers from mutating the options snapshot they were handed.
+   */
+  freeze?: boolean;
   /** Validates the query. Defaults to {@link defaultValidator}. */
   validator?: QueryValidator;
   /** Generates `id` properties for new rules and groups. Defaults to {@link generateID}. */
@@ -5822,11 +5887,30 @@ interface QueryManagerOptions<F extends FullField = FullField, O extends FullOpe
   now?: () => number;
 }
 /**
- * A single rule or group encountered by {@link QueryManager.walk}, along with where it was found.
+ * What changed in the notification a {@link QueryManager.subscribe} listener is receiving.
+ *
+ * The two flags are independent, and at least one is always `true`. A single notification can
+ * report both: a {@link QueryManager.batch batch} containing a
+ * {@link QueryManager.reconfigure reconfigure} and a mutation emits one
+ * `{ query: true, config: true }`.
+ *
+ * Listeners that ignore their argument keep working exactly as before — this exists so that a
+ * framework adapter can skip the work a change does not affect (re-deriving option lists on a
+ * query-only change, say) without diffing the manager's output to find out.
  *
  * @group Query Tools
  */
-interface QueryNode<RG extends RuleGroupTypeAny = RuleGroupType> {
+interface SubscriptionChange {
+  /** The query was replaced. */
+  query: boolean;
+  /** Options were applied, so option lists and any derived configuration may have changed. */
+  config: boolean;
+}
+/**
+ * A single rule or group encountered by {@link QueryManager.walk}, along with where it was found.
+ *
+ * @group Query Tools
+ */ interface QueryNode<RG extends RuleGroupTypeAny = RuleGroupType> {
   /** The rule or group itself. */
   node: RG | RuleType;
   /** The {@link Path} of `node` within the query. The root group's path is `[]`. */
@@ -5863,7 +5947,8 @@ type AsRuleGroup<T> = T extends RuleGroupTypeAny ? T : RuleGroupTypeAny;
  * The query is held internally, so each method takes the same arguments as its `queryTools`
  * counterpart minus the leading `query` parameter, and returns the manager itself for chaining.
  * Mutations use the non-`InPlace` tools, so a query previously handed out by
- * {@link QueryManager.getQuery} is never modified.
+ * {@link QueryManager.getQuery} is never modified. Under `freeze: false` that remains true, but
+ * as a convention rather than a runtime-enforced guarantee.
  *
  * ```ts
  * const q = new QueryManager(undefined, { fields });
@@ -5879,11 +5964,96 @@ type AsRuleGroup<T> = T extends RuleGroupTypeAny ? T : RuleGroupTypeAny;
  * @group Query Tools
  */
 declare class QueryManager<RG extends RuleGroupTypeAny = RuleGroupType, F extends FullField = FullField, O extends FullOperator = FullOperator, C extends FullCombinator = FullCombinator> {
-  #private;
+  /**
+   * All instance state, rather than `#private` fields. See `kState` for why.
+   *
+   * The property itself is symbol-keyed and installed by the constructor; this accessor exists
+   * because `isolatedDeclarations` cannot emit a computed property name keyed by a symbol the
+   * module does not export, and exporting it would put it in the public API surface. A
+   * prototype accessor is proxy-safe for the same reason the own property is: `this` is the
+   * proxy, and the `get` trap forwards to the target.
+   */
+  private get state();
   constructor(query?: RG, options?: QueryManagerOptions<F, O, C>);
   /**
-   * The current query. The returned object is frozen and structurally shared, so it is safe to
-   * retain and compare by reference to detect changes.
+   * Deep-freezes `x` unless the `freeze` option is `false`. Every value the manager hands out
+   * directly goes through here; the shallow copies returned by {@link QueryManager.getOptions}
+   * and passed to `applyOptions` are frozen unconditionally instead.
+   */
+  private freeze;
+  /**
+   * Assigns `options` and every field derived from it. Shared by the constructor and
+   * {@link QueryManager.reconfigure}, so the two can never drift apart. Does not touch the
+   * query, the history stacks, the caches, or the subscriber list.
+   */
+  private applyOptions;
+  /** Resolves the field configuration for a field name. */
+  private fieldData;
+  /** Resolves the operator list for a field, mirroring `QueryBuilder`'s precedence. */
+  private operatorsFor;
+  /** Resolves the default operator for a field, mirroring `QueryBuilder`'s precedence. */
+  private defaultOperator;
+  private valueSourcesFor;
+  private matchModesFor;
+  private valuesFor;
+  private valueEditorTypeFor;
+  /** Computes the default `value` for a rule, mirroring `QueryBuilder`'s precedence. */
+  private defaultValue;
+  /**
+   * Resolves the parameter list for a field/operator pair, normalized the same way as every
+   * other option list. Shared by `defaultValue` and {@link QueryManager.getRuleContext} so both
+   * see the same shape.
+   */
+  private parametersFor;
+  /** Defaults shared by every mutating method, overridable per call. */
+  private guardOptions;
+  private toolOptions;
+  /**
+   * Builds the `onAbort` handler passed to the query tools, applying the per-call overrides on
+   * top of the manager's own options.
+   */
+  private onAbort;
+  /** Defaults for {@link update}, so resets mirror `QueryBuilder`'s behavior. */
+  private updateOptions;
+  /**
+   * Applies a new query, recording history and notifying subscribers as appropriate. Every
+   * mutation funnels through here. A tool that could not resolve its target returns the same
+   * query object, which is treated as a no-op.
+   */
+  private commit;
+  /**
+   * Records a change, either as a new history entry or by absorbing it into the current one.
+   * Mirrors the recording semantics of the `react-querybuilder/history` entry point.
+   */
+  private record;
+  private notify;
+  /**
+   * Records that a history-stack method ran inside the current batch. Those methods manage
+   * `past`/`future` themselves, so the batch must not also record an entry on completion —
+   * doing so would push a duplicate onto `past` and clear the redo stack that `undo` just
+   * populated.
+   */
+  private markHistoryBypassed;
+  /**
+   * Discards every cached derivation when the query has been replaced since they were computed.
+   * Called at the top of each cached reader.
+   */
+  private ensureCache;
+  /**
+   * The single traversal implementation. Combinator strings in independent-combinator groups
+   * are skipped.
+   *
+   * @yields The subtree rooted at `node`, depth-first in pre-order, starting with `node` itself.
+   */
+  private walkFrom;
+  /** Builds (once per query) the `id` to {@link Path} index backing `findID`/`getPathOfID`. */
+  private index;
+  /** Resolves a path or `id` to a path, or `null` when the `id` isn't present. */
+  private toPath;
+  /**
+   * The current query. The returned object is structurally shared, so it is safe to retain and
+   * compare by reference to detect changes. It is also frozen unless the `freeze` option is
+   * `false`.
    *
    * Like {@link QueryManager.subscribe}, this method is bound to the instance, so it can be
    * passed as a bare reference (e.g. as the `getSnapshot` argument to `useSyncExternalStore`).
@@ -5953,13 +6123,34 @@ declare class QueryManager<RG extends RuleGroupTypeAny = RuleGroupType, F extend
    * re-normalize.
    *
    * History options are honored immediately: lowering `maxHistory` trims the undo stack, and
-   * turning history off clears both stacks. Subscribers are notified once, and
-   * {@link QueryManager.getConfigVersion} is incremented, even inside a
-   * {@link QueryManager.batch batch} — configuration is not part of a batch's rollback.
+   * turning history off clears both stacks.
+   *
+   * A call that resolves to the configuration already in effect is a **no-op**: nothing is
+   * re-derived, {@link QueryManager.getConfigVersion} does not change, and subscribers are not
+   * notified. Equality is structural for data and by identity for functions
+   * ({@link optionsEqual}), so a caller that rebuilds its options object on every render — which
+   * every framework adapter does — does not force a reconfigure as long as the data is the same.
+   * Rebuilding a callback per render _does_ count as a change; memoize it to avoid that.
+   *
+   * Otherwise subscribers are notified once and `getConfigVersion` is incremented. Inside a
+   * {@link QueryManager.batch batch} the options are still applied immediately — configuration
+   * is not part of a batch's rollback — but the notification is deferred and merged into the
+   * batch's single notification.
    */
   reconfigure(options: Partial<QueryManagerOptions<F, O, C>>, config?: {
     replace?: boolean;
   }): this;
+  /**
+   * Brings the history stacks in line with the current history configuration. Unlike
+   * {@link QueryManager.clearHistory}, this does _not_ set `historyBypassed`: it reflects a
+   * configuration change rather than a deliberate history repositioning, so a later mutation in
+   * the same batch must still be recorded normally.
+   *
+   * Called by {@link QueryManager.reconfigure} and again after a failed
+   * {@link QueryManager.batch batch} restores its snapshot, since that snapshot predates the
+   * configuration change (configuration is not part of a batch's rollback).
+   */
+  private reconcileHistoryConfig;
   /**
    * A counter incremented by every {@link QueryManager.reconfigure} call. Because reconfiguring
    * leaves the query object untouched, subscribers that compare query identity alone cannot see
@@ -5997,8 +6188,12 @@ declare class QueryManager<RG extends RuleGroupTypeAny = RuleGroupType, F extend
    * ```
    *
    * In React, prefer the `useQueryManager` hook from `react-querybuilder`, which wraps this.
+   *
+   * The listener receives a {@link SubscriptionChange} describing what changed. It is optional:
+   * a zero-argument listener — including `useSyncExternalStore`'s `onStoreChange` — is still a
+   * valid listener and behaves as it always has.
    */
-  subscribe: (listener: () => void) => (() => void);
+  subscribe: (listener: (change: SubscriptionChange) => void) => (() => void);
   /**
    * Runs `fn`, deferring history recording and subscriber notification until it returns. The
    * whole batch becomes a single undo step and triggers a single notification, or neither if
@@ -6188,6 +6383,24 @@ declare class QueryManager<RG extends RuleGroupTypeAny = RuleGroupType, F extend
   getValues(field: string, operator: string): FullOptionList<Option>;
   /** The value editor type for a field/operator pair. */
   getValueEditorType(field: string, operator: string): ValueEditorType;
+  /**
+   * The default `operator` for a field, identical to the operator
+   * {@link QueryManager.createRule} would assign to a new rule on that field.
+   */
+  getRuleDefaultOperator(field: string): string;
+  /**
+   * The default `value` for a rule, identical to the value {@link QueryManager.createRule} and
+   * {@link QueryManager.update} would assign after a field or operator change.
+   */
+  getRuleDefaultValue(rule: RuleType): unknown;
+  /**
+   * The flattened field record backing {@link QueryManager.getFieldData}, keyed by field name
+   * with option groups flattened away.
+   *
+   * Treat the result as read-only. It may or may not be frozen depending on configuration, so
+   * do not rely on frozen-ness to prevent mutation.
+   */
+  getFieldMap(): Partial<FullOptionRecord<F>>;
   /**
    * Resolves everything about a rule that depends on the field/operator configuration—field data,
    * operators, value editor type, value list, value sources, match modes, and validation result.
@@ -6240,6 +6453,206 @@ declare class QueryManager<RG extends RuleGroupTypeAny = RuleGroupType, F extend
   transform<T = any>(options?: TransformQueryOptions<RG>): T;
 }
 //#endregion
+//#region src/utils/optionsEqual.d.ts
+/**
+ * Structural equality for {@link QueryManagerOptions} values. Arrays and plain objects are
+ * compared by value; everything else — functions, class instances, `Map`s, `Date`s — by
+ * identity.
+ *
+ * That split is what makes an options object rebuilt on every render compare equal as long as
+ * its _data_ did not change, which is the entire point: a caller that passes object literals
+ * (`fields={[...]}`, `translations={{...}}`) hands a fresh identity to every reconfigure, so an
+ * identity-only comparison would report a change every time.
+ *
+ * Comparing functions by identity is deliberate rather than a limitation. Two functions cannot
+ * be proven equivalent, so a caller that rebuilds `getDefaultValue` per render must either
+ * memoize it or accept the reconfigure.
+ */
+declare const valuesEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * Whether two {@link QueryManagerOptions} objects describe the same configuration, per
+ * {@link valuesEqual}: data by value, functions by identity.
+ *
+ * {@link QueryManager.reconfigure} uses this to gate itself, so most callers never need it
+ * directly. It is exported for framework adapters that decide whether to _call_ `reconfigure`
+ * at all — skipping the call avoids building the merged options object in the first place.
+ *
+ * Nested option objects (`history`, `translations`, …) are descended into rather than compared
+ * by identity, so `{ history: { maxHistory: 10 } }` rebuilt per render compares equal.
+ */
+declare const optionsEqual: <F extends FullField = FullField, O extends FullOperator = FullOperator, C extends FullCombinator = FullCombinator>(a: Partial<QueryManagerOptions<F, O, C>> | undefined, b: Partial<QueryManagerOptions<F, O, C>> | undefined) => boolean;
+//#endregion
+//#region src/utils/parseNumber.d.ts
+/**
+ * Options object for {@link parseNumber}.
+ */
+interface ParseNumberOptions {
+  parseNumbers?: ParseNumberMethod;
+  /**
+   * Generates a `bigint` value if the string represents a valid integer
+   * outside the safe boundaries of the `number` type.
+   */
+  bigIntOnOverflow?: boolean;
+}
+/**
+ * Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is "native",
+ * otherwise uses [`numeric-quantity`](https://jakeboone02.github.io/numeric-quantity/).
+ * If that returns `NaN`, the string is returned unchanged. Numeric values are returned
+ * as-is regardless of the `parseNumbers` option.
+ */
+declare const parseNumber: (val: unknown, { parseNumbers, bigIntOnOverflow }?: ParseNumberOptions) => any;
+//#endregion
+//#region src/utils/preferProp.d.ts
+/**
+ * For given default, prop, and context values, return the first provided of prop,
+ * context, and default, in that order.
+ */
+declare const preferProp: (def: boolean, prop?: boolean, context?: boolean, doNotFinalize?: boolean) => boolean;
+/**
+ * For given default, prop, and context values, return the first provided of prop,
+ * context, and default, in that order.
+ */
+declare const preferAnyProp: (def?: any, prop?: any, context?: any) => any;
+/**
+ * For a given set of defaults, props, and context values, return the first provided of prop,
+ * context, and default—in that order—for each property in the defaults object.
+ */
+declare const preferFlagProps: (props?: QueryBuilderFlags, contextVals?: QueryBuilderFlags, finalize?: boolean) => QueryBuilderFlags;
+//#endregion
+//#region src/utils/prepareQueryObjects.d.ts
+/**
+ * Options for {@link prepareRule}/{@link prepareRuleGroup}.
+ */
+interface PreparerOptions {
+  idGenerator?: () => string;
+}
+/**
+ * Ensures that a rule is valid by adding an `id` property if it does not already exist.
+ */
+declare const prepareRule: (rule: RuleType, { idGenerator }?: PreparerOptions) => RuleType;
+/**
+ * Ensures that a rule group is valid by recursively adding an `id` property to the group itself
+ * and all its rules and subgroups where one does not already exist.
+ */
+declare const prepareRuleGroup: <RG extends RuleGroupTypeAny>(queryObject: RG, { idGenerator }?: PreparerOptions) => RG;
+/**
+ * Ensures that a rule or group is valid. See {@link prepareRule} and {@link prepareRuleGroup}.
+ */
+declare const prepareRuleOrGroup: (rg: RuleGroupTypeAny | RuleType, { idGenerator }?: PreparerOptions) => RuleGroupType | RuleGroupTypeIC | RuleType;
+/**
+ * Resolves the query a query builder should render from the available sources, in precedence
+ * order: the controlled `query`, then whatever is already in the store, then the uncontrolled
+ * `defaultQuery`, then a freshly created empty group.
+ *
+ * The result is prepared with {@link prepareRuleGroup} unless it already has an `id`, which is
+ * taken to mean it has been prepared before—most often because the caller is passing back the
+ * object it received from `onQueryChange`.
+ *
+ * @group Query Tools
+ */
+declare const resolveCandidateQuery: <RG extends RuleGroupTypeAny>(sources: {
+  query?: RG;
+  storeQuery?: RG;
+  defaultQuery?: RG;
+  fallbackQuery: RG;
+}, options?: {
+  idGenerator?: () => string;
+}) => RG;
+//#endregion
+//#region src/utils/queryActions.d.ts
+/**
+ * Confirmation callbacks invoked before a mutation is applied. Their return values are
+ * interpreted differently depending on the operation:
+ *
+ * - `onAddRule`/`onAddGroup` may return `true` to proceed, a falsy value to cancel, or a
+ *   _replacement rule/group_ to add instead of the one provided.
+ * - `onMoveRule`/`onMoveGroup`/`onGroupRule`/`onGroupGroup` may return `true` to proceed, a
+ *   falsy value to cancel, or a _replacement query_ to apply instead of the computed one.
+ * - `onRemove` is boolean only.
+ *
+ * @group Query Tools
+ */
+interface QueryActionCallbacks {
+  onAddRule?: (rule: RuleType, parentPath: Path, query: any, context?: any) => RuleType | boolean;
+  onAddGroup?: (ruleGroup: any, parentPath: Path, query: any, context?: any) => RuleGroupTypeAny | boolean;
+  onRemove?: (ruleOrGroup: any, path: Path, query: any, context?: any) => boolean;
+  onMoveRule?: (...args: any[]) => RuleGroupTypeAny | boolean;
+  onMoveGroup?: (...args: any[]) => RuleGroupTypeAny | boolean;
+  onGroupRule?: (...args: any[]) => RuleGroupTypeAny | boolean;
+  onGroupGroup?: (...args: any[]) => RuleGroupTypeAny | boolean;
+}
+/**
+ * Configuration for {@link createQueryActions}.
+ *
+ * @group Query Tools
+ */
+interface QueryActionsConfig extends QueryActionCallbacks {
+  /** Identifier included in every log payload. */
+  qbId?: string;
+  combinators?: OptionList;
+  idGenerator?: () => string;
+  /** The maximum depth at which groups may be added. Defaults to `Infinity`. */
+  maxLevels?: number;
+  /** Abort every mutation, as though the entire query were disabled. */
+  queryDisabled?: boolean;
+  /**
+   * Honor `disabled` properties within the query. Defaults to `true`, matching the
+   * `QueryBuilder` component; a node's own `disabled` property can always be changed.
+   */
+  respectDisabled?: boolean;
+  /**
+   * Paths disabled by position rather than by a `disabled` property on the node itself, mirroring
+   * the array form of the `QueryBuilder` `disabled` prop. Honored only when `respectDisabled` is
+   * `true`; as with the `disabled` property, a node's own `disabled` can always be changed.
+   */
+  disabledPaths?: Path[];
+  resetOnFieldChange?: boolean;
+  resetOnOperatorChange?: boolean;
+  getRuleDefaultOperator?: (field: string) => string;
+  getValueSources?: (field: string, operator: string) => ValueSourceFullOptions;
+  getRuleDefaultValue?: (rule: RuleType) => any;
+  getMatchModes?: (field: string) => MatchModeOptions;
+  /**
+   * Set `false` to skip immer's auto-freeze on the queries these handlers return, matching the
+   * option of the same name on the query tools and {@link QueryManager}.
+   *
+   * Deep-freezing throws on the reactive proxies used by signals-based frameworks (Svelte
+   * `$state`, Vue `reactive`), so an adapter whose storage may hand a proxied query to these
+   * handlers has to turn it off.
+   *
+   * @default true
+   */
+  freeze?: boolean;
+  /** Receives a structured event for every action, applied or aborted. */
+  onLog?: (payload: Record<string, any>) => void;
+}
+/**
+ * The six mutations a query builder performs. Each takes the current query and returns the next
+ * one, or `undefined` when the mutation was aborted—because the target is disabled, a
+ * confirmation callback declined, or a depth limit was reached.
+ *
+ * @group Query Tools
+ */
+interface QueryActionHandlers {
+  addRule: (query: any, rule: RuleType, parentPath: Path, context?: any) => any;
+  addGroup: (query: any, ruleGroup: any, parentPath: Path, context?: any) => any;
+  propChange: (query: any, prop: UpdateableProperties, value: any, path: Path) => any;
+  removeRuleOrGroup: (query: any, path: Path, context?: any) => any;
+  moveRule: (query: any, oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any) => any;
+  groupRule: (query: any, sourcePath: Path, targetPath: Path, clone?: boolean, context?: any) => any;
+}
+/**
+ * Builds the query builder's six mutation handlers as pure functions of the current query.
+ *
+ * This is the framework-agnostic core of the action handlers in `useQueryBuilderSchema`. It owns
+ * the policy that surrounds the query tools—disabled gating, the confirmation callback protocol,
+ * `maxLevels`, and debug logging—so an implementation only has to supply its own storage: read
+ * the current query, call the action, and apply a non-`undefined` result.
+ *
+ * @group Query Tools
+ */
+declare const createQueryActions: (config?: QueryActionsConfig) => QueryActionHandlers;
+//#endregion
 //#region src/utils/regenerateIDs.d.ts
 /**
  * Options object for {@link regenerateID}/{@link regenerateIDs}.
@@ -6344,5 +6757,5 @@ declare const unchangedSignature = "";
  */
 declare const signatureOf: (prev: RuleGroupTypeAny, next: RuleGroupTypeAny) => string;
 //#endregion
-export { AbortInfo, AbortOptions, AbortReason, AccessibleDescriptionGenerator, ActionElementEventHandler, AddMethod, AddOptions, Arity, BaseFullOption, BaseOption, BaseOptionMap, BaseTranslation, BaseTranslationWithLabel, BaseTranslationWithPlaceholders, BaseTranslations, BaseTranslationsFull, Classname, ClassnameCondition, ClassnameSpec, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, CreateRuleGroupOptions, CreateRuleOptions, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DeriveClassNamesOptions, DiagnosticEntry, DiagnosticsFieldSummaryEntry, DiagnosticsResult, DiagnosticsStats, DndClassNameState, DndDropTargetType, DragCollection, DraggedItem, DrizzleOperatorsLike, DrizzleWhereCallback, DropCollection, DropEffect, DropResult, ExportFormat, ExportObjectFormats, ExportOperatorMap, ExpressionNode, Field, FieldByValue, FindPathReturnType, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleDefaultValueOptions, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GroupMethod, GroupOptions, GroupVariantCondition, GuardOptions, InputType, InsertMethod, InsertOptions, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, LogType, MatchConfig, MatchMode, MatchModeOptions, MoveMethod, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Operator, OperatorByValue, Option, OptionGroup, OptionList, OuterClassNameOptions, OuterClassNameOptionsBase, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, PathInfo, Placeholder, PrepareOptionListParams, PreparedOptionList, PreparerOptions, QueryActionCallbacks, QueryActionHandlers, QueryActions, QueryActionsConfig, QueryBuilderClassNameState, QueryBuilderFlags, QueryHistoryOptions, QueryManager, QueryManagerError, QueryManagerOptions, QueryNode, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveMethod, RemoveNullability, RemoveOptions, ResolveOptionListOptions, RuleClassNameState, RuleClassnameKey, RuleContext, RuleContextResolvers, RuleDiagnosticsResult, RuleFacet, RuleGroupArray, RuleGroupClassnameKey, RuleGroupContext, RuleGroupDiagnosticsArray, RuleGroupDiagnosticsResult, RuleGroupICArray, RuleGroupICDiagnosticsArray, RuleGroupICDiagnosticsResult, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, SequelizeWhereOptionsLike, StrictOptions, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, TestID, ToFlexibleOption, ToFullOption, ToRuleGroupType, ToRuleGroupTypeIC, TransformQueryOptions, UpdateMethod, UpdateOptions, UpdateValueMap, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WalkOptions, WithRequired, WithUnknownIndex, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, coerceBigIntValue, coerceInputType, convertFromIC, convertQuery, convertToIC, createQueryActions, createRule, createRuleGroup, cypherCombinatorMap, defaultCELValueProcessor, defaultCoalesceMs, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMaxHistory, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, derivePathInfo, deriveQueryBuilderClassNames, deriveRuleClassName, deriveRuleClassNames, deriveRuleContext, deriveRuleGroupClassNames, deriveRuleGroupContext, deriveRuleGroupOuterClassName, deriveRuleOuterClassName, exceedsMaxLevels, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFieldData, getFirstOption, getGuardAbortReason, getLikeWildcards, getMatchModesUtil, getMultiValueUpdate, getNLTranslataion, getOption, getParametersAsList, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue$1 as getRuleDefaultValue, getRuleGroupCombinator, getRuleInputType, getRuleValidationResult, getRuleValueEditorType, getRuleValueSourceOptions, getRuleValues, getSQLConcat, getSubqueryElementAlias, getValidationClassNames, getValueEditorReset, getValueSelectorUpdate, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, hideValueControlsForOperator, inOperators, insert, insertInPlace, isAncestor, isBetweenOperator, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, normalizeValueSelectorValue, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathIsDisabledByPaths, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, resolveCandidateQuery, resolveDefaultOperator, resolveOperatorList, resolveValueEditorType, resolveValueList, rootPath, shouldRenderAsNumber, signatureOf, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, strictAbortReasons, stripParamPrefix, structuralSignature, subqueryElementAliasBase, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, unchangedSignature, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, withParamPrefix, wrapLikeFragment };
+export { AbortInfo, AbortOptions, AbortReason, AccessibleDescriptionGenerator, ActionElementEventHandler, AddMethod, AddOptions, Arity, BaseFullOption, BaseOption, BaseOptionMap, BaseTranslation, BaseTranslationWithLabel, BaseTranslationWithPlaceholders, BaseTranslations, BaseTranslationsFull, Classname, ClassnameCondition, ClassnameSpec, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, ControlKey, CreateRuleGroupOptions, CreateRuleOptions, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultFieldProp, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperatorProp, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DeriveClassNamesOptions, DiagnosticEntry, DiagnosticsFieldSummaryEntry, DiagnosticsResult, DiagnosticsStats, DndClassNameState, DndDropTargetType, DragCollection, DraggedItem, DrizzleOperatorsLike, DrizzleWhereCallback, DropCollection, DropEffect, DropResult, ExportFormat, ExportObjectFormats, ExportOperatorMap, ExpressionNode, Field, FieldByValue, FindPathReturnType, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleDefaultValueOptions, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GroupMethod, GroupOptions, GroupVariantCondition, GuardOptions, InputType, InsertMethod, InsertOptions, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, LogType, MatchConfig, MatchMode, MatchModeOptions, MoveMethod, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Operator, OperatorByValue, Option, OptionGroup, OptionList, OuterClassNameOptions, OuterClassNameOptionsBase, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, PathInfo, Placeholder, PrepareOptionListParams, PreparedOptionList, PreparerOptions, QueryActionCallbacks, QueryActionHandlers, QueryActions, QueryActionsConfig, QueryBuilderClassNameState, QueryBuilderFlags, QueryHistoryOptions, QueryManager, QueryManagerError, QueryManagerOptions, QueryNode, QueryToolOptions, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveMethod, RemoveNullability, RemoveOptions, ResolveOptionListOptions, RuleClassNameState, RuleClassnameKey, RuleContext, RuleContextResolvers, RuleDiagnosticsResult, RuleFacet, RuleGroupArray, RuleGroupClassnameKey, RuleGroupContext, RuleGroupDiagnosticsArray, RuleGroupDiagnosticsResult, RuleGroupICArray, RuleGroupICDiagnosticsArray, RuleGroupICDiagnosticsResult, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, SequelizeWhereOptionsLike, StrictOptions, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, SubscriptionChange, TestID, ToFlexibleOption, ToFullOption, ToRuleGroupType, ToRuleGroupTypeIC, TransformQueryOptions, UpdateMethod, UpdateOptions, UpdateValueMap, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WalkOptions, WithRequired, WithUnknownIndex, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, coerceBigIntValue, coerceInputType, controlKeys, controlKind, controlPropKeys, convertFromIC, convertQuery, convertToIC, createQueryActions, createRule, createRuleGroup, cypherCombinatorMap, defaultCELValueProcessor, defaultCoalesceMs, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMaxHistory, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, derivePathInfo, deriveQueryBuilderClassNames, deriveRuleClassName, deriveRuleClassNames, deriveRuleContext, deriveRuleGroupClassNames, deriveRuleGroupContext, deriveRuleGroupOuterClassName, deriveRuleOuterClassName, exceedsMaxLevels, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFieldData, getFirstOption, getGuardAbortReason, getLikeWildcards, getMatchModesUtil, getMultiValueUpdate, getNLTranslataion, getOption, getParametersAsList, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue$1 as getRuleDefaultValue, getRuleGroupCombinator, getRuleInputType, getRuleValidationResult, getRuleValueEditorType, getRuleValueSourceOptions, getRuleValues, getSQLConcat, getSubqueryElementAlias, getValidationClassNames, getValueEditorReset, getValueSelectorUpdate, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, hideValueControlsForOperator, inOperators, insert, insertInPlace, isAncestor, isBetweenOperator, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, normalizeValueSelectorValue, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, optionsEqual, parseNumber, pathIsDisabled, pathIsDisabledByPaths, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, resolveCandidateQuery, resolveDefaultOperator, resolveOperatorList, resolveValueEditorType, resolveValueList, rootPath, setAutoFreeze, shouldCoalesce, shouldRenderAsNumber, signatureOf, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, strictAbortReasons, stripParamPrefix, structuralSignature, subqueryElementAliasBase, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, unchangedSignature, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, valuesEqual, withParamPrefix, wrapLikeFragment };
 //# sourceMappingURL=react-querybuilder_core.production.d.mts.map