@react-querybuilder/core 8.22.4 → 8.23.0

package/dist/react-querybuilder_core.d.mts

@@ -1,7 +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";
-import { Column, Operators, SQL, Table } from "drizzle-orm";
-import { WhereOptions } from "sequelize";
-import { eq } from "@tanstack/db";
+//#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).
@@ -3198,2298 +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.
- *
- * The React `useValueEditor` hook applies the result in an effect; other implementations may
- * apply it wherever is idiomatic.
- *
- * @group Value Editors
- */
-declare const getValueEditorReset: ({ skipHook, type, operator, value, inputType }: {
-  skipHook?: boolean;
-  type?: string;
-  operator: string;
-  value: unknown;
-  inputType?: InputType | null;
-}) => {
-  reset: boolean;
-  value: unknown;
-};
+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;
+}
 /**
- * Produces the next value for a series of value editors when the editor at `index` changes.
+ * Inserts a rule or group into a query without mutating the original query.
  *
- * 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 A new query 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 insert: 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).
+ * Inserts a rule or group into a query in place.
  *
- * @group Value Editors
- */
-declare const coerceBigIntValue: (value: unknown, parseNumberMethod?: ParseNumberMethod) => unknown;
-/**
- * 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.
+ * @returns The query (mutated in place) with the rule or group inserted.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const coerceInputType: (inputType: InputType | null | undefined, operator: string) => InputType;
+declare const insertInPlace: InsertMethod;
 /**
- * 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.
+ * Options for {@link group}.
  *
- * @group Value Editors
+ * @group Query Tools
  */
-declare const getValueSelectorUpdate: (value: string | string[], { multiple, listsAsArrays }?: {
-  multiple?: boolean;
-  listsAsArrays?: boolean;
-}) => string | string[];
+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;
+}
 /**
- * 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 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 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.
+ * @returns A new query with the rules or groups grouped.
  *
- * @group Option Lists
+ * @group Query Tools
  */
-declare const filterFieldsByComparator: (field: FullField, fields: OptionList<FullField>, operator: string) => FullField[] | {
-  options: WithUnknownIndex<FullField>[];
-  label: string;
-}[];
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
+declare const group: GroupMethod;
 /**
- * Default rule processor used by {@link formatQuery} for "cel" format.
+ * 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 Export
+ * @returns The query (mutated in place) with the rules or groups grouped.
+ *
+ * @group Query Tools
  */
-declare const defaultRuleProcessorCEL: RuleProcessor;
+declare const groupInPlace: GroupMethod;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorMongoDB.d.ts
+//#region src/utils/abortReasons.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "mongodb" format.
+ * 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.
  *
- * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
+ * Declared apart from `QueryManager` so the `@react-querybuilder/core/derivations` entry point can
+ * export it without putting the manager in its module graph.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleProcessorMongoDB: RuleProcessor;
+declare const strictAbortReasons: readonly AbortReason[];
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSpEL.d.ts
+//#region src/utils/arrayUtils.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "spel" 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 defaultRuleProcessorSpEL: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultValueProcessorByRule.d.ts
+declare const splitBy: (str?: string, splitChar?: string) => string[];
 /**
- * Default value processor used by {@link formatQuery} for "sql" 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}.
  *
- * @group Export
+ * 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.
+ *
+ * @example
+ * joinWith(['this,,that', '', 'the other', '', '', ','], ', ')
+ * // would return
+ * 'this\\,\\,that, , the other, , , \\,'
  */
-declare const defaultValueProcessorByRule: ValueProcessorByRule;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.d.ts
+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;
 /**
- * Rule group processor used by {@link formatQuery} for "cel" format.
- *
- * @group Export
+ * Trims the value if it is a string. Otherwise returns the value as is.
  */
-declare const defaultRuleGroupProcessorCEL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.d.ts
+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[];
 /**
- * Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
- *
- * @group Export
+ * Splits a string by comma then trims each element. Arrays are returned as is except
+ * any string elements are trimmed.
  */
-declare const cypherCombinatorMap: {
-  and: "AND";
-  or: "OR";
-};
+declare const toArray: <T>(a: T, { retainEmptyStrings }?: {
+  retainEmptyStrings?: boolean;
+}) => ToArrayResult<T>;
 /**
- * Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
- *
- * @group Export
+ * Determines if an array is free of `null`/`undefined`.
  */
-declare const defaultRuleGroupProcessorCypher: RuleGroupProcessor<string>;
+declare const nullFreeArray: <T>(arr: T[]) => arr is Exclude<T, null>[];
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorDrizzle.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 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.
+ * 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.
  *
- * @example
- * const where = formatQuery(query, 'drizzle');
- * const results = db.query.users.findMany({ where });
+ * 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
  *
- * @returns Function that takes a Drizzle table config and an object of Drizzle operators.
+ * 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.
  *
- * @group Export
+ * @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 defaultRuleGroupProcessorDrizzle: RuleGroupProcessor<(columns: Record<string, Column> | Table, drizzleOperators: Operators) => SQL | undefined>;
+declare const shouldCoalesce: (prevSig: string | undefined, nextSig: string, prevAt: number, now: number, coalesceMs?: number) => boolean;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorElasticSearch.d.ts
+//#region src/utils/convertQuery.d.ts
 /**
- * Rule group processor used by {@link formatQuery} for "elasticsearch" 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 defaultRuleGroupProcessorElasticSearch: RuleGroupProcessor<Record<string, unknown>>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.d.ts
+declare const convertFromIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupType<RG>;
 /**
- * Rule group processor used by {@link formatQuery} for "gremlin" format.
+ * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.
  *
- * At the top level, filter rules produce chained `.has()` steps (implicit AND).
- * Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
- * `__` anonymous traversal prefixes.
+ * This function is idempotent: {@link RuleGroupTypeIC} queries will be
+ * returned as-is.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorGremlin: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.d.ts
+declare const convertToIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupTypeIC<RG>;
 /**
- * Rule group processor used by {@link formatQuery} for "jsonata" format.
+ * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit
+ * operation, use {@link convertToIC}.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorJSONata: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorJsonLogic.d.ts
+declare function convertQuery(query: RuleGroupType): RuleGroupTypeIC;
 /**
- * Rule group processor used by {@link formatQuery} for "jsonlogic" format.
+ * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit
+ * operation, use {@link convertFromIC}.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorJsonLogic: RuleGroupProcessor<RQBJsonLogic>;
+declare function convertQuery(query: RuleGroupTypeIC): RuleGroupType;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorLDAP.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;
 /**
- * Rule group processor used by {@link formatQuery} for "ldap" format.
+ * 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.
  */
-declare const defaultRuleGroupProcessorLDAP: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDB.d.ts
+interface ClassnameCondition<S> {
+  key: StandardClassnameKey;
+  when: (state: S) => boolean | undefined;
+  standardOnly?: boolean;
+}
 /**
- * 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
+ * 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.
  */
