@react-querybuilder/core 8.21.2 → 8.22.1

package/dist/react-querybuilder_core.d.mts

@@ -2445,6 +2445,32 @@ type NLTranslationKey = "and" | "or" | "true" | "false" | "ruleSeparator" | "bet
  */
 type NLTranslations = Partial<Record<NLTranslationKey, string>>;
 //#endregion
+//#region src/types/history.d.ts
+/**
+ * Options controlling how query changes are recorded for undo/redo.
+ *
+ * Shared by the `react-querybuilder/history` entry point and the
+ * {@link index!QueryManager QueryManager} utility.
+ */
+interface QueryHistoryOptions {
+  /**
+   * Maximum number of undo steps to retain. Older entries are discarded.
+   *
+   * @default 50
+   */
+  maxHistory?: number;
+  /**
+   * Consecutive changes to the same property of the same rule within this many milliseconds
+   * are merged into a single undo step, so that (for example) typing a multi-character value
+   * produces one history entry rather than one per keystroke.
+   *
+   * Set to `0` to record every change separately.
+   *
+   * @default 500
+   */
+  coalesceMs?: number;
+}
+//#endregion
 //#region src/types/queryBuilder.d.ts
 /**
  * Base interface for all rule subcomponents.
@@ -2536,6 +2562,18 @@ interface Classnames {
    * Classnames applied to the `<span>` handle for dragging rules/groups.
    */
   shiftActions: Classname;
+  /**
+   * Classname(s) to be applied to the undo/redo actions container.
+   */
+  undoRedoActions: Classname;
+  /**
+   * Classname(s) to be applied to the "undo" button.
+   */
+  undoAction: Classname;
+  /**
+   * Classname(s) to be applied to the "redo" button.
+   */
+  redoAction: Classname;
   /**
    * Classnames applied to the `<span>` handle for dragging rules/groups.
    */
@@ -2710,6 +2748,8 @@ interface BaseTranslations<LabelType = string> {
   cloneRuleGroup: BaseTranslationWithLabel<LabelType>;
   shiftActionUp: BaseTranslationWithLabel<LabelType>;
   shiftActionDown: BaseTranslationWithLabel<LabelType>;
+  undo: BaseTranslationWithLabel<LabelType>;
+  redo: BaseTranslationWithLabel<LabelType>;
   dragHandle: BaseTranslationWithLabel<LabelType>;
   lockRule: BaseTranslationWithLabel<LabelType>;
   lockGroup: BaseTranslationWithLabel<LabelType>;
@@ -2749,6 +2789,18 @@ interface QueryBuilderFlags {
    * @default true
    */
   enableMountQueryChange?: boolean;
+  /**
+   * By default, when the last `QueryBuilder` component using a given `qbId` unmounts, its
+   * query is removed from the internal Redux store. Set this to `true` to retain the query
+   * state after unmount, which allows a subsequent `QueryBuilder` with the same `qbId` to
+   * pick up where the previous one left off.
+   *
+   * Only meaningful in conjunction with an explicit `qbId` prop, since automatically generated
+   * `qbId`s are never reused.
+   *
+   * @default false
+   */
+  preserveQueryStateOnUnmount?: boolean;
   /**
    * Enables drag-and-drop features.
    *
@@ -2780,6 +2832,16 @@ interface QueryBuilderFlags {
    * @default false
    */
   showShiftActions?: boolean;
+  /**
+   * Show the "Undo"/"Redo" actions in the header of the outermost group.
+   *
+   * Requires the `QueryBuilderHistory` component from `react-querybuilder/history`, which
+   * provides the controls and records the history they navigate. Defaults to `true` when a
+   * `QueryBuilderHistory` ancestor is present (pass `false` explicitly to opt out).
+   *
+   * @default false
+   */
+  showUndoRedo?: boolean;
   /**
    * Show the "Clone rule" and "Clone group" buttons.
    *
@@ -3018,6 +3080,9 @@ declare const standardClassnames: {
   readonly valid: "queryBuilder-valid";
   readonly invalid: "queryBuilder-invalid";
   readonly shiftActions: "shiftActions";
+  readonly undoRedoActions: "undoRedoActions";
+  readonly undoAction: "undoRedoActions-undo";
+  readonly redoAction: "undoRedoActions-redo";
   readonly dndDragging: "dndDragging";
   readonly dndOver: "dndOver";
   readonly dndCopy: "dndCopy";
@@ -3078,6 +3143,9 @@ declare const TestID: {
   readonly valueEditor: "value-editor";
   readonly notToggle: "not-toggle";
   readonly shiftActions: "shift-actions";
+  readonly undoRedoActions: "undo-redo-actions";
+  readonly undoAction: "undo-action";
+  readonly redoAction: "redo-action";
   readonly dragHandle: "drag-handle";
   readonly lockRule: "lock-rule";
   readonly lockGroup: "lock-group";
@@ -3116,6 +3184,19 @@ declare const rootPath: Path;
  * @group Defaults
  */
 declare const queryBuilderFlagDefaults: Required<QueryBuilderFlags>;
+/**
+ * Default maximum number of undo steps retained by query history.
+ *
+ * @group Defaults
+ */
+declare const defaultMaxHistory = 50;
+/**
+ * Default time window (in milliseconds) within which consecutive changes to the same
+ * property of the same rule are coalesced into a single undo step.
+ *
+ * @group Defaults
+ */
+declare const defaultCoalesceMs = 500;
 //#endregion
 //#region src/utils/arrayUtils.d.ts
 /**
@@ -3204,6 +3285,119 @@ declare function convertQuery(query: RuleGroupType): RuleGroupTypeIC;
  */
 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;
+/**
+ * A classname applied only when `when` returns true for the current state.
+ *
+ * `key` is used to look up both the standard classname and the corresponding `controlClassnames`
+ * entry. Set `standardOnly` when the standard class is conditional but no custom class
+ * corresponds to it.
+ */
+interface ClassnameCondition<S> {
+  key: StandardClassnameKey;
+  when: (state: S) => boolean | undefined;
+  standardOnly?: 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.
+ */
+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;
+}
+/**
+ * Classnames for each element rendered by a rule. This is the framework-agnostic core of the
+ * `classNames` object returned by the `useRule` hook.
+ *
+ * @group Query Tools
+ */
+declare const deriveRuleClassNames: (options: DeriveClassNamesOptions) => Record<RuleClassnameKey, string>;
+/**
+ * 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 Query Tools
+ */
+declare const deriveRuleClassName: (key: RuleClassnameKey, options: DeriveClassNamesOptions) => string;
+/**
+ * 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 Query Tools
+ */
+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 {}
+/**
+ * The outer (wrapper) classname for a rule, including every conditional state class.
+ *
+ * @group Query Tools
+ */
+declare const deriveRuleOuterClassName: (options: OuterClassNameOptions) => string;
+/**
+ * The outer (wrapper) classname for a rule group, including every conditional state class.
+ *
+ * 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 deriveRuleGroupOuterClassName: (options: OuterClassNameOptions) => string;
+/**
+ * The outer (wrapper) classname for the query builder itself, including the conditional
+ * `disabled`, `valid`, and `invalid` state classes.
+ *
+ * @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
@@ -3212,6 +3406,229 @@ declare function convertQuery(query: RuleGroupTypeIC): RuleGroupType;
  */
 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>;
+}
+/**
+ * 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`.
+ */
+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.
+ *
+ * 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 deriveRuleContext: <F extends FullField = FullField>(rule: RuleType, resolvers: RuleContextResolvers<F>, options?: {
+  validationMap?: ValidationMap;
+  id?: string;
+}) => RuleContext<F>;
+/**
+ * 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).
+ *
+ * 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 getRuleGroupCombinator: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>) => string;
+/**
+ * Resolves everything about a rule group that depends on the combinator configuration, plus its
+ * validation result.
+ *
+ * Note that unlike {@link deriveRuleContext}, there is no field-level validator fallback—a
+ * group's validation result comes only from the query-level {@link ValidationMap}.
+ *
+ * @group Query Tools
+ */
+declare const deriveRuleGroupContext: <C extends FullCombinator = FullCombinator>(ruleGroup: RuleGroupTypeAny, combinators: FullOptionList<C>, options?: {
+  validationMap?: ValidationMap;
+  id?: string;
+}) => RuleGroupContext<C>;
+//#endregion
+//#region src/utils/deriveValueEditor.d.ts
+/**
+ * Whether an operator's value is a list of two bounds.
+ *
+ * @group Value Editors
+ */
+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;
+};
+/**
+ * Produces the next value for a series of value editors when the editor at `index` changes.
+ *
+ * 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 getMultiValueUpdate: ({ value, index, valueAsArray, operator, values, listsAsArrays, parseNumberMethod }: {
+  value: unknown;
+  index: number;
+  valueAsArray: unknown[];
+  operator: string;
+  values?: any[];
+  listsAsArrays?: boolean;
+  parseNumberMethod?: ParseNumberMethod;
+}) => unknown;
+/**
+ * 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 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.
+ *
+ * @group Value Editors
+ */
+declare const coerceInputType: (inputType: InputType | null | undefined, operator: string) => InputType;
+/**
+ * Produces the next value for a value selector. Multiselect values are normalized to an array
+ * first, then comma-joined unless `listsAsArrays` is `true`. Single-select values pass through.
+ *
+ * @group Value Editors
+ */
+declare const getValueSelectorUpdate: (value: string | string[], { multiple, listsAsArrays }?: {
+  multiple?: boolean;
+  listsAsArrays?: boolean;
+}) => string | string[];
+/**
+ * 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 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
@@ -4155,7 +4572,7 @@ interface GetRuleDefaultValueOptions<F extends FullField = FullField> {
  *
  * @group Option Lists
  */