-declare const defaultRuleGroupProcessorMongoDB: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDBQuery.d.ts
+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 fallback object used by {@link formatQuery} for "mongodb_query" format.
+ * 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 mongoDbFallback: {
-  readonly $and: readonly [{
-    readonly $expr: true;
-  }];
-};
+declare const deriveRuleClassNames: (options: DeriveClassNamesOptions) => Record<RuleClassnameKey, string>;
 /**
- * Rule group processor used by {@link formatQuery} for "mongodb_query" 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 defaultRuleGroupProcessorMongoDBQuery: RuleGroupProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorNL.d.ts
+declare const deriveRuleClassName: (key: RuleClassnameKey, options: DeriveClassNamesOptions) => string;
 /**
- * Rule group processor used by {@link formatQuery} for "natural_language" format.
+ * 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 defaultRuleGroupProcessorNL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorParameterized.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 "parameterized" and
- * "parameterized_named" formats.
+ * The outer (wrapper) classname for a rule, including every conditional state class.
  *
- * @group Export
+ * @group Query Tools
  */
-declare const defaultRuleGroupProcessorParameterized: RuleGroupProcessor<ParameterizedSQL | ParameterizedNamedSQL>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorPrisma.d.ts
+declare const deriveRuleOuterClassName: (options: OuterClassNameOptions) => string;
 /**
- * Default fallback object used by {@link formatQuery} for "prisma" 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 prismaFallback: {};
+declare const deriveRuleGroupOuterClassName: (options: OuterClassNameOptions) => string;
 /**
- * Rule group processor used by {@link formatQuery} for "prisma" 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 defaultRuleGroupProcessorPrisma: RuleGroupProcessor<Record<string, unknown> | undefined>;
+declare const deriveQueryBuilderClassNames: (options: OuterClassNameOptionsBase & QueryBuilderClassNameState) => string;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSequelize.d.ts
+//#region src/utils/defaultValidator.d.ts
 /**
- * Rule group processor used by {@link formatQuery} for "sequelize" 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 defaultRuleGroupProcessorSequelize: RuleGroupProcessor<WhereOptions | undefined>;
+declare const defaultValidator: QueryValidator;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.d.ts
+//#region src/utils/deriveRuleContext.d.ts
 /**
- * Rule group processor used by {@link formatQuery} for "sparql" format.
- *
- * SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
- *
- * @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 defaultRuleGroupProcessorSPARQL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSpEL.d.ts
+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>;
+}
 /**
- * Default rule processor used by {@link formatQuery} for "spel" format.
- *
- * @group Export
+ * Everything {@link deriveRuleContext} resolves for a single rule.
  */
-declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.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>;
+}
 /**
- * Default rule processor used by {@link formatQuery} for "sql" 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 defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
-//#endregion
-//#region src/utils/formatQuery/tanStackDbTypes.d.ts
-type TanStackDbWhereCallbackReturnType = ReturnType<typeof eq>;
-type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
+declare const getFieldData: (field: string, fieldMap: Partial<FullOptionRecord<FullField>>) => FullField;
 /**
- * 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
+ * The input type for a rule. A field's own `inputType` takes precedence over `getInputType`.
  */
-declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
+declare const getRuleInputType: <F extends FullField = FullField>(field: string, operator: string, fieldData: F, getInputType: RuleContextResolvers<F>["getInputType"]) => InputType | null;
 /**
- * Rule group processor used by {@link formatQuery} for "diagnostics" 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
+ * Whether the value editor(s) should be hidden for an operator, based on its `arity`.
  */
-declare const defaultRuleGroupProcessorDiagnostics: RuleGroupProcessor<DiagnosticsResult>;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorCypher.d.ts
+declare const hideValueControlsForOperator: (operatorObject?: FullOperator) => boolean;
 /**
- * Default rule processor used by {@link formatQuery} for "cypher" and "gql" formats.
- *
- * @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 defaultRuleProcessorCypher: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorDrizzle.d.ts
+type RuleFacet = Pick<RuleType, "field" | "operator" | "valueSource">;
 /**
- * Default rule processor used by {@link formatQuery} for the "drizzle" format.
+ * 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`.
+ */
+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.
  *
- * @group Export
+ * 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 Query Tools
  */
-declare const defaultRuleProcessorDrizzle: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.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 "elasticsearch" 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 defaultRuleProcessorElasticSearch: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorGremlin.d.ts
+declare const getRuleGroupCombinator: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>) => string;
 /**
- * Default rule processor used by {@link formatQuery} for "gremlin" format.
+ * Resolves everything about a rule group that depends on the combinator configuration, plus its
+ * validation result.
  *
- * Each rule becomes a `.has()` step (or `.hasNot()`/`.has()` for null checks).
+ * 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 Export
+ * @group Query Tools
  */
-declare const defaultRuleProcessorGremlin: RuleProcessor;
+declare const deriveRuleGroupContext: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>, options?: {
+  validationMap?: ValidationMap;
+  id?: string;
+}) => RuleGroupContext<C>;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorJSONata.d.ts
+//#region src/utils/deriveValueEditor.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "jsonata" format.
+ * Whether an operator's value is a list of two bounds.
  *
- * @group Export
+ * @group Value Editors
  */
-declare const defaultRuleProcessorJSONata: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorJsonLogic.d.ts
+declare const isBetweenOperator: (operator: string) => boolean;
 /**
- * Default rule processor used by {@link formatQuery} for "jsonlogic" format.
+ * 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.
  *
- * @group Export
+ * 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.
+ *
+ * The React `useValueEditor` hook applies the result in an effect; other implementations may
+ * apply it wherever is idiomatic.
+ *
+ * @group Value Editors
  */
-declare const defaultRuleProcessorJsonLogic: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorLDAP.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;
+};
 /**
- * Default rule processor used by {@link formatQuery} for "ldap" format.
+ * Produces the next value for a series of value editors when the editor at `index` changes.
  *
- * @group Export
+ * 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 Value Editors
  */
-declare const defaultRuleProcessorLDAP: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorMongoDBQuery.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 "mongodb_query" format.
+ * 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 defaultRuleProcessorMongoDBQuery: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorNL.d.ts
+declare const coerceBigIntValue: (value: unknown, parseNumberMethod?: ParseNumberMethod) => unknown;
 /**
- * Default operator map used by {@link formatQuery} for "natural_language" 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 defaultExportOperatorMap: ExportOperatorMap;
+declare const coerceInputType: (inputType: InputType | null | undefined, operator: string) => InputType;
 /**
- * Default operator processor used by {@link formatQuery} for "natural_language" 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 defaultOperatorProcessorNL: RuleProcessor;
+declare const getValueSelectorUpdate: (value: string | string[], { multiple, listsAsArrays }?: {
+  multiple?: boolean;
+  listsAsArrays?: boolean;
+}) => string | string[];
 /**
- * Default rule processor used by {@link formatQuery} for "natural_language" 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"]`).
  *
- * @group Export
+ * @group Value Editors
  */
-declare const defaultRuleProcessorNL: RuleProcessor;
+declare const normalizeValueSelectorValue: (value: unknown, multiple?: boolean) => any;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorParameterized.d.ts
+//#region src/utils/filterFieldsByComparator.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "parameterized" and
- * "parameterized_named" formats.
+ * 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 defaultRuleProcessorParameterized: RuleProcessor;
+declare const filterFieldsByComparator: (field: FullField, fields: OptionList<FullField>, operator: string) => FullField[] | {
+  options: WithUnknownIndex<FullField>[];
+  label: string;
+}[];
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorPrisma.d.ts
+//#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "prisma" format.
+ * Default rule processor used by {@link formatQuery} for "cel" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorPrisma: RuleProcessor;
+declare const defaultRuleProcessorCEL: RuleProcessor;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSequelize.d.ts
+//#region src/utils/formatQuery/defaultRuleProcessorMongoDB.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for the "sequelize" 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 defaultRuleProcessorSequelize: RuleProcessor;
+declare const defaultRuleProcessorMongoDB: 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.
+//#region src/utils/formatQuery/defaultRuleProcessorSpEL.d.ts
+/**
+ * Default rule processor used by {@link formatQuery} for "spel" format.
  *
  * @group Export
  */
-declare const sparqlVar: (name: string) => string;
+declare const defaultRuleProcessorSpEL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultValueProcessorByRule.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "sparql" format.
+ * Default value processor used by {@link formatQuery} for "sql" format.
  *
  * @group Export
  */
-declare const defaultRuleProcessorSPARQL: RuleProcessor;
+declare const defaultValueProcessorByRule: ValueProcessorByRule;
 //#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorSQL.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.d.ts
 /**
- * Default operator processor used by {@link formatQuery} for "sql" and "parameterized*" formats.
+ * Rule group processor used by {@link formatQuery} for "cel" format.
  *
  * @group Export
  */
-declare const defaultOperatorProcessorSQL: RuleProcessor;
+declare const defaultRuleGroupProcessorCEL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.d.ts
 /**
- * Default rule processor used by {@link formatQuery} for "sql" format.
+ * Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
  *
  * @group Export
  */
-declare const defaultRuleProcessorSQL: RuleProcessor;
-//#endregion
-//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
+declare const cypherCombinatorMap: {
+  and: "AND";
+  or: "OR";
+};
 /**
- * Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
+ * Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
  *
  * @group Export
  */
-declare const defaultRuleProcessorTanStackDB: RuleProcessor;
+declare const defaultRuleGroupProcessorCypher: RuleGroupProcessor<string>;
 //#endregion
-//#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorDrizzle.d.ts
 /**
- * Default value processor used by {@link formatQuery} for "natural_language" format.
+ * 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 defaultValueProcessorNL: ValueProcessorByRule;
-//#endregion
-//#region src/utils/formatQuery/formatQuery.d.ts
+interface DrizzleOperatorsLike {
+  and: (...conditions: any[]) => any;
+  or: (...conditions: any[]) => any;
+  not: (...conditions: any[]) => any;
+}
 /**
- * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
+ * 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 sqlDialectPresets: Record<SQLPreset, FormatQueryOptions>;
+type DrizzleWhereCallback = <Ops extends DrizzleOperatorsLike>(columns: object, drizzleOperators: Ops) => ReturnType<Ops["and"]>;
 /**
- * A collection of option presets for {@link formatQuery}.
+ * 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.
  *
  * @group Export
  */
-declare const formatQueryOptionPresets: Record<string, FormatQueryOptions>;
+declare const defaultRuleGroupProcessorDrizzle: RuleGroupProcessor<DrizzleWhereCallback>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorElasticSearch.d.ts
 /**
- * Generates a formatted (indented two spaces) JSON string from a query object.
+ * Rule group processor used by {@link formatQuery} for "elasticsearch" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny): string;
+declare const defaultRuleGroupProcessorElasticSearch: RuleGroupProcessor<Record<string, unknown>>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.d.ts
 /**
- * Generates a result based on the provided rule group processor.
+ * 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 function formatQuery<TResult = unknown>(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
-  ruleGroupProcessor: RuleGroupProcessor<TResult>;
-}): TResult;
+declare const defaultRuleGroupProcessorGremlin: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.d.ts
 /**
- * Generates a {@link index!ParameterizedSQL ParameterizedSQL} object from a query object.
+ * Rule group processor used by {@link formatQuery} for "jsonata" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized" | (FormatQueryOptions & {
-  format: "parameterized";
-})): ParameterizedSQL;
+declare const defaultRuleGroupProcessorJSONata: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorJsonLogic.d.ts
 /**
- * Generates a {@link index!ParameterizedNamedSQL ParameterizedNamedSQL} object from a query object.
+ * Rule group processor used by {@link formatQuery} for "jsonlogic" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized_named" | (FormatQueryOptions & {
-  format: "parameterized_named";
-})): ParameterizedNamedSQL;
+declare const defaultRuleGroupProcessorJsonLogic: RuleGroupProcessor<RQBJsonLogic>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorLDAP.d.ts
 /**
- * Generates a {@link index!RQBJsonLogic JsonLogic} object from a query object.
+ * Rule group processor used by {@link formatQuery} for "ldap" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonlogic" | (FormatQueryOptions & {
-  format: "jsonlogic";
-})): RQBJsonLogic;
+declare const defaultRuleGroupProcessorLDAP: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDB.d.ts
 /**
- * Generates an ElasticSearch query object from an RQB query object.
+ * Rule group processor used by {@link formatQuery} for "mongodb" format.
  *
- * 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).
+ * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "elasticsearch" | (FormatQueryOptions & {
-  format: "elasticsearch";
-})): Record<string, any>;
+declare const defaultRuleGroupProcessorMongoDB: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDBQuery.d.ts
 /**
- * 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.
+ * Default fallback object used by {@link formatQuery} for "mongodb_query" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb_query" | (FormatQueryOptions & {
-  format: "mongodb_query";
-})): Record<string, any>;
+declare const mongoDbFallback: {
+  readonly $and: readonly [{
+    readonly $expr: true;
+  }];
+};
 /**
- * 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.
- *
- * @deprecated Use the "mongodb_query" format for greater flexibility.
+ * Rule group processor used by {@link formatQuery} for "mongodb_query" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb" | (FormatQueryOptions & {
-  format: "mongodb";
-})): string;
+declare const defaultRuleGroupProcessorMongoDBQuery: RuleGroupProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorNL.d.ts
 /**
- * Generates a Prisma ORM query object from an RQB query object.
+ * Rule group processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "prisma" | (FormatQueryOptions & {
-  format: "prisma";
-})): Record<string, any>;
+declare const defaultRuleGroupProcessorNL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorParameterized.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.
+ * Rule group processor used by {@link formatQuery} for "parameterized" and
+ * "parameterized_named" formats.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (FormatQueryOptions & {
-  format: "drizzle";
-})): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
+declare const defaultRuleGroupProcessorParameterized: RuleGroupProcessor<ParameterizedSQL | ParameterizedNamedSQL>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorPrisma.d.ts
 /**
- * Generates a TanStack DB WhereCallback from an RQB query object. The callback can
- * be passed directly to TanStack DB's `.where()` method.
+ * Default fallback object used by {@link formatQuery} for "prisma" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
-  format: "tanstack_db";
-})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
+declare const prismaFallback: {};
 /**
- * be assigned to the `where` property in the Sequelize query functions.
+ * Rule group processor used by {@link formatQuery} for "prisma" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "sequelize" | (FormatQueryOptions & {
-  format: "sequelize";
-})): ReturnType<typeof defaultRuleGroupProcessorSequelize>;
+declare const defaultRuleGroupProcessorPrisma: RuleGroupProcessor<Record<string, unknown> | undefined>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSequelize.d.ts
 /**
- * Generates a JSONata query string from an RQB query object.
- *
- * NOTE: Either `parseNumbers: "strict-limited"` or `parseNumbers: true`
- * are recommended for this format.
+ * 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: "jsonata" | (FormatQueryOptions & {
-  format: "jsonata";
-})): string;
+interface SequelizeWhereOptionsLike {
+  [key: string | symbol]: unknown;
+}
 /**
- * Generates an LDAP query string from an RQB query object.
+ * Rule group processor used by {@link formatQuery} for "sequelize" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "ldap" | (FormatQueryOptions & {
-  format: "ldap";
-})): string;
+declare const defaultRuleGroupProcessorSequelize: RuleGroupProcessor<SequelizeWhereOptionsLike | undefined>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.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.
+ * Rule group processor used by {@link formatQuery} for "sparql" format.
+ *
+ * SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "diagnostics" | (FormatQueryOptions & {
-  format: "diagnostics";
-})): DiagnosticsResult;
+declare const defaultRuleGroupProcessorSPARQL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSpEL.d.ts
 /**
- * Generates a formatted (indented two spaces) JSON string from a query object.
+ * Default rule processor used by {@link formatQuery} for "spel" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions): string;
+declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.d.ts
 /**
- * Generates a query string in the requested format.
+ * Default rule processor used by {@link formatQuery} for "sql" format.
  *
  * @group Export
  */
-declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: Exclude<ExportFormat, ExportObjectFormats>): string;
+declare const defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
+//#endregion
+//#region src/utils/formatQuery/tanStackDbTypes.d.ts
 /**
- * Generates a query string in the requested format.
+ * 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.
+ */
+type TanStackDbWhereCallbackReturnType = unknown;
+type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
+/**
+ * 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: FormatQueryOptions & {
-  format: Exclude<ExportFormat, ExportObjectFormats>;
-}): string;
+declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
 //#endregion
-//#region src/utils/formatQuery/utils.d.ts
+//#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
 /**
- * Maps a {@link DefaultOperatorName} to a SQL operator.
+ * Rule group processor used by {@link formatQuery} for "diagnostics" 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 const mapSQLOperator: (rqbOperator: string) => string;
+declare const defaultRuleGroupProcessorDiagnostics: RuleGroupProcessor<DiagnosticsResult>;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorCypher.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 "cypher" and "gql" formats.
  *
  * @group Export
  */
-declare const getSQLConcat: (concatOperator?: string) => (...values: string[]) => string;
+declare const defaultRuleProcessorCypher: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorDrizzle.d.ts
 /**
- * Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
- * → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
- * yield `['', '']`.
+ * Default rule processor used by {@link formatQuery} for the "drizzle" format.
  *
  * @group Export
  */
-declare const getLikeWildcards: (operatorLC: string) => [string, string];
+declare const defaultRuleProcessorDrizzle: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.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 rule processor used by {@link formatQuery} for "elasticsearch" format.
  *
  * @group Export
  */
-declare const wrapLikeFragment: (fragment: string, operatorLC: string, { concatOperator, quoteValuesWith, wrapValueWith }?: {
-  concatOperator?: string;
-  quoteValuesWith?: string;
-  wrapValueWith?: [string, string];
-}) => string;
+declare const defaultRuleProcessorElasticSearch: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorGremlin.d.ts
 /**
- * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
+ * 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 const mongoOperators: {
-  "=": string;
-  "!=": string;
-  "<": string;
-  "<=": string;
-  ">": string;
-  ">=": string;
-  in: string;
-  notin: string;
-  notIn: string;
-};
+declare const defaultRuleProcessorGremlin: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorJSONata.d.ts
 /**
- * Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
+ * Default rule processor used by {@link formatQuery} for "jsonata" format.
  *
  * @group Export
  */
-declare const prismaOperators: {
-  "=": string;
-  "!=": string;
-  "<": string;
-  "<=": string;
-  ">": string;
-  ">=": string;
-  in: string;
-  notin: string;
-};
+declare const defaultRuleProcessorJSONata: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorJsonLogic.d.ts
 /**
- * Maps a {@link DefaultCombinatorName} to a CEL combinator.
+ * Default rule processor used by {@link formatQuery} for "jsonlogic" format.
  *
  * @group Export
  */
-declare const celCombinatorMap: {
-  and: "&&";
-  or: "||";
-};
+declare const defaultRuleProcessorJsonLogic: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorLDAP.d.ts
 /**
- * Register these operators with `jsonLogic` before applying the result
- * of `formatQuery(query, 'jsonlogic')`.
+ * Default rule processor used by {@link formatQuery} for "ldap" format.
  *
- * @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 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 jsonLogicAdditionalOperators: Record<"startsWith" | "endsWith", (a: string, b: string) => boolean>;
+declare const defaultRuleProcessorMongoDBQuery: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorNL.d.ts
 /**
- * Returns a new query object with all `string`-type `value` properties converted
- * to `number` where appropriate.
+ * Default operator map used by {@link formatQuery} for "natural_language" format.
  *
- * Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
+ * @group Export
+ */
+declare const defaultExportOperatorMap: ExportOperatorMap;
+/**
+ * Default operator processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const numerifyValues: (rg: RuleGroupTypeAny, options: SetRequired<FormatQueryOptions, "fields">) => RuleGroupTypeAny;
+declare const defaultOperatorProcessorNL: RuleProcessor;
 /**
- * Determines whether a value is _anything_ except an empty `string` or `NaN`.
+ * Default rule processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const isValidValue: (value: unknown) => boolean;
+declare const defaultRuleProcessorNL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorParameterized.d.ts
 /**
- * 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 "parameterized" and
+ * "parameterized_named" formats.
  *
  * @group Export
  */
-declare const shouldRenderAsNumber: (value: unknown, parseNumbers?: boolean) => boolean;
+declare const defaultRuleProcessorParameterized: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorPrisma.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 rule processor used by {@link formatQuery} for "prisma" format.
  *
  * @group Export
  */
-declare const isValueProcessorLegacy: (valueProcessor: ValueProcessorLegacy | ValueProcessorByRule) => valueProcessor is ValueProcessorLegacy;
+declare const defaultRuleProcessorPrisma: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSequelize.d.ts
 /**
- * Converts the `quoteFieldNamesWith` option into an array of two strings.
- * If the option is a string, the array elements are both that string.
+ * Default rule processor used by {@link formatQuery} for the "sequelize" format.
  *
- * @default
- * ['', '']
+ * @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.
  *
  * @group Export
  */