-declare const getRuleDefaultValue: <F extends FullField = FullField>(rule: RuleType, options: GetRuleDefaultValueOptions<F>) => unknown;
+declare const getRuleDefaultValue$1: <F extends FullField = FullField>(rule: RuleType, options: GetRuleDefaultValueOptions<F>) => unknown;
 //#endregion
 //#region src/utils/getValidationClassNames.d.ts
 /**
@@ -4264,6 +4681,85 @@ declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value:
  */
 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.
+ */
+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;
+}
+/**
+ * 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 Option Lists
+ */
+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>;
+/**
+ * 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 Option Lists
+ */
+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;
+/**
+ * Resolves the value editor type for a field/operator pair, applying the same precedence as the
+ * `QueryBuilder` component: the field's own `valueEditorType` (a string or a function of the
+ * operator), then the `getValueEditorType` callback, then `"text"`.
+ *
+ * @group Option Lists
+ */
+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;
+/**
+ * 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 Option Lists
+ */
+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
 /**
  * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
@@ -4456,6 +4952,29 @@ declare const getCommonAncestorPath: (path1: Path, path2: Path) => Path;
  * 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.
+ *
+ * @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 Paths
+ */
+declare const derivePathInfo: (path: Path, childCount: number, { disabled, disabledPaths }?: {
+  disabled?: boolean;
+  disabledPaths?: Path[];
+}) => PathInfo[];
 //#endregion
 //#region src/utils/preferProp.d.ts
 /**
@@ -4494,39 +5013,232 @@ declare const prepareRuleGroup: <RG extends RuleGroupTypeAny>(queryObject: 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/queryTools.d.ts
+//#region src/utils/queryActions.d.ts
 /**
- * Options for {@link add}.
+ * 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 AddOptions {
-  /**
-   * 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`.
-   */
+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;
   /**
-   * 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`.
+   * Honor `disabled` properties within the query. Defaults to `true`, matching the
+   * `QueryBuilder` component; a node's own `disabled` property can always be changed.
    */