-declare const getQuoteFieldNamesWithArray: (quoteFieldNamesWith?: null | string | [string, string]) => [string, string];
+declare const sparqlVar: (name: string) => string;
 /**
- * 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 "sparql" format.
  *
  * @group Export
  */
-declare const getQuotedFieldName: (fieldName: string, { quoteFieldNamesWith, fieldIdentifierSeparator }: ValueProcessorOptions) => string;
+declare const defaultRuleProcessorSPARQL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSQL.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 operator processor used by {@link formatQuery} for "sql" and "parameterized*" formats.
  *
  * @group Export
  */
-declare const normalizeConstituentWordOrder: (input: string) => ConstituentWordOrder;
+declare const defaultOperatorProcessorSQL: RuleProcessor;
 /**
- * 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"`).
+ * Default rule processor used by {@link formatQuery} for "sql" format.
  *
  * @group Export
  */
-declare const withParamPrefix: (value: unknown, paramPrefix?: string) => string;
+declare const defaultRuleProcessorSQL: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
 /**
- * Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
- * {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
+ * Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
  *
  * @group Export
  */
-declare const stripParamPrefix: (value: unknown, paramPrefix?: string) => string;
+declare const defaultRuleProcessorTanStackDB: RuleProcessor;
+//#endregion
+//#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
 /**
- * Default translations used by {@link formatQuery} for "natural_language" format.
+ * Default value processor used by {@link formatQuery} for "natural_language" format.
  *
  * @group Export
  */
-declare const defaultNLTranslations: NLTranslations;
+declare const defaultValueProcessorNL: ValueProcessorByRule;
+//#endregion
+//#region src/utils/formatQuery/formatQuery.d.ts
 /**
- * Used by {@link formatQuery} to get a translation based on certain conditions
- * for the "natural_language" format.
+ * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
  *
  * @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 const sqlDialectPresets: Record<SQLPreset, FormatQueryOptions>;
 /**
- * Transforms
- * - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
- * - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
+ * A collection of option presets for {@link formatQuery}.
  *
- * 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 const formatQueryOptionPresets: Record<string, FormatQueryOptions>;
 /**
- * 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 formatted (indented two spaces) JSON string from a query object.
+ *
+ * @group Export
  */
-declare const subqueryElementAliasBase = "elem_alias";
+declare function formatQuery(ruleGroup: RuleGroupTypeAny): string;
 /**
- * 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.
+ * Generates a result based on the provided rule group processor.
  *
- * Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
+ * @group Export
+ */
+declare function formatQuery<TResult = unknown>(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
+  ruleGroupProcessor: RuleGroupProcessor<TResult>;
+}): TResult;
+/**
+ * Generates a {@link index!ParameterizedSQL ParameterizedSQL} object from a query object.
  *
  * @group Export
  */
-declare const getSubqueryElementAlias: (subqueryDepth?: number) => string;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized" | (FormatQueryOptions & {
+  format: "parameterized";
+})): ParameterizedSQL;
 /**
- * "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 a {@link index!ParameterizedNamedSQL ParameterizedNamedSQL} object from a query object.
  *
- * Inverse of {@link bigIntJsonParseReviver}.
+ * @group Export
+ */
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized_named" | (FormatQueryOptions & {
+  format: "parameterized_named";
+})): ParameterizedNamedSQL;
+/**
+ * Generates a {@link index!RQBJsonLogic JsonLogic} object from a query object.
  *
- * @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: "jsonlogic" | (FormatQueryOptions & {
+  format: "jsonlogic";
+})): RQBJsonLogic;
 /**
- * "Reviver" method for JSON.parse's second argument. Converts objects having a single
- * `$bigint: string` property to an actual `bigint` value.
+ * Generates an ElasticSearch query object from an RQB query object.
  *
- * Inverse of {@link bigIntJsonStringifyReplacer}.
+ * 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 bigIntJsonParseReviver: (_key: string, value: unknown) => unknown;
-//#endregion
-//#region src/utils/formatQuery/index.d.ts
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "elasticsearch" | (FormatQueryOptions & {
+  format: "elasticsearch";
+})): Record<string, any>;
 /**
- * Default value processor used by {@link formatQuery} for "sql" format.
+ * Generates a MongoDB query object from an RQB query object.
  *
- * @deprecated Prefer {@link defaultValueProcessorByRule}.
+ * This is equivalent to the "mongodb" format, but returns a JSON object
+ * instead of a string.
  *
  * @group Export
  */
-declare const defaultValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb_query" | (FormatQueryOptions & {
+  format: "mongodb_query";
+})): Record<string, any>;
 /**
- * @deprecated Prefer {@link defaultRuleProcessorMongoDB}.
+ * 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.
+ *
+ * @deprecated Use the "mongodb_query" format for greater flexibility.
  *
  * @group Export
  */
-declare const defaultMongoDBValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb" | (FormatQueryOptions & {
+  format: "mongodb";
+})): string;
 /**
- * @deprecated Prefer {@link defaultRuleProcessorCEL}.
+ * Generates a Prisma ORM query object from an RQB query object.
  *
  * @group Export
  */
-declare const defaultCELValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "prisma" | (FormatQueryOptions & {
+  format: "prisma";
+})): Record<string, any>;
 /**
- * @deprecated Prefer {@link defaultRuleProcessorSpEL}.
+ * 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 defaultSpELValueProcessor: ValueProcessorLegacy;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (FormatQueryOptions & {
+  format: "drizzle";
+})): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
 /**
- * @deprecated Renamed to {@link defaultRuleProcessorCEL}.
+ * 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 defaultValueProcessorCELByRule: RuleProcessor;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
+  format: "tanstack_db";
+})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
 /**
- * @deprecated Renamed to {@link defaultRuleProcessorMongoDB}.
+ * be assigned to the `where` property in the Sequelize query functions.
  *
  * @group Export
  */
-declare const defaultValueProcessorMongoDBByRule: RuleProcessor;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "sequelize" | (FormatQueryOptions & {
+  format: "sequelize";
+})): ReturnType<typeof defaultRuleGroupProcessorSequelize>;
 /**
- * @deprecated Renamed to {@link defaultRuleProcessorSpEL}.
+ * 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 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;
-/**
- * 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 let generateID: () => UUID;
-//#endregion
-//#region src/utils/getMatchModesUtil.d.ts
-/**
- * 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 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: "jsonata" | (FormatQueryOptions & {
+  format: "jsonata";
+})): 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 an LDAP query string from an RQB query object.
  *
- * @group Option Lists
- */
-declare const getRuleDefaultValue$1: <F extends FullField = FullField>(rule: RuleType, options: GetRuleDefaultValueOptions<F>) => unknown;
-//#endregion
-//#region src/utils/getValidationClassNames.d.ts
-/**
- * Gets the standard classname for valid or invalid components
- * based on the given validation result.
- */
-declare const getValidationClassNames: (validationResult: boolean | ValidationResult) => "" | (typeof standardClassnames)["valid"] | (typeof standardClassnames)["invalid"];
-//#endregion
-//#region src/utils/getValueSourcesUtil.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.
+ * @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 function formatQuery(ruleGroup: RuleGroupTypeAny, options: "ldap" | (FormatQueryOptions & {
+  format: "ldap";
+})): string;
 /**
- * Determines if an object is a {@link RuleType} (only checks for a `field` property).
+ * 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 const isRuleType: (s: unknown) => s is RuleType;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "diagnostics" | (FormatQueryOptions & {
+  format: "diagnostics";
+})): DiagnosticsResult;
 /**
- * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
+ * Generates a formatted (indented two spaces) JSON string from a query object.
+ *
+ * @group Export
  */
-declare const isRuleGroup: (rg: unknown) => rg is RuleGroupTypeAny;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions): string;
 /**
- * Determines if an object is a {@link RuleGroupType}.
+ * Generates a query string in the requested format.
+ *
+ * @group Export
  */
-declare const isRuleGroupType: (rg: unknown) => rg is RuleGroupType;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: Exclude<ExportFormat, ExportObjectFormats>): string;
 /**
- * Determines if an object is a {@link RuleGroupTypeIC}.
+ * Generates a query string in the requested format.
+ *
+ * @group Export
  */
-declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
+  format: Exclude<ExportFormat, ExportObjectFormats>;
+}): string;
 //#endregion
-//#region src/utils/isRuleOrGroupValid.d.ts
-/**
- * Determines if an object is useful as a validation result.
- */
-declare const isValidationResult: (vr?: ValidationResult) => vr is ValidationResult;
+//#region src/utils/formatQuery/utils.d.ts
 /**
- * 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 DefaultOperatorName} to a SQL operator.
+ *
+ * @group Export
  */
-declare const isRuleOrGroupValid: (rg: RuleType | RuleGroupTypeAny, validationResult?: boolean | ValidationResult, validator?: RuleValidator) => boolean;
-//#endregion
-//#region src/utils/mergeAnyTranslations.d.ts
+declare const mapSQLOperator: (rqbOperator: string) => string;
 /**
- * Merges any number of partial translations into a single definition.
+ * 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 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 getSQLConcat: (concatOperator?: string) => (...values: string[]) => string;
 /**
- * Merges a list of partial {@link Classnames} definitions into a single definition.
+ * Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
+ * → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
+ * yield `['', '']`.
+ *
+ * @group Export
  */
-declare const mergeClassnames: (...args: MergeClassnamesParams) => Classnames;
-//#endregion
-//#region src/utils/misc.d.ts
+declare const getLikeWildcards: (operatorLC: string) => [string, string];
 /**
- * Converts a value to lowercase if it's a string, otherwise returns the value as is.
+ * 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 lc: <T>(v: T) => T;
+declare const wrapLikeFragment: (fragment: string, operatorLC: string, { concatOperator, quoteValuesWith, wrapValueWith }?: {
+  concatOperator?: string;
+  quoteValuesWith?: string;
+  wrapValueWith?: [string, string];
+}) => string;
 /**
- * Regex matching numeric strings. Passes for positive/negative integers, decimals,
- * and E notation, with optional surrounding whitespace.
+ * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
+ *
+ * @group Export
  */
-declare const numericRegex: RegExp;
+declare const mongoOperators: {
+  "=": string;
+  "!=": string;
+  "<": string;
+  "<=": string;
+  ">": string;
+  ">=": string;
+  in: string;
+  notin: string;
+  notIn: string;
+};
 /**
- * Determines if a variable is a plain old JavaScript object, aka POJO.
+ * Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
+ *
+ * @group Export
  */
-declare const isPojo: (obj: unknown) => obj is Record<string, any>;
+declare const prismaOperators: {
+  "=": string;
+  "!=": string;
+  "<": string;
+  "<=": string;
+  ">": string;
+  ">=": string;
+  in: string;
+  notin: string;
+};
 /**
- * Simple helper to determine whether a value is null, undefined, or an empty string.
+ * Maps a {@link DefaultCombinatorName} to a CEL combinator.
+ *
+ * @group Export
  */
-declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefined | "";
-//#endregion
-//#region src/utils/objectUtils.d.ts
+declare const celCombinatorMap: {
+  and: "&&";
+  or: "||";
+};
 /**
- * Original looked like this (not sure why template string is used):
+ * Register these operators with `jsonLogic` before applying the result
+ * of `formatQuery(query, 'jsonlogic')`.
+ *
+ * @example
  * ```
- * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+ * for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {
+ *   jsonLogic.add_operation(op, func);
+ * }
+ * jsonLogic.apply({ "startsWith": [{ "var": "firstName" }, "Stev"] }, data);
  * ```
+ *
+ * @group Export
  */
-type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
+declare const jsonLogicAdditionalOperators: Record<"startsWith" | "endsWith", (a: string, b: string) => boolean>;
 /**
- * A strongly-typed version of `Object.keys()`.
+ * Returns a new query object with all `string`-type `value` properties converted
+ * to `number` where appropriate.
  *
- * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+ * Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
+ *
+ * @group Export
  */
-declare const objectKeys: <Type extends object>(value: Type) => Array<ObjectKeys<Type>>;
+declare const numerifyValues: (rg: RuleGroupTypeAny, options: SetRequired<FormatQueryOptions, "fields">) => RuleGroupTypeAny;
 /**
- * A strongly-typed version of `Object.entries()`.
+ * Determines whether a value is _anything_ except an empty `string` or `NaN`.
  *
- * [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 isValidValue: (value: unknown) => boolean;
 /**
- * Returns `true` if the key could cause prototype pollution when used
- * as a property name in bracket-notation assignment.
- */
-declare const isUnsafeKey: (key: unknown) => boolean;
-//#endregion
-//#region src/utils/optionResolvers.d.ts
-/**
- * Options shared by the resolvers below that produce a normalized option list.
+ * 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
  */
-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 shouldRenderAsNumber: (value: unknown, parseNumbers?: boolean) => boolean;
 /**
- * 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 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 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 isValueProcessorLegacy: (valueProcessor: ValueProcessorLegacy | ValueProcessorByRule) => valueProcessor is ValueProcessorLegacy;
 /**
- * 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.
+ * Converts the `quoteFieldNamesWith` option into an array of two strings.
+ * If the option is a string, the array elements are both that string.
  *
- * @group Option Lists
+ * @default
+ * ['', '']
+ *
+ * @group Export
  */
-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 getQuoteFieldNamesWithArray: (quoteFieldNamesWith?: null | string | [string, string]) => [string, string];
 /**
- * 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"`.
+ * Given a field name and relevant {@link ValueProcessorOptions}, returns the field name
+ * wrapped in the configured quote character(s).
  *
- * @group Option Lists
+ * @group Export
  */