-  combinatorPreceding?: string;
+  respectDisabled?: boolean;
   /**
-   * ID generator.
+   * 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.
    */
-  idGenerator?: () => string;
+  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;
 }
-interface AddMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, ruleOrGroup: RG | RuleType, parentPathOrID: Path | string, options?: AddOptions): RG;
+/**
+ * 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;
 }
 /**
- * Adds a rule or group to a query without mutating the original query.
+ * Builds the query builder's six mutation handlers as pure functions of the current query.
  *
- * @returns A new query with the rule or group added.
+ * 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
+ */
+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;
+}
+/**
+ * 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 const getGuardAbortReason: (query: RuleGroupTypeAny, pathOrID: Path | string | undefined, guards?: GuardOptions, { asParent }?: {
+  asParent?: boolean;
+}) => AbortReason | null;
+/**
+ * Whether adding a group beneath `parentPath` would exceed `maxLevels`.
+ *
+ * @group Query Tools
+ */
+declare const exceedsMaxLevels: (parentPath: Path | undefined, { maxLevels }?: GuardOptions) => boolean;
+/**
+ * Options for {@link add}.
+ *
+ * @group Query Tools
+ */
+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;
+}
+/**
+ * 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
  */
@@ -4544,7 +5256,7 @@ declare const addInPlace: AddMethod;
  *
  * @group Query Tools
  */