-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 getQuotedFieldName: (fieldName: string, { quoteFieldNamesWith, fieldIdentifierSeparator }: ValueProcessorOptions) => string;
 /**
- * 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.
+ * 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"]`).
  *
- * @group Option Lists
+ * @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 normalizeConstituentWordOrder: (input: string) => ConstituentWordOrder;
 /**
- * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
- * into a {@link FullOption}. Full options are left unchanged.
+ * 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"`).
  *
- * @group Option Lists
+ * @group Export
  */
-declare function toFullOption<Opt extends BaseOption>(opt: Opt | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt>;
+declare const withParamPrefix: (value: unknown, paramPrefix?: string) => string;
 /**
- * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
- * Lists of full options are left unchanged.
+ * Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
+ * {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
  *
- * @group Option Lists
+ * @group Export
  */
-declare function toFullOptionList<Opt extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt>;
+declare const stripParamPrefix: (value: unknown, paramPrefix?: string) => string;
 /**
- * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
- * Lists of full options are left unchanged.
+ * Default translations used by {@link formatQuery} for "natural_language" format.
  *
- * @group Option Lists
+ * @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 defaultNLTranslations: NLTranslations;
 /**
- * @deprecated Renamed to {@link uniqByIdentifier}.
+ * Used by {@link formatQuery} to get a translation based on certain conditions
+ * for the "natural_language" format.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const uniqByName: <T extends {
-  name: string;
-  value?: string;
+declare const getNLTranslataion: (key: NLTranslationKey, translations: NLTranslations, conditions?: GroupVariantCondition[]) => string;
+type ProcessedMatchMode = {
+  mode: "all";
+  threshold?: number | null | undefined;
 } | {
-  name?: string;
-  value: string;
-}>(originalArray: T[]) => T[];
+  mode: "none";
+  threshold?: number | null | undefined;
+} | {
+  mode: "some";
+  threshold?: number | null | undefined;
+} | {
+  mode: "atleast";
+  threshold: number;
+} | {
+  mode: "atmost";
+  threshold: number;
+} | {
+  mode: "exactly";
+  threshold: number;
+};
 /**
- * Generates a new array of objects with duplicates removed based
- * on the identifying property (`value` or `name`)
+ * 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 uniqByIdentifier: <T extends RequireAtLeastOne$1<{
-  name: string;
-  value: string;
-}, "name" | "value">>(originalArray: T[]) => T[];
+declare const processMatchMode: (rule: RuleType) => null | false | ProcessedMatchMode;
 /**
- * Determines if an {@link OptionList} is an {@link OptionGroup} array.
- *
- * @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 isOptionGroupArray: (arr: unknown) => arr is OptionGroup<BaseOption>[];
+declare const subqueryElementAliasBase = "elem_alias";
 /**
- * Determines if an array is a flat array of {@link FlexibleOption}.
+ * 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 isFlexibleOptionArray: (arr: unknown) => arr is FlexibleOption[];
+declare const getSubqueryElementAlias: (subqueryDepth?: number) => string;
 /**
- * Determines if an array is a flat array of {@link FullOption}.
+ * "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 const isFullOptionArray: (arr: unknown) => arr is FullOption[];
+declare const bigIntJsonStringifyReplacer: (_key: string, value: unknown) => unknown;
 /**
- * Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
+ * "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 const isFlexibleOptionGroupArray: (arr: unknown, { allowEmpty }?: {
-  allowEmpty?: boolean;
-}) => arr is FlexibleOptionGroup[];
+declare const bigIntJsonParseReviver: (_key: string, value: unknown) => unknown;
+//#endregion
+//#region src/utils/formatQuery/index.d.ts
 /**
- * Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.
+ * Default value processor used by {@link formatQuery} for "sql" format.
  *
- * @group Option Lists
+ * @deprecated Prefer {@link defaultValueProcessorByRule}.
+ *
+ * @group Export
  */
-declare const isFullOptionGroupArray: (arr: unknown, { allowEmpty }?: {
-  allowEmpty?: boolean;
-}) => arr is OptionGroup<FullOption>[];
+declare const defaultValueProcessor: ValueProcessorLegacy;
 /**
- * Gets the option from an {@link OptionList} with the given `name`. Handles
- * {@link Option} arrays as well as {@link OptionGroup} arrays.
+ * @deprecated Prefer {@link defaultRuleProcessorMongoDB}.
  *
- * @group Option Lists
+ * @group Export
  */
-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 const defaultMongoDBValueProcessor: ValueProcessorLegacy;
 /**
- * Gets the first option from an {@link OptionList}.
+ * @deprecated Prefer {@link defaultRuleProcessorCEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare function getFirstOption<Opt extends FullOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-declare function getFirstOption<Opt extends ValueOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
-declare function getFirstOption<Opt extends Option>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
+declare const defaultCELValueProcessor: ValueProcessorLegacy;
 /**
- * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
- * If the array is already flat, it is returned as is.
+ * @deprecated Prefer {@link defaultRuleProcessorSpEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const toFlatOptionArray: <T extends FullOption>(arr: FullOptionList<T>) => T[];
+declare const defaultSpELValueProcessor: ValueProcessorLegacy;
 /**
- * Generates a new {@link OptionGroup} array with duplicates
- * removed based on the identifying property (`value` or `name`).
+ * @deprecated Renamed to {@link defaultRuleProcessorCEL}.
  *
- * @group Option Lists
+ * @group Export
  */
-declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptionGroup<T>[]) => OptionGroup<ToFullOption<T>>[];
+declare const defaultValueProcessorCELByRule: RuleProcessor;
 /**
- * Generates a new {@link Option} or {@link OptionGroup} array with duplicates
- * removed based on the identifier property (`value` or `name`).
+ * @deprecated Renamed to {@link defaultRuleProcessorMongoDB}.
  *
- * @group Option Lists
+ * @group Export
  */
-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 defaultValueProcessorMongoDBByRule: RuleProcessor;
+/**
+ * @deprecated Renamed to {@link defaultRuleProcessorSpEL}.
+ *
+ * @group Export
+ */
+declare const defaultValueProcessorSpELByRule: RuleProcessor;
 //#endregion
-//#region src/utils/parseNumber.d.ts
+//#region src/utils/generateAccessibleDescription.d.ts
 /**
- * Options object for {@link parseNumber}.
+ * 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 Accessibility
  */
-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 generateAccessibleDescription: AccessibleDescriptionGenerator;
+//#endregion
+//#region src/utils/generateID.d.ts
+type UUID = `${string}-${string}-${string}-${string}-${string}`;
+declare const uuidV4regex: RegExp;
 /**
- * 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.
+ * 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 const parseNumber: (val: unknown, { parseNumbers, bigIntOnOverflow }?: ParseNumberOptions) => any;
+declare let generateID: () => UUID;
 //#endregion
-//#region src/utils/pathUtils.d.ts
+//#region src/utils/immerInstances.d.ts
 /**
- * Return type for {@link findPath}.
+ * 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}.
+ *
+ * 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 Query Tools
  */