-interface UpdateOptions {
+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`.
@@ -4610,8 +5322,14 @@ declare const update: UpdateMethod;
  * @group Query Tools
  */
 declare const updateInPlace: UpdateMethod;
+/**
+ * Options for {@link remove}.
+ *
+ * @group Query Tools
+ */
+interface RemoveOptions extends AbortOptions {}
 interface RemoveMethod {
-  <RG extends RuleGroupTypeAny>(query: RG, pathOrID: Path | string): RG;
+  <RG extends RuleGroupTypeAny>(query: RG, pathOrID: Path | string, options?: RemoveOptions): RG;
 }
 /**
  * Removes a rule or group from a query without mutating the original query.
@@ -4634,7 +5352,7 @@ declare const removeInPlace: RemoveMethod;
  *
  * @group Query Tools
  */
-interface MoveOptions {
+interface MoveOptions extends AbortOptions {
   /**
    * When `true`, the source rule/group will not be removed from its original path.
    */
@@ -4676,7 +5394,7 @@ declare const moveInPlace: MoveMethod;
  *
  * @group Query Tools
  */
-interface InsertOptions {
+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
@@ -4733,7 +5451,7 @@ declare const insertInPlace: InsertMethod;
  *
  * @group Query Tools
  */
-interface GroupOptions {
+interface GroupOptions extends AbortOptions {
   /**
    * When `true`, the source rule/group will not be removed from its original path.
    */
@@ -4773,24 +5491,6 @@ declare const group: GroupMethod;
  */
 declare const groupInPlace: GroupMethod;
 //#endregion
-//#region src/utils/regenerateIDs.d.ts
-/**
- * Options object for {@link regenerateID}/{@link regenerateIDs}.
- */
-interface RegenerateIdOptions {
-  idGenerator?: () => string;
-}
-/**
- * Generates a new `id` property for a rule.
- */
-declare const regenerateID: <R extends RuleType>(rule: R, { idGenerator }?: RegenerateIdOptions) => SetRequired<R, "id">;
-/**
- * Recursively generates new `id` properties for a rule group and all its rules and subgroups.
- */
-declare const regenerateIDs: <RG>(subject: RG, { idGenerator }?: RegenerateIdOptions) => RG & {
-  id: string;
-};
-//#endregion
 //#region src/utils/transformQuery.d.ts
 /**
  * Options object for {@link index!transformQuery transformQuery}.
@@ -4904,5 +5604,660 @@ declare function transformQuery(query: RuleGroupType, options?: TransformQueryOp
  */
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
-export { AccessibleDescriptionGenerator, ActionElementEventHandler, AddMethod, AddOptions, Arity, BaseFullOption, BaseOption, BaseOptionMap, BaseTranslation, BaseTranslationWithLabel, BaseTranslationWithPlaceholders, BaseTranslations, BaseTranslationsFull, Classname, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DiagnosticEntry, DiagnosticsFieldSummaryEntry, DiagnosticsResult, DiagnosticsStats, 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, 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, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, Placeholder, PrepareOptionListParams, PreparedOptionList, PreparerOptions, QueryActions, QueryBuilderFlags, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveMethod, RemoveNullability, RuleDiagnosticsResult, RuleGroupArray, RuleGroupDiagnosticsArray, RuleGroupDiagnosticsResult, RuleGroupICArray, RuleGroupICDiagnosticsArray, RuleGroupICDiagnosticsResult, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, 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, WithRequired, WithUnknownIndex, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, cypherCombinatorMap, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, 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, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getLikeWildcards, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue, getSQLConcat, getSubqueryElementAlias, getValidationClassNames, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, inOperators, insert, insertInPlace, isAncestor, 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, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, rootPath, shouldRenderAsNumber, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, stripParamPrefix, subqueryElementAliasBase, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, withParamPrefix, wrapLikeFragment };
+//#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.
+ *
+ * @group Query Tools
+ */
+declare class QueryManagerError extends Error {
+  /** Why the operation was aborted. */
+  readonly code: AbortReason;
+  /** Full details about the aborted operation. */
+  readonly info: AbortInfo;
+  constructor(info: AbortInfo);
+}
+/**
+ * Per-call overrides for {@link QueryManager}'s abort handling. Every mutating method accepts
+ * these alongside the options of the query tool it delegates to.
+ *
+ * @group Query Tools
+ */
+interface StrictOptions {
+  /**
+   * Throw a {@link QueryManagerError} when an operation is aborted for one of the
+   * {@link strictAbortReasons}. Overrides the manager's own `strict` option.
+   */
+  strict?: boolean;
+  /**
+   * Called whenever an operation is aborted, including for the non-error reasons
+   * `"same-location"` and `"no-change"`. Runs before any `strict` throw, so an operation can be
+   * both observed and enforced. Overrides the manager's own `onInvalidTarget` option.
+   */
+  onInvalidTarget?: (info: AbortInfo) => void;
+}
+/**
+ * Options for {@link QueryManager}. Mirrors the subset of
+ * {@link react-querybuilder!QueryBuilder QueryBuilder} props that affect query
+ * _structure_ rather than rendering, so the same configuration objects can drive both.
+ *
+ * @group Query Tools
+ */
+interface QueryManagerOptions<F extends FullField = FullField, O extends FullOperator = FullOperator, C extends FullCombinator = FullCombinator> {
+  /** The fields available for rules. Accepts the same shapes as the `fields` prop. */
+  fields?: FlexibleOptionListProp<F> | BaseOptionMap<F>;
+  /** The operators available for rules. Accepts the same shapes as the `operators` prop. */
+  operators?: FlexibleOptionListProp<O> | BaseOptionMap<O>;
+  /** The combinators available for groups. Defaults to `defaultCombinators`. */
+  combinators?: FlexibleOptionListProp<C> | BaseOptionMap<C>;
+  /** Properties applied to every field in `fields`. */
+  baseField?: Record<string, unknown>;
+  /** Properties applied to every operator in `operators`. */
+  baseOperator?: Record<string, unknown>;
+  /** Properties applied to every combinator in `combinators`. */
+  baseCombinator?: Record<string, unknown>;
+  /** When `false`, an empty placeholder option is prepended to the field list. */
+  autoSelectField?: boolean;
+  /** When `false`, an empty placeholder option is prepended to each operator list. */
+  autoSelectOperator?: boolean;
+  /** When `false`, an empty placeholder option is prepended to each value list. */
+  autoSelectValue?: boolean;
+  /** The default `field` for rules created by {@link QueryManager.createRule}. */
+  getDefaultField?: string | ((fieldsData: FullOptionList<F>) => string);
+  /** The default `operator` for a given field. */
+  getDefaultOperator?: string | ((field: string, misc: {
+    fieldData: F;
+  }) => string);
+  /** Overrides the computed default `value` for a new rule. */
+  getDefaultValue?: (rule: RuleType, misc: {
+    fieldData: F;
+  }) => unknown;
+  /** The operators available for a given field. */
+  getOperators?: (field: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<O> | null;
+  /** The value editor type for a given field/operator, which informs the default value. */
+  getValueEditorType?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => ValueEditorType;
+  /** The value list for a given field/operator, which informs the default value. */
+  getValues?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<Option>;
+  /** The valid value sources for a given field/operator. */
+  getValueSources?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => ValueSources | ValueSourceFlexibleOptions;
+  /** The valid match modes for a given field. */
+  getMatchModes?: (field: string, misc: {
+    fieldData: F;
+  }) => boolean | MatchMode[] | FlexibleOption<MatchMode>[];
+  /** The named parameters available for a given field/operator. */
+  getParameters?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => FlexibleOptionList<Option> | null;
+  /** When `true`, multi-value defaults are arrays instead of comma-joined strings. */
+  listsAsArrays?: boolean;
+  /** When `true`, groups created by {@link QueryManager.createRuleGroup} contain one new rule. */
+  addRuleToNewGroups?: boolean;
+  /**
+   * When updating a rule's `field`, reset its `operator`, `value`, and `valueSource` to their
+   * defaults. Defaults to `true`, matching the `QueryBuilder` prop of the same name.
+   */
+  resetOnFieldChange?: boolean;
+  /**
+   * When updating a rule's `operator`, reset its `value` to the default. Defaults to `false`,
+   * matching the `QueryBuilder` prop of the same name.
+   */
+  resetOnOperatorChange?: boolean;
+  /**
+   * The maximum depth at which groups may be added. As with the `QueryBuilder` prop of the same
+   * name, a non-positive value means unlimited. Defaults to `Infinity`.
+   */
+  maxLevels?: number;
+  /**
+   * Honor `disabled` properties within the query, so mutations targeting a disabled rule or
+   * group (or a descendant of a disabled group) are aborted. Updating a node's own `disabled`
+   * property is always permitted. Defaults to `true`, matching the `QueryBuilder` component;
+   * pass `false` to mutate freely regardless of the property.
+   */
+  respectDisabled?: boolean;
+  /**
+   * Paths that are disabled without the corresponding rule or group carrying a `disabled`
+   * property. This mirrors the array form of the `QueryBuilder` `disabled` prop
+   * (e.g. `disabled={[[2]]}`), which disables nodes by position rather than by data.
+   *
+   * A path is treated as disabled if it appears here or descends from a path that does. Honored
+   * only when `respectDisabled` is `true`; as with the `disabled` property, a node's own
+   * `disabled` can always be changed so it is never permanently locked.
+   */
+  disabledPaths?: Path[];
+  /** Abort every mutation, as though the entire query were disabled. Defaults to `false`. */
+  queryDisabled?: boolean;
+  /** The input type for a given field/operator, surfaced by {@link QueryManager.getRuleContext}. */
+  getInputType?: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => InputType | null;
+  /** Extra props for a subquery builder, surfaced by {@link QueryManager.getRuleContext}. */
+  getSubQueryBuilderProps?: (field: string, misc: {
+    fieldData: F;
+  }) => Record<string, unknown>;
+  /**
+   * Enables undo/redo recording. Pass `true` for the defaults, or an object to configure
+   * `maxHistory` and/or `coalesceMs`. Disabled by default, so instances that never undo
+   * retain no extra references.
+   */
+  history?: boolean | QueryHistoryOptions;
+  /**
+   * Throw a {@link QueryManagerError} when a mutation is aborted because its target could not
+   * be used. Disabled by default, in which case such mutations are silent no-ops. Can be
+   * overridden per call.
+   */
+  strict?: boolean;
+  /**
+   * Called whenever a mutation is aborted, including for the non-error reasons
+   * `"same-location"` and `"no-change"`. Can be overridden per call.
+   */
+  onInvalidTarget?: (info: AbortInfo) => void;
+  /** Validates the query. Defaults to {@link defaultValidator}. */
+  validator?: QueryValidator;
+  /** Generates `id` properties for new rules and groups. Defaults to {@link generateID}. */
+  idGenerator?: () => string;
+  /**
+   * Clock used to time history coalescing. Defaults to `Date.now`.
+   *
+   * @internal Test seam. Exists so that history recording can be compared against the
+   * `react-querybuilder/history` implementation without depending on wall-clock timing.
+   */
+  now?: () => number;
+}
+/**
+ * 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 `[]`. */
+  path: Path;
+  /** The group containing `node`, or `null` for the root group. */
+  parent: RG | null;
+}
+/**
+ * Options for {@link QueryManager.walk} and its derivatives.
+ *
+ * @group Query Tools
+ */
+interface WalkOptions {
+  /**
+   * Traverse only the subtree rooted at this path or `id` instead of the whole query. The node
+   * itself is visited first. When the path or `id` can't be resolved, nothing is visited.
+   */
+  from?: Path | string;
+  /** Visit only rules. Groups are still traversed, just not yielded (except as `parent`). */
+  rulesOnly?: boolean;
+  /** Visit only groups. */
+  groupsOnly?: boolean;
+}
+/**
+ * Coerces the result of a conditional query type back into something assignable to
+ * {@link QueryManager}'s `RG` parameter, which TypeScript cannot verify on its own.
+ */
+type AsRuleGroup<T> = T extends RuleGroupTypeAny ? T : RuleGroupTypeAny;
+/**
+ * Stateful wrapper around the {@link add}/{@link remove}/{@link update}/{@link move}/
+ * {@link insert}/{@link group} query tools, plus rule/group factories, {@link defaultValidator
+ * validation}, and {@link formatQuery formatting}.
+ *
+ * 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.
+ *
+ * ```ts
+ * const q = new QueryManager(undefined, { fields });
+ * q.add(q.createRule()).add({ field: 'firstName', operator: '=', value: 'Steve' });
+ * q.format('sql');
+ * ```
+ *
+ * Like the underlying query tools, methods are a no-op when the target path or `id` can't be
+ * resolved (including attempts to remove the root group). By default nothing is thrown; pass
+ * `strict: true` to raise a {@link QueryManagerError} instead, or `onInvalidTarget` to observe
+ * aborted operations without changing control flow.
+ *
+ * @group Query Tools
+ */
+declare class QueryManager<RG extends RuleGroupTypeAny = RuleGroupType, F extends FullField = FullField, O extends FullOperator = FullOperator, C extends FullCombinator = FullCombinator> {
+  #private;
+  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.
+   *
+   * 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`).
+   */
+  getQuery: () => RG;
+  /** Replaces the current query, ensuring every rule and group has an `id`. */
+  setQuery(query: RG): this;
+  /**
+   * Creates a rule using the configured fields, operators, and defaults. The rule is not added
+   * to the query—pass it to {@link QueryManager.add} or {@link QueryManager.insert}.
+   */
+  createRule(): RuleType;
+  /**
+   * Creates a group. Pass `true` for a group with independent combinators. The group is not
+   * added to the query—pass it to {@link QueryManager.add} or {@link QueryManager.insert}.
+   */
+  createRuleGroup(independentCombinators?: boolean): RG;
+  /**
+   * Adds a rule or group to the end of the group at `parentPathOrID`, which defaults to the
+   * root group.
+   */
+  add(ruleOrGroup: RG | RuleType, parentPathOrID?: Path | string, options?: AddOptions & StrictOptions): this;
+  /** Removes the rule or group at the given path or `id`. The root group cannot be removed. */
+  remove(pathOrID: Path | string, options?: RemoveOptions & StrictOptions): this;
+  /** Updates a single property of the rule or group at the given path or `id`. */
+  update(prop: UpdateableProperties, value: unknown, pathOrID: Path | string, options?: UpdateOptions & StrictOptions): this;
+  /** Updates multiple properties using parallel arrays of names and values. */
+  update(props: UpdateableProperties[], values: unknown[], pathOrID: Path | string, options?: UpdateOptions & StrictOptions): this;
+  /** Updates multiple properties using a map of names to values. */
+  update(props: UpdateValueMap, pathOrID: Path | string, options?: UpdateOptions & StrictOptions): this;
+  /** Moves the rule or group at `oldPathOrID` to `newPath`, or shifts it `'up'`/`'down'`. */
+  move(oldPathOrID: Path | string, newPath: Path | "up" | "down", options?: MoveOptions & StrictOptions): this;
+  /**
+   * Inserts a rule or group at the given path. Unlike the other methods, this accepts a path
+   * only—inserting _at_ an `id` would be ambiguous.
+   */
+  insert(ruleOrGroup: RG | RuleType, path: Path, options?: InsertOptions & StrictOptions): this;
+  /**
+   * Creates a new group at `targetPathOrID` containing the rules/groups currently at
+   * `targetPathOrID` and `sourcePathOrID`.
+   */
+  group(sourcePathOrID: Path | string, targetPathOrID: Path | string, options?: GroupOptions & StrictOptions): this;
+  /**
+   * Creates an independent manager with the same configuration and the current query.
+   *
+   * Subscribers and history are _not_ carried over: the clone starts with no listeners and an
+   * empty undo stack. Because every mutation produces a new query object, the two managers
+   * share the initial query safely and diverge from the first change.
+   *
+   * Pass `{ regenerateIDs: true }` to give every rule and group in the clone a new `id`, which
+   * is useful when both queries will be used together (e.g. inserted into the same tree).
+   */
+  clone(options?: {
+    regenerateIDs?: boolean;
+  }): QueryManager<RG, F, O, C>;
+  /**
+   * Registers a listener called after every change to the query, and returns a function that
+   * unregisters it. Mutations that resolve to a no-op do not notify, and a
+   * {@link QueryManager.batch batch} notifies once no matter how many changes it contains.
+   *
+   * Together with {@link QueryManager.getQuery}, this satisfies React's `useSyncExternalStore`
+   * contract. Both methods are bound to the instance, so they are stable references across
+   * renders and can be passed directly:
+   *
+   * ```ts
+   * const query = useSyncExternalStore(q.subscribe, q.getQuery);
+   * ```
+   *
+   * In React, prefer the `useQueryManager` hook from `react-querybuilder`, which wraps this.
+   */
+  subscribe: (listener: () => 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
+   * the query ends up unchanged.
+   *
+   * Batches may be nested; only the outermost one commits. If `fn` throws, the query and its
+   * history are restored to their pre-batch state and the error propagates, so a batch either
+   * applies completely or not at all.
+   *
+   * {@link QueryManager.undo}, {@link QueryManager.redo}, and {@link QueryManager.clearHistory}
+   * may be called inside a batch; their notifications are deferred like everything else. Because
+   * they manage the history stacks themselves, a batch containing one of them records no entry of
+   * its own, leaving the stacks exactly as those methods left them.
+   */
+  batch(fn: () => void): this;
+  /** Whether there is a previous query to restore. Always `false` unless `history` is enabled. */
+  canUndo(): boolean;
+  /** Whether there is an undone query to restore. Always `false` unless `history` is enabled. */
+  canRedo(): boolean;
+  /** Restores the previous query. No-op when {@link QueryManager.canUndo} is `false`. */
+  undo(): this;
+  /** Restores the most recently undone query. No-op when {@link QueryManager.canRedo} is `false`. */
+  redo(): this;
+  /** Discards all undo/redo history without changing the current query. */
+  clearHistory(): this;
+  /**
+   * The recorded history: `past` oldest first, `future` newest first. Both are copies, so
+   * mutating them does not affect the manager.
+   */
+  getHistory(): {
+    past: RG[];
+    future: RG[];
+  };
+  /**
+   * Validates the current query with the configured validator.
+   *
+   * The result is cached until the query changes, so a custom `validator` with side effects (or
+   * one that depends on anything other than the query) may run fewer times than expected.
+   */
+  validate(): boolean | ValidationMap;
+  /** Generates a JSON string from the current query. */
+  format(): string;
+  /** Generates a result based on the provided rule group processor. */
+  format<TResult = unknown>(options: FormatQueryOptions & {
+    ruleGroupProcessor: RuleGroupProcessor<TResult>;
+  }): TResult;
+  /** Generates a {@link ParameterizedSQL} object from the current query. */
+  format(options: "parameterized" | (FormatQueryOptions & {
+    format: "parameterized";
+  })): ParameterizedSQL;
+  /** Generates a {@link ParameterizedNamedSQL} object from the current query. */
+  format(options: "parameterized_named" | (FormatQueryOptions & {
+    format: "parameterized_named";
+  })): ParameterizedNamedSQL;
+  /** Generates a JsonLogic object from the current query. */
+  format(options: "jsonlogic" | (FormatQueryOptions & {
+    format: "jsonlogic";
+  })): RQBJsonLogic;
+  /** Generates an ElasticSearch query object from the current query. */
+  format(options: "elasticsearch" | (FormatQueryOptions & {
+    format: "elasticsearch";
+  })): Record<string, any>;
+  /** Generates a MongoDB query object from the current query. */
+  format(options: "mongodb_query" | (FormatQueryOptions & {
+    format: "mongodb_query";
+  })): Record<string, any>;
+  /** Generates a Prisma ORM query object from the current query. */
+  format(options: "prisma" | (FormatQueryOptions & {
+    format: "prisma";
+  })): Record<string, any>;
+  /** Generates a Drizzle ORM query object from the current query. */
+  format(options: "drizzle" | (FormatQueryOptions & {
+    format: "drizzle";
+  })): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
+  /** Generates a TanStack DB query object from the current query. */
+  format(options: "tanstack_db" | (FormatQueryOptions & {
+    format: "tanstack_db";
+  })): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
+  /** Generates a Sequelize ORM query object from the current query. */
+  format(options: "sequelize" | (FormatQueryOptions & {
+    format: "sequelize";
+  })): ReturnType<typeof defaultRuleGroupProcessorSequelize>;
+  /** Generates a diagnostics result from the current query. */
+  format(options: "diagnostics" | (FormatQueryOptions & {
+    format: "diagnostics";
+  })): DiagnosticsResult;
+  /** Generates a query string in the requested format. */
+  format(options: Exclude<ExportFormat, ExportObjectFormats>): string;
+  /** Generates a query string in the requested format. */
+  format(options: FormatQueryOptions & {
+    format: Exclude<ExportFormat, ExportObjectFormats>;
+  }): string;
+  /** Generates a query string in the requested format. */
+  format(options: FormatQueryOptions): string;
+  /**
+   * Yields every rule and group in the query, depth-first in pre-order, starting with the root
+   * group itself. Combinator strings in independent-combinator groups are skipped.
+   *
+   * ```ts
+   * for (const { node, path, parent } of qm.walk({ rulesOnly: true })) {
+   *   console.log(path, node.field);
+   * }
+   * ```
+   *
+   * Traversal operates on the query as it was when iteration began, so mutating the manager
+   * mid-iteration does not affect a walk already in progress. Because generators are lazy, that
+   * happens on the first iteration step rather than when `walk` is called.
+   *
+   * @yields Every rule and group in the query, subject to `options`.
+   */
+  walk(options?: WalkOptions): Generator<QueryNode<RG>>;
+  /** Yields every rule in the query. Shorthand for `walk({ ...options, rulesOnly: true })`. */
+  rules(options?: Omit<WalkOptions, "rulesOnly" | "groupsOnly">): Generator<QueryNode<RG>>;
+  /**
+   * Yields every group in the query, including the root group. Shorthand for
+   * `walk({ ...options, groupsOnly: true })`.
+   */
+  groups(options?: Omit<WalkOptions, "rulesOnly" | "groupsOnly">): Generator<QueryNode<RG>>;
+  /** Returns the first node matching `predicate`, or `null` if there is none. */
+  find(predicate: (entry: QueryNode<RG>) => boolean, options?: WalkOptions): QueryNode<RG> | null;
+  /** Returns every node matching `predicate`. */
+  filter(predicate: (entry: QueryNode<RG>) => boolean, options?: WalkOptions): QueryNode<RG>[];
+  /** Equivalent to {@link QueryManager.walk} with no options, enabling `for...of` and spread. */
+  [Symbol.iterator](): Generator<QueryNode<RG>>;
+  /**
+   * Returns the rule or group at the given path, or `null` if the path can't be resolved.
+   *
+   * Unlike the standalone {@link findPath}, which can return `undefined` for an out-of-range
+   * index, unresolvable paths are always normalized to `null` here.
+   */
+  findPath(path: Path): FindPathReturnType;
+  /**
+   * Returns the rule or group with the given `id`, or `null` if there is none. Backed by an
+   * index built once per query, so repeated lookups are constant time.
+   */
+  findID(id: string): FindPathReturnType;
+  /**
+   * Returns the {@link Path} of the rule or group with the given `id`, or `null` if there is
+   * none. Backed by an index built once per query, so repeated lookups are constant time.
+   */
+  getPathOfID(id: string): Path | null;
+  /**
+   * Determines whether the rule or group at the given path is disabled, either itself or by an
+   * ancestor group.
+   */
+  pathIsDisabled(path: Path): boolean;
+  /** Returns the rule or group at the given path or `id`, or `null` if it can't be resolved. */
+  getNode(pathOrID: Path | string): FindPathReturnType;
+  /**
+   * Returns the rule at the given path or `id`, or `null` if it can't be resolved _or_ resolves
+   * to a group.
+   */
+  getRule(pathOrID: Path | string): RuleType | null;
+  /**
+   * Returns the group at the given path or `id`, or `null` if it can't be resolved _or_
+   * resolves to a rule.
+   */
+  getGroup(pathOrID: Path | string): RG | null;
+  /**
+   * Returns the group containing the rule or group at the given path or `id`. Returns `null`
+   * for the root group, which has no parent, and when the target can't be resolved.
+   */
+  getParent(pathOrID: Path | string): RG | null;
+  /**
+   * The normalized field list, as the `QueryBuilder` component would render it. Needed to
+   * populate a field selector.
+   */
+  getFields(): FullOptionList<F>;
+  /**
+   * The normalized combinator list, as the `QueryBuilder` component would render it. Needed to
+   * populate a combinator selector.
+   */
+  getCombinators(): FullOptionList<C>;
+  /**
+   * The field configuration for a field name. When the field isn't configured, returns the same
+   * minimal fallback (`{ name, value, label }`, all set to the field name) that
+   * {@link QueryManager.getRuleContext} reports as `fieldData`, so both access paths agree.
+   */
+  getFieldData(field: string): F;
+  /** The operator list for a field, mirroring `QueryBuilder`'s precedence. */
+  getOperators(field: string): FullOptionList<O>;
+  /** The value sources available for a field/operator pair. */
+  getValueSources(field: string, operator: string): ValueSourceFullOptions;
+  /** The match modes available for a field. */
+  getMatchModes(field: string): MatchModeOptions;
+  /** The value option list for a field/operator pair. */
+  getValues(field: string, operator: string): FullOptionList<Option>;
+  /** The value editor type for a field/operator pair. */
+  getValueEditorType(field: string, operator: string): ValueEditorType;
+  /**
+   * 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.
+   * Returns `null` when the target can't be resolved or isn't a rule.
+   *
+   * This is the same derivation the `useRule` hook performs, so a non-React implementation can
+   * render a rule without reimplementing the configuration precedence rules.
+   */
+  getRuleContext(pathOrID: Path | string): RuleContext<F> | null;
+  /**
+   * Resolves everything about a rule group that depends on the combinator configuration, plus its
+   * validation result. Returns `null` when the target can't be resolved or isn't a group.
+   *
+   * This is the same derivation the `useRuleGroup` hook performs.
+   */
+  getRuleGroupContext(pathOrID?: Path | string): RuleGroupContext<C> | null;
+  /** Whether the current query uses independent combinators. */
+  isIC(): boolean;
+  /**
+   * Returns the signature describing how the current query differs from `other`, as used by
+   * this manager's history coalescing.
+   */
+  signatureOf(other: RuleGroupTypeAny): string;
+  /** Generates a {@link DiagnosticsResult}. Shorthand for `format('diagnostics')`. */
+  diagnostics(): DiagnosticsResult;
+  /**
+   * Returns the current query, so `JSON.stringify(queryManager)` produces the same output as
+   * `JSON.stringify(queryManager.getQuery())`.
+   */
+  toJSON(): RG;
+  /**
+   * Returns a new manager with the same configuration and the current query converted to use
+   * independent combinators. Idempotent, and never modifies this manager. As with
+   * {@link QueryManager.clone}, subscribers and history are not carried over.
+   */
+  toIC(): QueryManager<AsRuleGroup<ToRuleGroupTypeIC<RG>>, F, O, C>;
+  /**
+   * Returns a new manager with the same configuration and the current query converted to use a
+   * single combinator per group. Idempotent, and never modifies this manager. As with
+   * {@link QueryManager.clone}, subscribers and history are not carried over.
+   */
+  fromIC(): QueryManager<AsRuleGroup<ToRuleGroupType<RG>>, F, O, C>;
+  /**
+   * Runs {@link transformQuery} against the current query and returns its result.
+   *
+   * Unlike {@link QueryManager.toIC}/{@link QueryManager.fromIC}, this returns the raw
+   * transformed value rather than a new manager, since `transformQuery` can produce arbitrary
+   * shapes that are no longer valid queries. This manager is never modified.
+   */
+  transform<T = any>(options?: TransformQueryOptions<RG>): T;
+}
+//#endregion
+//#region src/utils/regenerateIDs.d.ts
+/**
+ * Options object for {@link regenerateID}/{@link regenerateIDs}.
+ */
+interface RegenerateIdOptions {
+  idGenerator?: () => string;
+}
+/**
+ * Generates a new `id` property for a rule.
+ */
+declare const regenerateID: <R extends RuleType>(rule: R, { idGenerator }?: RegenerateIdOptions) => SetRequired<R, "id">;
+/**
+ * Recursively generates new `id` properties for a rule group and all its rules and subgroups.
+ */
+declare const regenerateIDs: <RG>(subject: RG, { idGenerator }?: RegenerateIdOptions) => RG & {
+  id: string;
+};
+//#endregion
+//#region src/utils/ruleFactory.d.ts
+/**
+ * Everything {@link createRule} needs to produce a new rule. Each member corresponds to the
+ * `QueryBuilder` prop (or `useQueryBuilderSetup` output) of the same name.
+ */
+interface CreateRuleOptions<F extends FullField = FullField> {
+  fields: FullOptionList<F>;
+  getDefaultField?: string | ((fieldsData: FullOptionList<F>) => string);
+  /** Produces the default operator for a field, i.e. `resolveDefaultOperator` already bound. */
+  getRuleDefaultOperator: (field: string) => string;
+  /** Produces the value sources for a field/operator pair. */
+  getValueSources: (field: string, operator: string, misc: {
+    fieldData: F;
+  }) => ValueSourceFullOptions;
+  /** Produces the match modes for a field. */
+  getMatchModes: (field: string, misc: {
+    fieldData: F;
+  }) => MatchModeOptions;
+  /** Produces the default `value` for an otherwise-complete rule. */
+  getRuleDefaultValue: (rule: RuleType) => unknown;
+  idGenerator?: () => string;
+}
+/**
+ * Creates a rule from the given configuration, applying the same precedence as the
+ * `QueryBuilder` component. The `value` is computed in a second pass, once `field`, `operator`,
+ * and `valueSource` are known, since the default value depends on all three.
+ *
+ * @group Query Tools
+ */
+declare const createRule: <F extends FullField = FullField>({ fields, getDefaultField, getRuleDefaultOperator, getValueSources, getMatchModes, getRuleDefaultValue, idGenerator }: CreateRuleOptions<F>) => RuleType;
+/**
+ * Everything {@link createRuleGroup} needs to produce a new group.
+ */
+interface CreateRuleGroupOptions<C extends FullCombinator = FullCombinator> {
+  combinators: FullOptionList<C>;
+  /** When `true`, the new group contains one new rule. */
+  addRuleToNewGroups?: boolean;
+  /** Produces that rule, i.e. {@link createRule} already bound. */
+  createRule: () => RuleType;
+  idGenerator?: () => string;
+}
+/**
+ * Creates a group from the given configuration. Pass `true` for `independentCombinators` to omit
+ * the `combinator` property.
+ *
+ * The group's own `id` is generated _before_ any contained rule's, matching the order the
+ * `QueryBuilder` component has always used. This is observable when `idGenerator` is
+ * deterministic, as it often is in tests.
+ *
+ * @group Query Tools
+ */
+declare const createRuleGroup: <C extends FullCombinator = FullCombinator>({ combinators, addRuleToNewGroups, createRule: createRuleMain, idGenerator }: CreateRuleGroupOptions<C>, independentCombinators?: boolean) => RuleGroupTypeAny;
+//#endregion
+//#region src/utils/signature.d.ts
+/**
+ * Signature returned when a change alters the _shape_ of the query—rules or groups added,
+ * removed, moved, or reordered—rather than the properties of a single node. Structural changes
+ * never coalesce with each other, so each one produces its own history entry.
+ */
+declare const structuralSignature = "~structural";
+/**
+ * Signature returned when two queries differ by reference only, with no observable difference
+ * in their properties.
+ */
+declare const unchangedSignature = "";
+/**
+ * Describes _what changed_ between two versions of a query as a short string, so that
+ * consecutive edits to the same property of the same rule (e.g. typing in a value editor) can
+ * be recognized and coalesced into a single history entry.
+ *
+ * Returns {@link structuralSignature} for changes to the shape of the query, {@link unchangedSignature} when the
+ * two queries differ by reference only, and `"<id>:<props>"` otherwise.
+ *
+ * The walk prunes on reference equality, so it costs O(depth) rather than O(size) for the
+ * single-node edits that make up the overwhelming majority of changes.
+ *
+ * Note that this relies on the structural sharing that Immer—and therefore every query
+ * produced by RQB's own update functions—guarantees: nodes that did not change keep their
+ * identity. A query that has been wholly rebuilt (deep-cloned, round-tripped through JSON,
+ * re-parsed from a string) shares no identity with its predecessor, so it is reported as
+ * {@link structuralSignature} and will not coalesce. That is a graceful degradation—every change simply
+ * gets its own history entry—but controlled components that clone the query on every change
+ * will not benefit from coalescing.
+ */
+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 };
 //# sourceMappingURL=react-querybuilder_core.d.mts.map