-type FindPathReturnType = RuleGroupTypeAny | RuleType | null;
+declare const setAutoFreeze: (autoFreeze: boolean) => void;
+//#endregion
+//#region src/utils/getMatchModesUtil.d.ts
 /**
- * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
- * at the given path within a query.
+ * 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 findPath: (path: Path, query: RuleGroupTypeAny) => FindPathReturnType;
+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;
+}
 /**
- * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
- * with the given `id` within a query.
+ * 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 findID: (id: string, query: RuleGroupTypeAny) => FindPathReturnType;
+declare const getRuleDefaultValue$1: <F extends FullField = FullField>(rule: RuleType, options: GetRuleDefaultValueOptions<F>) => unknown;
+//#endregion
+//#region src/utils/getValidationClassNames.d.ts
 /**
- * Returns the {@link Path} of the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
- * with the given `id` within a query.
+ * Gets the standard classname for valid or invalid components
+ * based on the given validation result.
  */
-declare const getPathOfID: (id: string, query: RuleGroupTypeAny) => Path | null;
+declare const getValidationClassNames: (validationResult: boolean | ValidationResult) => "" | (typeof standardClassnames)["valid"] | (typeof standardClassnames)["invalid"];
+//#endregion
+//#region src/utils/getValueSourcesUtil.d.ts
 /**
- * Truncates the last element of an array and returns the result as a new array.
+ * 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 getParentPath: (path: Path) => Path;
+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
 /**
- * Determines if two paths (each `Path`) are equivalent.
+ * Determines if an object is a {@link RuleType} (only checks for a `field` property).
  */
-declare const pathsAreEqual: (path1: Path, path2: Path) => boolean;
+declare const isRuleType: (s: unknown) => s is RuleType;
 /**
- * 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.
+ * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
  */
-declare const isAncestor: (maybeAncestor: Path, path: Path) => boolean;
+declare const isRuleGroup: (rg: unknown) => rg is RuleGroupTypeAny;
 /**
- * Finds the deepest/longest path that two paths have in common.
+ * Determines if an object is a {@link RuleGroupType}.
  */
-declare const getCommonAncestorPath: (path1: Path, path2: Path) => Path;
+declare const isRuleGroupType: (rg: unknown) => rg is RuleGroupType;
 /**
- * Determines if the rule or group at the specified path is either disabled itself
- * or disabled by an ancestor group.
+ * Determines if an object is a {@link RuleGroupTypeIC}.
  */
-declare const pathIsDisabled: (path: Path, query: RuleGroupTypeAny) => boolean;
+declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
+//#endregion
+//#region src/utils/isRuleOrGroupValid.d.ts
 /**
- * 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
+ * Determines if an object is useful as a validation result.
  */
-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 isValidationResult: (vr?: ValidationResult) => vr is ValidationResult;
 /**
- * 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 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 derivePathInfo: (path: Path, childCount: number, { disabled, disabledPaths }?: {
-  disabled?: boolean;
-  disabledPaths?: Path[];
-}) => PathInfo[];
+declare const isRuleOrGroupValid: (rg: RuleType | RuleGroupTypeAny, validationResult?: boolean | ValidationResult, validator?: RuleValidator) => boolean;
 //#endregion
-//#region src/utils/preferProp.d.ts
+//#region src/utils/mergeAnyTranslations.d.ts
 /**
- * For given default, prop, and context values, return the first provided of prop,
- * context, and default, in that order.
+ * Merges any number of partial translations into a single definition.
  */
-declare const preferProp: (def: boolean, prop?: boolean, context?: boolean, doNotFinalize?: boolean) => 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)[];
 /**
- * For given default, prop, and context values, return the first provided of prop,
- * context, and default, in that order.
+ * Merges a list of partial {@link Classnames} definitions into a single definition.
  */
-declare const preferAnyProp: (def?: any, prop?: any, context?: any) => any;
+declare const mergeClassnames: (...args: MergeClassnamesParams) => Classnames;
+//#endregion
+//#region src/utils/misc.d.ts
 /**
- * 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.
+ * Converts a value to lowercase if it's a string, otherwise returns the value as is.
  */
-declare const preferFlagProps: (props?: QueryBuilderFlags, contextVals?: QueryBuilderFlags, finalize?: boolean) => QueryBuilderFlags;
-//#endregion
-//#region src/utils/prepareQueryObjects.d.ts
+declare const lc: <T>(v: T) => T;
 /**
- * Options for {@link prepareRule}/{@link prepareRuleGroup}.
+ * Regex matching numeric strings. Passes for positive/negative integers, decimals,
+ * and E notation, with optional surrounding whitespace.
  */
-interface PreparerOptions {
-  idGenerator?: () => string;
-}
+declare const numericRegex: RegExp;
 /**
- * Ensures that a rule is valid by adding an `id` property if it does not already exist.
+ * Determines if a variable is a plain old JavaScript object, aka POJO.
  */
-declare const prepareRule: (rule: RuleType, { idGenerator }?: PreparerOptions) => RuleType;
+declare const isPojo: (obj: unknown) => obj is Record<string, any>;
 /**
- * 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.
+ * Simple helper to determine whether a value is null, undefined, or an empty string.
  */
-declare const prepareRuleGroup: <RG extends RuleGroupTypeAny>(queryObject: RG, { idGenerator }?: PreparerOptions) => RG;
+declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefined | "";
+//#endregion
+//#region src/utils/objectUtils.d.ts
 /**
- * Ensures that a rule or group is valid. See {@link prepareRule} and {@link prepareRuleGroup}.
+ * Original looked like this (not sure why template string is used):
+ * ```
+ * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+ * ```
  */
-declare const prepareRuleOrGroup: (rg: RuleGroupTypeAny | RuleType, { idGenerator }?: PreparerOptions) => RuleGroupType | RuleGroupTypeIC | RuleType;
+type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
 /**
- * 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.
+ * A strongly-typed version of `Object.keys()`.
  *
- * 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`.
+ * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+ */
+declare const objectKeys: <Type extends object>(value: Type) => Array<ObjectKeys<Type>>;
+/**
+ * A strongly-typed version of `Object.entries()`.
  *
- * @group Query Tools
+ * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
  */
-declare const resolveCandidateQuery: <RG extends RuleGroupTypeAny>(sources: {
-  query?: RG;
-  storeQuery?: RG;
-  defaultQuery?: RG;
-  fallbackQuery: RG;
-}, options?: {
-  idGenerator?: () => string;
-}) => RG;
+declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value: Type) => Array<[ObjectKeys<Type>, Type[ObjectKeys<Type>]]>;
+/**
+ * Returns `true` if the key could cause prototype pollution when used
+ * as a property name in bracket-notation assignment.
+ */
+declare const isUnsafeKey: (key: unknown) => boolean;
 //#endregion
-//#region src/utils/queryActions.d.ts
+//#region src/utils/optionResolvers.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
 /**
@@ -5605,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.
@@ -5645,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
@@ -5680,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;
@@ -5776,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}. */
@@ -5789,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 `[]`. */
@@ -5830,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 });
@@ -5846,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`).
@@ -5920,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
@@ -5964,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
@@ -6155,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.
@@ -6207,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}.
@@ -6311,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, 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, 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.d.mts.map