import { $ as ValueProcessorOptions, $t as DefaultRuleGroupType, A as FormatQueryFinalOptions, An as SetRequired, At as ValidationMap, B as RQBJsonLogicStartsWith, Bt as RuleGroupTypeAny, C as DiagnosticEntry, Cn as OptionList, Ct as ValueSource, D as ExportFormat, Dn as ToFullOption, Dt as WithRequired, E as DiagnosticsStats, En as ToFlexibleOption, Et as ValueSources, F as NLTranslations, Fn as IsNever, Ft as DefaultRuleOrGroupArray, G as RuleGroupICDiagnosticsArray, Gt as CommonRuleAndGroupProperties, H as RuleDiagnosticsResult, Ht as RuleOrGroupArray, I as ParameterizedNamedSQL, In as IsAny, It as GenericizeRuleGroupType, J as RuleProcessor, Jt as DefaultCombinatorName, K as RuleGroupICDiagnosticsResult, Kt as DefaultCombinator, L as ParameterizedSQL, Lt as GetRuleGroupType, M as FormatQueryValidateRule, Mt as DefaultRuleGroupICArray, N as GroupVariantCondition, Nn as Simplify, Nt as DefaultRuleGroupTypeAny, O as ExportObjectFormats, On as ValueOption, Ot as QueryValidator, P as NLTranslationKey, Pn as If, Pt as DefaultRuleGroupTypeIC, Q as ValueProcessorLegacy, Qt as DefaultRuleGroupArray, R as RQBJsonLogic, Rt as GetRuleTypeFromGroupWithFieldAndOperator, S as ConstituentWordOrderString, Sn as OptionGroup, St as ValueEditorType, T as DiagnosticsResult, Tn as StringUnionToFullOptionArray, Tt as ValueSourceFullOptions, U as RuleGroupDiagnosticsArray, Ut as ToRuleGroupType, V as RQBJsonLogicVar, Vt as RuleGroupTypeIC, W as RuleGroupDiagnosticsResult, Wt as ToRuleGroupTypeIC, X as ValueProcessor, Xt as DefaultOperator, Y as SQLPreset, Yt as DefaultCombinatorNameExtended, Z as ValueProcessorByRule, Zt as DefaultOperatorName, _ as JsonLogicSome, _n as FullOptionRecord, _t as ParseNumberMethod, a as JsonLogicGreaterThan, an as UpdateableProperties, at as CombinatorByValue, b as JsonLogicVar, bn as NameLabelPair, bt as RemoveNullability, c as JsonLogicInString, cn as BaseOption, ct as FullCombinator, d as JsonLogicNegation, dn as FlexibleOptionGroup, dt as InputType, en as DefaultRuleType, et as AccessibleDescriptionGenerator, f as JsonLogicNone, fn as FlexibleOptionList, ft as MatchConfig, g as JsonLogicRulesLogic, gn as FullOptionMap, gt as OperatorByValue, h as JsonLogicReservedOperations, hn as FullOptionList, ht as Operator, i as JsonLogicEqual, in as UpdateValueMap, it as Combinator, j as FormatQueryOptions, jn as Except, jt as ValidationResult, k as ExportOperatorMap, kn as WithUnknownIndex, kt as RuleValidator, l as JsonLogicLessThan, ln as BaseOptionMap, lt as FullField, m as JsonLogicOr, mn as FullOption, mt as MatchModeOptions, n as JsonLogicAnd, nn as RuleGroupType, nt as Arity, o as JsonLogicGreaterThanOrEqual, on as ExpressionNode, ot as Field, p as JsonLogicNotEqual, pn as FlexibleOptionListProp, pt as MatchMode, q as RuleGroupProcessor, qt as DefaultCombinatorExtended, r as JsonLogicDoubleNegation, rn as RuleType, rt as Classname, s as JsonLogicInArray, sn as BaseFullOption, st as FieldByValue, t as JsonLogicAll, tn as RuleGroupArray, tt as ActionElementEventHandler, u as JsonLogicLessThanOrEqual, un as FlexibleOption, ut as FullOperator, v as JsonLogicStrictEqual, vn as GetOptionIdentifierType, vt as ParseNumbersPropConfig, w as DiagnosticsFieldSummaryEntry, wn as StringUnionToFlexibleOptionArray, wt as ValueSourceFlexibleOptions, x as ConstituentWordOrder, xn as Option, xt as ValueChangeEventHandler, y as JsonLogicStrictNotEqual, yn as GetOptionType, yt as Path, z as RQBJsonLogicEndsWith, zt as RuleGroupICArray } from "./index-DOIE2pwx.mjs";
import "./index-OF2Q1gTp.mjs";
import { n as transformQuery, t as TransformQueryOptions } from "./transformQuery-B7d9AWUf.mjs";
import { produce } from "immer";
//#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).

@category Type
*/
type Primitive = null | undefined | string | number | boolean | symbol | bigint;
//#endregion
//#region ../../node_modules/type-fest/source/internal/type.d.ts
/**
Matches any primitive, `void`, `Date`, or `RegExp` value.
*/
type BuiltIns = Primitive | void | Date | RegExp;
/**
Test if the given function has multiple call signatures.

Needed to handle the case of a single call signature with properties.

Multiple call signatures cannot currently be supported due to a TypeScript limitation.
@see https://github.com/microsoft/TypeScript/issues/29732
*/
type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
  (...arguments_: infer A): unknown;
  (...arguments_: infer B): unknown;
} ? B extends A ? A extends B ? false : true : true : false;
/**
An if-else-like type that resolves depending on whether the given type is `any` or `never`.

@example
```
// When `T` is neither `any` nor `never` (like `string`) => Returns `IfNot` branch
type A = IfNotAnyOrNever<string, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
//=> 'VALID'

// When `T` is `any` => Returns `IfAny` branch
type B = IfNotAnyOrNever<any, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
//=> 'IS_ANY'

// When `T` is `never` => Returns `IfNever` branch
type C = IfNotAnyOrNever<never, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
//=> 'IS_NEVER'
```

Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:

@example
```ts
import type {StringRepeat} from 'type-fest';

type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;

// The following implementation is not tail recursive
type TrimLeft<S extends string> = IfNotAnyOrNever<S, {ifNot: S extends ` ${infer R}` ? TrimLeft<R> : S}>;

// Hence, instantiations with long strings will fail
// @ts-expect-error
type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Error: Type instantiation is excessively deep and possibly infinite.

// To fix this, move the recursion into a helper type
type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, {ifNot: _TrimLeftOptimised<S>}>;

type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;

type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
//=> ''
```
*/
type IfNotAnyOrNever<T, Cases extends {
  ifNot: unknown;
  ifAny?: unknown;
  ifNever?: unknown;
}> = IsAny<T> extends true ? 'ifAny' extends keyof Cases ? Cases['ifAny'] : any : IsNever<T> extends true ? 'ifNever' extends keyof Cases ? Cases['ifNever'] : never : Cases['ifNot'];
//#endregion
//#region ../../node_modules/type-fest/source/require-at-least-one.d.ts
/**
Create a type that requires at least one of the given keys, while keeping the remaining keys as is.

@example
```
import type {RequireAtLeastOne} from 'type-fest';

type Responder = {
	text?: () => string;
	json?: () => string;
	secure?: boolean;
};

const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
	json: () => '{"message": "ok"}',
	secure: true,
};
```

@category Object
*/
type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, {
  ifNot: If<IsNever<KeysType>, never, _RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
}>;
type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = { [
// For each `Key` in `KeysType` make a mapped type:
Key in KeysType]-?: Required<Pick<ObjectType, Key>> // 1. Make `Key`'s type required
 & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> // 2. Make all other keys in `KeysType` optional
; }[KeysType] & Except<ObjectType, KeysType>; // 3. Add the remaining keys not in `KeysType`
//#endregion
//#region ../../node_modules/type-fest/source/required-deep.d.ts
/**
Create a deeply required version of another type.

Use-cases:
- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
- Modeling the resulting type after a deep merge with a set of defaults.

Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.

@example
```
import type {RequiredDeep} from 'type-fest';

type Settings = {
	textEditor?: {
		fontSize?: number;
		fontColor?: string;
		fontWeight?: number | undefined;
	};
	autocomplete?: boolean;
	autosave?: boolean | undefined;
};

type RequiredSettings = RequiredDeep<Settings>;
//=> {
// 	textEditor: {
// 		fontSize: number;
// 		fontColor: string;
// 		fontWeight: number | undefined;
// 	};
// 	autocomplete: boolean;
// 	autosave: boolean | undefined;
// }
```

Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).

@category Utilities
@category Object
@category Array
@category Set
@category Map
*/
type RequiredDeep<T> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T> : T extends object ? Simplify<RequiredObjectDeep<T>> // `Simplify` to prevent `RequiredObjectDeep` from appearing in the resulting type
 : unknown;
type RequiredObjectDeep<ObjectType extends object> = { [KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>; };
//#endregion
//#region src/types/dnd.d.ts
type DndDropTargetType = "rule" | "ruleGroup" | "inlineCombinator";
type DraggedItem = (RuleType & {
  path: Path;
  qbId: string;
}) | (RuleGroupTypeAny & {
  path: Path;
  qbId: string;
});
type DropEffect = "move" | "copy";
interface DropResult {
  path: Path;
  type: DndDropTargetType;
  dropEffect?: DropEffect;
  groupItems?: boolean;
  qbId: string;
  getQuery: () => RuleGroupTypeAny;
  dispatchQuery: (query: RuleGroupTypeAny) => void;
}
interface DragCollection {
  isDragging: boolean;
  dragMonitorId: string | symbol;
}
interface DropCollection {
  dropNotAllowed: boolean;
  isOver: boolean;
  dropMonitorId: string | symbol;
  dropEffect?: DropEffect;
  groupItems?: boolean;
}
//#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.
 *
 * @group Props
 */
interface CommonRuleSubComponentProps {
  rule: RuleType;
}
/**
 * Classnames applied to each component.
 *
 * @group Props
 */
interface Classnames {
  /**
   * Classnames applied to the root `<div>` element.
   */
  queryBuilder: Classname;
  /**
   * Classnames applied to the `<div>` containing the RuleGroup.
   */
  ruleGroup: Classname;
  /**
   * Classnames applied to the `<div>` containing the RuleGroup header controls.
   */
  header: Classname;
  /**
   * Classnames applied to the `<div>` containing the RuleGroup child rules/groups.
   */
  body: Classname;
  /**
   * Classnames applied to the `<select>` control for combinators.
   */
  combinators: Classname;
  /**
   * Classnames applied to the `<button>` to add a Rule.
   */
  addRule: Classname;
  /**
   * Classnames applied to the `<button>` to add a RuleGroup.
   */
  addGroup: Classname;
  /**
   * Classnames applied to the `<button>` to clone a Rule.
   */
  cloneRule: Classname;
  /**
   * Classnames applied to the `<button>` to clone a RuleGroup.
   */
  cloneGroup: Classname;
  /**
   * Classnames applied to the `<button>` to remove a RuleGroup.
   */
  removeGroup: Classname;
  /**
   * Classnames applied to the `<div>` containing the Rule.
   */
  rule: Classname;
  /**
   * Classnames applied to the `<select>` control for fields.
   */
  fields: Classname;
  /**
   * Classnames applied to the `<select>` control for match modes.
   */
  matchMode: Classname;
  /**
   * Classnames applied to the `<input>` for match thresholds.
   */
  matchThreshold: Classname;
  /**
   * Classnames applied to the `<select>` control for operators.
   */
  operators: Classname;
  /**
   * Classnames applied to the `<input>` for the rule value.
   */
  value: Classname;
  /**
   * Classnames applied to the `<button>` to remove a Rule.
   */
  removeRule: Classname;
  /**
   * Classnames applied to the `<label>` on the "not" toggle.
   */
  notToggle: Classname;
  /**
   * 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.
   */
  dragHandle: Classname;
  /**
   * Classnames applied to the `<button>` to lock/disable a Rule.
   */
  lockRule: Classname;
  /**
   * Classnames applied to the `<button>` to lock/disable a RuleGroup.
   */
  lockGroup: Classname;
  /**
   * Classnames applied to the `<button>` to mute a Rule.
   */
  muteRule: Classname;
  /**
   * Classnames applied to the `<button>` to mute a RuleGroup.
   */
  muteGroup: Classname;
  /**
   * Classnames applied to the `<select>` control for value sources.
   */
  valueSource: Classname;
  /**
   * Classnames applied to all action elements.
   */
  actionElement: Classname;
  /**
   * Classnames applied to all select elements.
   */
  valueSelector: Classname;
  /**
   * Classname(s) applied to inline combinator elements.
   */
  betweenRules: Classname;
  /**
   * Classname(s) applied to valid rules and groups.
   */
  valid: Classname;
  /**
   * Classname(s) applied to invalid rules and groups.
   */
  invalid: Classname;
  /**
   * Classname(s) applied to rules and groups while being dragged.
   */
  dndDragging: Classname;
  /**
   * Classname(s) applied to rules and groups hovered over by a dragged element.
   */
  dndOver: Classname;
  /**
   * Classname(s) applied to rules and groups hovered over by a dragged element
   * when the drop effect is "copy" (modifier key is pressed).
   */
  dndCopy: Classname;
  /**
   * Classname(s) applied to rules and groups hovered over by a dragged element
   * when the Ctrl key is pressed, indicating the items will form a new group.
   */
  dndGroup: Classname;
  /**
   * Classname(s) applied to rules and groups that cannot accept a drop from
   * the dragged element hovering over it.
   */
  dndDropNotAllowed: Classname;
  /**
   * Classname(s) applied to a rule or group at its prospective position
   * during an active drag when `updateWhileDragging` is enabled.
   */
  dndPreviewPosition: Classname;
  /**
   * Classname(s) applied to a dragged rule or group at its original position
   * to hide it when `updateWhileDragging` is enabled.
   */
  dndHidden: Classname;
  /**
   * Classname(s) applied to disabled elements.
   */
  disabled: Classname;
  /**
   * Classname(s) applied to muted elements.
   */
  muted: Classname;
  /**
   * Classname(s) applied to each element in a series of value editors.
   */
  valueListItem: Classname;
  /**
   * Not applied, but see CSS styles.
   */
  branches: Classname;
  /**
   * Classname(s) applied to rules that render a subquery.
   */
  hasSubQuery: Classname;
  /**
   * Classname(s) applied to async components in their "loading" state.
   */
  loading: Classname;
  /**
   * Classname(s) applied to value editors for relative date/time values.
   */
  valueDateTimeRelative: Classname;
}
/**
 * Placeholder strings for option lists.
 *
 * @group Props
 */
interface Placeholder {
  /**
   * Value for the placeholder field option if autoSelectField is false,
   * or the placeholder operator option if autoSelectOperator is false.
   */
  placeholderName?: string;
  /**
   * Label for the placeholder field option if autoSelectField is false,
   * or the placeholder operator option if autoSelectOperator is false.
   */
  placeholderLabel?: string;
  /**
   * Label for the placeholder field optgroup if autoSelectField is false,
   * or the placeholder operator optgroup if autoSelectOperator is false.
   */
  placeholderGroupLabel?: string;
}
/**
 * A translation for a component with `title` only.
 *
 * @group Props
 */
interface BaseTranslation {
  title?: string;
}
/**
 * A translation for a component with `title` and `label`.
 *
 * @group Props
 */
interface BaseTranslationWithLabel<LabelType = string> extends BaseTranslation {
  label?: LabelType;
}
/**
 * A translation for a component with `title` and a placeholder.
 *
 * @group Props
 */
interface BaseTranslationWithPlaceholders extends BaseTranslation, Placeholder {}
/**
 * The shape of the `translations` prop.
 *
 * @group Props
 */
interface BaseTranslations<LabelType = string> {
  fields: BaseTranslationWithPlaceholders;
  operators: BaseTranslationWithPlaceholders;
  values: BaseTranslationWithPlaceholders;
  matchMode: BaseTranslation;
  matchThreshold: BaseTranslation & {
    placeholderName?: string;
  };
  value: BaseTranslation;
  removeRule: BaseTranslationWithLabel<LabelType>;
  removeGroup: BaseTranslationWithLabel<LabelType>;
  addRule: BaseTranslationWithLabel<LabelType>;
  addGroup: BaseTranslationWithLabel<LabelType>;
  combinators: BaseTranslation;
  notToggle: BaseTranslationWithLabel<LabelType>;
  cloneRule: BaseTranslationWithLabel<LabelType>;
  cloneRuleGroup: BaseTranslationWithLabel<LabelType>;
  shiftActionUp: BaseTranslationWithLabel<LabelType>;
  shiftActionDown: BaseTranslationWithLabel<LabelType>;
  undo: BaseTranslationWithLabel<LabelType>;
  redo: BaseTranslationWithLabel<LabelType>;
  dragHandle: BaseTranslationWithLabel<LabelType>;
  lockRule: BaseTranslationWithLabel<LabelType>;
  lockGroup: BaseTranslationWithLabel<LabelType>;
  lockRuleDisabled: BaseTranslationWithLabel<LabelType>;
  lockGroupDisabled: BaseTranslationWithLabel<LabelType>;
  muteRule: BaseTranslationWithLabel<LabelType>;
  muteGroup: BaseTranslationWithLabel<LabelType>;
  unmuteRule: BaseTranslationWithLabel<LabelType>;
  unmuteGroup: BaseTranslationWithLabel<LabelType>;
  valueSourceSelector: BaseTranslation;
}
/**
 * The full `translations` interface with all properties required.
 *
 * @group Props
 */
type BaseTranslationsFull<LabelType = string> = RequiredDeep<BaseTranslations<LabelType>>;
/**
 * Functions included in the `actions` prop passed to every subcomponent.
 *
 * @group Props
 */
interface QueryActions {
  onGroupAdd(group: RuleGroupTypeAny, parentPath: Path, context?: any): void;
  onGroupRemove(path: Path): void;
  onPropChange(prop: Exclude<keyof RuleType | keyof RuleGroupType, "id" | "path">, value: any, path: Path, context?: any): void;
  onRuleAdd(rule: RuleType, parentPath: Path, context?: any): void;
  onRuleRemove(path: Path): void;
  moveRule(oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any): void;
  groupRule(sourcePath: Path, targetPath: Path, clone?: boolean, context?: any): void;
}
interface QueryBuilderFlags {
  /**
   * Set to `false` to avoid calling the `onQueryChange` callback
   * when the component mounts.
   *
   * @default true
   */
  enableMountQueryChange?: boolean;
  /**
   * 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.
   *
   * @default false
   */
  enableDragAndDrop?: boolean;
  /**
   * Enables debug logging for query builders (and React DnD when applicable).
   *
   * @default false
   */
  debugMode?: boolean;
  /**
   * Show group combinator selectors in the body of the group, between each child rule/group,
   * instead of in the group header.
   *
   * @default false
   */
  showCombinatorsBetweenRules?: boolean;
  /**
   * Show the "not" (aka inversion) toggle for rule groups.
   *
   * @default false
   */
  showNotToggle?: boolean;
  /**
   * Show the "Shift up"/"Shift down" actions.
   *
   * @default false
   */
  showShiftActions?: boolean;
  /**
   * Show the "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.
   *
   * @default false
   */
  showCloneButtons?: boolean;
  /**
   * Show the "Lock rule" and "Lock group" buttons.
   *
   * @default false
   */
  showLockButtons?: boolean;
  /**
   * Show the "Mute rule" and "Mute group" buttons.
   *
   * @default false
   */
  showMuteButtons?: boolean;
  /**
   * Reset the `operator` and `value` when the `field` changes.
   *
   * @default true
   */
  resetOnFieldChange?: boolean;
  /**
   * Reset the `value` when the `operator` changes.
   *
   * @default false
   */
  resetOnOperatorChange?: boolean;
  /**
   * Select the first field in the array automatically.
   *
   * @default true
   */
  autoSelectField?: boolean;
  /**
   * Select the first operator in the array automatically.
   *
   * @default true
   */
  autoSelectOperator?: boolean;
  /**
   * Select the first value in the array automatically. Only applicable when the value editor renders a select list.
   *
   * @default false
   */
  autoSelectValue?: boolean;
  /**
   * Adds a new default rule automatically to each new group.
   *
   * @default false
   */
  addRuleToNewGroups?: boolean;
  /**
   * Store list-type values as native arrays instead of comma-separated strings.
   *
   * @default false
   */
  listsAsArrays?: boolean;
  /**
   * Prevent _any_ assignment of standard classes to elements. This includes conditional
   * and event-based classes for validation, drag-and-drop, etc.
   *
   * @default false
   */
  suppressStandardClassnames?: boolean;
}
//#endregion
//#region src/defaults.d.ts
/**
 * @group Defaults
 */
declare const defaultPlaceholderName = "~";
/**
 * @group Defaults
 */
declare const defaultPlaceholderLabel = "------";
/**
 * Default `name` for placeholder option in the `fields` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderFieldName: typeof defaultPlaceholderName;
/**
 * Default `label` for placeholder option in the `fields` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderFieldLabel: typeof defaultPlaceholderLabel;
/**
 * Default `label` for placeholder option group in the `fields` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderFieldGroupLabel: typeof defaultPlaceholderLabel;
/**
 * Default `name` for placeholder option in the `operators` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderOperatorName: typeof defaultPlaceholderName;
/**
 * Default `label` for placeholder option in the `operators` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderOperatorLabel: typeof defaultPlaceholderLabel;
/**
 * Default `label` for placeholder option group in the `operators` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderOperatorGroupLabel: typeof defaultPlaceholderLabel;
/**
 * Default `name` for placeholder option in the `values` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderValueName: typeof defaultPlaceholderName;
/**
 * Default `label` for placeholder option in the `values` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderValueLabel: typeof defaultPlaceholderLabel;
/**
 * Default `label` for placeholder option group in the `values` array.
 *
 * @group Defaults
 */
declare const defaultPlaceholderValueGroupLabel: typeof defaultPlaceholderLabel;
/**
 * Default configuration of translatable strings.
 *
 * @group Defaults
 */
declare const defaultTranslations: BaseTranslationsFull;
/**
 * Default character used to `.join` and `.split` arrays.
 *
 * @group Defaults
 */
declare const defaultJoinChar = ",";
type DefaultOperators = StringUnionToFullOptionArray<DefaultOperatorName>;
declare const defaultOperatorLabelMap: Record<DefaultOperatorName, string>;
declare const defaultCombinatorLabelMap: Record<DefaultCombinatorNameExtended, string>;
/**
 * Default operator list.
 *
 * @group Defaults
 */
declare const defaultOperators: DefaultOperators;
/**
 * Map of default operators to their respective opposite/negating operators.
 *
 * @group Defaults
 */
declare const defaultOperatorNegationMap: Record<DefaultOperatorName, DefaultOperatorName>;
/**
 * Relational/comparison operators (`=`, `!=`, `<`, `>`, `<=`, `>=`).
 *
 * @group Defaults
 */
declare const relationalOperators: Set<DefaultOperatorName>;
/**
 * Substring/text-matching operators (`contains`, `beginsWith`, `endsWith`, and negations).
 *
 * @group Defaults
 */
declare const substringOperators: Set<DefaultOperatorName>;
/**
 * Null-check operators (`null`, `notNull`).
 *
 * @group Defaults
 */
declare const nullOperators: Set<DefaultOperatorName>;
/**
 * List-membership operators (`in`, `notIn`).
 *
 * @group Defaults
 */
declare const inOperators: Set<DefaultOperatorName>;
/**
 * Range operators (`between`, `notBetween`).
 *
 * @group Defaults
 */
declare const betweenOperators: Set<DefaultOperatorName>;
type DefaultCombinators = StringUnionToFullOptionArray<DefaultCombinatorName>;
/**
 * Default combinator list.
 *
 * @group Defaults
 */
declare const defaultCombinators: DefaultCombinators;
type DefaultCombinatorsExtended = StringUnionToFullOptionArray<DefaultCombinatorNameExtended>;
/**
 * Default combinator list, with `XOR` added.
 *
 * @group Defaults
 */
declare const defaultCombinatorsExtended: DefaultCombinatorsExtended;
type DefaultMatchModes = StringUnionToFullOptionArray<MatchMode>;
/**
 * Default match modes.
 *
 * @group Defaults
 */
declare const defaultMatchModes: DefaultMatchModes;
/**
 * Standard classnames applied to each component.
 *
 * @group Defaults
 */
declare const standardClassnames: {
  readonly queryBuilder: "queryBuilder";
  readonly ruleGroup: "ruleGroup";
  readonly header: "ruleGroup-header";
  readonly body: "ruleGroup-body";
  readonly combinators: "ruleGroup-combinators";
  readonly addRule: "ruleGroup-addRule";
  readonly addGroup: "ruleGroup-addGroup";
  readonly cloneRule: "rule-cloneRule";
  readonly cloneGroup: "ruleGroup-cloneGroup";
  readonly removeGroup: "ruleGroup-remove";
  readonly notToggle: "ruleGroup-notToggle";
  readonly rule: "rule";
  readonly fields: "rule-fields";
  readonly matchMode: "rule-matchMode";
  readonly matchThreshold: "rule-matchThreshold";
  readonly operators: "rule-operators";
  readonly value: "rule-value";
  readonly removeRule: "rule-remove";
  readonly betweenRules: "betweenRules";
  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";
  readonly dndGroup: "dndGroup";
  readonly dndDropNotAllowed: "dndDropNotAllowed";
  readonly dndPreviewPosition: "dndPreviewPosition";
  readonly dndHidden: "dndHidden";
  readonly dragHandle: "queryBuilder-dragHandle";
  readonly disabled: "queryBuilder-disabled";
  readonly muted: "queryBuilder-muted";
  readonly lockRule: "rule-lock";
  readonly lockGroup: "ruleGroup-lock";
  readonly muteRule: "rule-mute";
  readonly muteGroup: "ruleGroup-mute";
  readonly valueSource: "rule-valueSource";
  readonly valueListItem: "rule-value-list-item";
  readonly branches: "queryBuilder-branches";
  readonly justified: "queryBuilder-justified";
  readonly responsive: "queryBuilder-responsive";
  readonly hasSubQuery: "rule-hasSubQuery";
  readonly loading: "queryBuilder-loading";
  readonly valueDateTimeRelative: "rule-value-dateTimeRelative";
};
/**
 * Default classnames for each component.
 *
 * @group Defaults
 */
declare const defaultControlClassnames: Classnames;
/**
 * Default reason codes for a group being invalid.
 *
 * @group Defaults
 */
declare const groupInvalidReasons: {
  readonly empty: "empty";
  readonly invalidCombinator: "invalid combinator";
  readonly invalidIndependentCombinators: "invalid independent combinators";
};
/**
 * Component identifiers for testing.
 *
 * @group Defaults
 */
declare const TestID: {
  readonly rule: "rule";
  readonly ruleGroup: "rule-group";
  readonly inlineCombinator: "inline-combinator";
  readonly addGroup: "add-group";
  readonly removeGroup: "remove-group";
  readonly cloneGroup: "clone-group";
  readonly cloneRule: "clone-rule";
  readonly addRule: "add-rule";
  readonly removeRule: "remove-rule";
  readonly combinators: "combinators";
  readonly fields: "fields";
  readonly operators: "operators";
  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";
  readonly muteRule: "mute-rule";
  readonly muteGroup: "mute-group";
  readonly valueSourceSelector: "value-source-selector";
  readonly matchModeEditor: "match-mode-editor";
};
declare const LogType: {
  readonly parentPathDisabled: "action aborted: parent path disabled";
  readonly pathDisabled: "action aborted: path is disabled";
  readonly queryUpdate: "query updated";
  readonly onAddRuleFalse: "onAddRule callback returned false";
  readonly onAddGroupFalse: "onAddGroup callback returned false";
  readonly onGroupRuleFalse: "onGroupRule callback returned false";
  readonly onGroupGroupFalse: "onGroupGroup callback returned false";
  readonly onMoveRuleFalse: "onMoveRule callback returned false";
  readonly onMoveGroupFalse: "onMoveGroup callback returned false";
  readonly onRemoveFalse: "onRemove callback returned false";
  readonly add: "rule or group added";
  readonly remove: "rule or group removed";
  readonly update: "rule or group updated";
  readonly move: "rule or group moved";
  readonly group: "rule or group grouped with another";
};
/**
 * The {@link Path} of the root group.
 *
 * @group Defaults
 */
declare const rootPath: Path;
/**
 * Default values for all `boolean`
 * {@link react-querybuilder!QueryBuilder QueryBuilder} options.
 *
 * @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/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;
}
/**
 * Options shared by every query tool.
 *
 * @group Query Tools
 */
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;
}
/**
 * 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 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;
}
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
 */
declare const add: AddMethod;
/**
 * 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 addInPlace: AddMethod;
/**
 * Options for {@link update}.
 *
 * @group Query Tools
 */
interface UpdateOptions extends QueryToolOptions {
  /**
   * 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;
}
/**
 * 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 update: UpdateMethod;
/**
 * 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.
 *
 * @group Query Tools
 */
declare const updateInPlace: UpdateMethod;
/**
 * Options for {@link remove}.
 *
 * @group Query Tools
 */
interface RemoveOptions extends QueryToolOptions {}
interface RemoveMethod {
  <RG extends RuleGroupTypeAny>(query: RG, pathOrID: Path | string, options?: RemoveOptions): RG;
}
/**
 * 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 remove: RemoveMethod;
/**
 * Removes a rule or group from a query in place.
 *
 * @returns The query (mutated in place) with the rule or group removed.
 *
 * @group Query Tools
 */
declare const removeInPlace: RemoveMethod;
/**
 * Options for {@link move}.
 *
 * @group Query Tools
 */
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;
}
/**
 * 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.
 *
 * @group Query Tools
 */
declare const move: MoveMethod;
/**
 * 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.
 *
 * @group Query Tools
 */
declare const moveInPlace: MoveMethod;
/**
 * Options for {@link insert}.
 *
 * @group Query Tools
 */
interface InsertOptions extends QueryToolOptions {
  /**
   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
   * combinators), then the first combinator in this list will be inserted
   * before the new rule/group if the parent group is not empty. This option
   * is overridden by `combinatorPreceding`.
   */
  combinators?: OptionList;
  /**
   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
   * combinators), then this combinator will be inserted before the new rule/group
   * if the parent group is not empty and the new rule/group is not the first in the
   * group (`path.at(-1) > 0`). This option will supersede `combinators`.
   */
  combinatorPreceding?: string;
  /**
   * If the query extends `RuleGroupTypeIC` (i.e. the query has independent
   * combinators), then this combinator will be inserted after the new rule/group
   * if the parent group is not empty and the new rule/group is the first in the
   * group (`path.at(-1) === 0`). This option will supersede `combinators`.
   */
  combinatorSucceeding?: string;
  /**
   * ID generator.
   *
   * @default generateID
   */
  idGenerator?: () => string;
  /**
   * When `true`, the new rule/group will replace the rule/group at `path`.
   */
  replace?: boolean;
}
interface InsertMethod {
  <RG extends RuleGroupTypeAny>(query: RG, ruleOrGroup: RG | RuleType, path: number[], options?: InsertOptions): RG;
}
/**
 * Inserts a rule or group into a query without mutating the original query.
 *
 * @returns A new query with the rule or group inserted.
 *
 * @group Query Tools
 */
declare const insert: InsertMethod;
/**
 * Inserts a rule or group into a query in place.
 *
 * @returns The query (mutated in place) with the rule or group inserted.
 *
 * @group Query Tools
 */
declare const insertInPlace: InsertMethod;
/**
 * Options for {@link group}.
 *
 * @group Query Tools
 */
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;
}
/**
 * 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.
 *
 * @returns A new query with the rules or groups grouped.
 *
 * @group Query Tools
 */
declare const group: GroupMethod;
/**
 * 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.
 *
 * @returns The query (mutated in place) with the rules or groups grouped.
 *
 * @group Query Tools
 */
declare const groupInPlace: GroupMethod;
//#endregion
//#region src/utils/abortReasons.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.
 *
 * Declared apart from `QueryManager` so the `@react-querybuilder/core/derivations` entry point can
 * export it without putting the manager in its module graph.
 *
 * @group Query Tools
 */
declare const strictAbortReasons: readonly AbortReason[];
//#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[];
/**
 * 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}.
 *
 * 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 joinWith: (strArr: unknown[], joinChar?: string) => string;
type IsUnknown<T> = unknown extends T ? true : false;
type Trimmed<T> = IsUnknown<T> extends true ? string : T;
/**
 * Trims the value if it is a string. Otherwise returns the value as is.
 */
declare const trimIfString: <T>(val: T) => Trimmed<T>;
type ToArrayResult<T> = IsUnknown<T> extends true ? string[] : T extends readonly (infer U)[] ? Trimmed<U>[] : T extends string ? string[] : T extends number ? number[] : never[];
/**
 * Splits a string by comma then trims each element. Arrays are returned as is except
 * any string elements are trimmed.
 */
declare const toArray: <T>(a: T, { retainEmptyStrings }?: {
  retainEmptyStrings?: boolean;
}) => ToArrayResult<T>;
/**
 * Determines if an array is free of `null`/`undefined`.
 */
declare const nullFreeArray: <T>(arr: T[]) => arr is Exclude<T, null>[];
//#endregion
//#region ../../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
/**
 * 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.
 *
 * A change coalesces only when all three hold:
 * - the change is not structural (rules/groups added, removed, moved, or reordered)
 * - its signature matches the previously recorded signature
 * - it occurred within `coalesceMs` of the previous recording
 *
 * Note that {@link unchangedSignature} is not handled here. A change with no observable
 * difference is never recorded at all, which is a separate decision made before this check.
 *
 * @param prevSig Signature of the previously recorded change, or `undefined` if there is none.
 * @param nextSig Signature of the change being recorded, from {@link signatureOf}.
 * @param prevAt Timestamp of the previous recording.
 * @param now Timestamp of the change being recorded.
 * @param coalesceMs Coalescing window in milliseconds.
 */
declare const shouldCoalesce: (prevSig: string | undefined, nextSig: string, prevAt: number, now: number, coalesceMs?: number) => boolean;
//#endregion
//#region src/utils/convertQuery.d.ts
/**
 * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.
 *
 * This function is idempotent: {@link RuleGroupType} queries will be
 * returned as-is.
 *
 * @group Query Tools
 */
declare const convertFromIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupType<RG>;
/**
 * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.
 *
 * This function is idempotent: {@link RuleGroupTypeIC} queries will be
 * returned as-is.
 *
 * @group Query Tools
 */
declare const convertToIC: <RG extends RuleGroupTypeAny>(rg: RG) => ToRuleGroupTypeIC<RG>;
/**
 * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit
 * operation, use {@link convertToIC}.
 *
 * @group Query Tools
 */
declare function convertQuery(query: RuleGroupType): RuleGroupTypeIC;
/**
 * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit
 * operation, use {@link convertFromIC}.
 *
 * @group Query Tools
 */
declare function convertQuery(query: RuleGroupTypeIC): RuleGroupType;
//#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/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/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
 * 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 Option Lists
 */
declare const filterFieldsByComparator: (field: FullField, fields: OptionList<FullField>, operator: string) => FullField[] | {
  options: WithUnknownIndex<FullField>[];
  label: string;
}[];
//#endregion
//#region src/utils/generateAccessibleDescription.d.ts
/**
 * 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
 */
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;
}
/**
 * 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 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.
 */
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/immerInstances.d.ts
/**
 * 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
 */
declare const setAutoFreeze: (autoFreeze: boolean) => void;
//#endregion
//#region src/utils/isRuleGroup.d.ts
/**
 * Determines if an object is a {@link RuleType} (only checks for a `field` property).
 */
declare const isRuleType: (s: unknown) => s is RuleType;
/**
 * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
 */
declare const isRuleGroup: (rg: unknown) => rg is RuleGroupTypeAny;
/**
 * Determines if an object is a {@link RuleGroupType}.
 */
declare const isRuleGroupType: (rg: unknown) => rg is RuleGroupType;
/**
 * Determines if an object is a {@link RuleGroupTypeIC}.
 */
declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
//#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;
/**
 * 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 isRuleOrGroupValid: (rg: RuleType | RuleGroupTypeAny, validationResult?: boolean | ValidationResult, validator?: RuleValidator) => boolean;
//#endregion
//#region src/utils/mergeAnyTranslations.d.ts
/**
 * Merges any number of partial translations into a single definition.
 */
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)[];
/**
 * Merges a list of partial {@link Classnames} definitions into a single definition.
 */
declare const mergeClassnames: (...args: MergeClassnamesParams) => Classnames;
//#endregion
//#region src/utils/misc.d.ts
/**
 * Converts a value to lowercase if it's a string, otherwise returns the value as is.
 */
declare const lc: <T>(v: T) => T;
/**
 * Regex matching numeric strings. Passes for positive/negative integers, decimals,
 * and E notation, with optional surrounding whitespace.
 */
declare const numericRegex: RegExp;
/**
 * Determines if a variable is a plain old JavaScript object, aka POJO.
 */
declare const isPojo: (obj: unknown) => obj is Record<string, any>;
/**
 * Simple helper to determine whether a value is null, undefined, or an empty string.
 */
declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefined | "";
//#endregion
//#region src/utils/objectUtils.d.ts
/**
 * Original looked like this (not sure why template string is used):
 * ```
 * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
 * ```
 */
type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
/**
 * A strongly-typed version of `Object.keys()`.
 *
 * [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()`.
 *
 * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
 */
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/optGroupUtils.d.ts
/**
 * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
 * into a {@link FullOption}. Full options are left unchanged.
 *
 * @group Option Lists
 */
declare function toFullOption<Opt extends BaseOption>(opt: Opt | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt>;
/**
 * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
 * Lists of full options are left unchanged.
 *
 * @group Option Lists
 */
declare function toFullOptionList<Opt extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt>;
/**
 * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
 * Lists of full options are left unchanged.
 *
 * @group Option Lists
 */
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;
/**
 * @deprecated Renamed to {@link uniqByIdentifier}.
 *
 * @group Option Lists
 */
declare const uniqByName: <T extends {
  name: string;
  value?: string;
} | {
  name?: string;
  value: string;
}>(originalArray: T[]) => T[];
/**
 * Generates a new array of objects with duplicates removed based
 * on the identifying property (`value` or `name`)
 *
 * @group Option Lists
 */
declare const uniqByIdentifier: <T extends RequireAtLeastOne<{
  name: string;
  value: string;
}, "name" | "value">>(originalArray: T[]) => T[];
/**
 * Determines if an {@link OptionList} is an {@link OptionGroup} array.
 *
 * @group Option Lists
 */
declare const isOptionGroupArray: (arr: unknown) => arr is OptionGroup<BaseOption>[];
/**
 * Determines if an array is a flat array of {@link FlexibleOption}.
 *
 * @group Option Lists
 */
declare const isFlexibleOptionArray: (arr: unknown) => arr is FlexibleOption[];
/**
 * Determines if an array is a flat array of {@link FullOption}.
 *
 * @group Option Lists
 */
declare const isFullOptionArray: (arr: unknown) => arr is FullOption[];
/**
 * Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
 *
 * @group Option Lists
 */
declare const isFlexibleOptionGroupArray: (arr: unknown, { allowEmpty }?: {
  allowEmpty?: boolean;
}) => arr is FlexibleOptionGroup[];
/**
 * Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.
 *
 * @group Option Lists
 */
declare const isFullOptionGroupArray: (arr: unknown, { allowEmpty }?: {
  allowEmpty?: boolean;
}) => arr is OptionGroup<FullOption>[];
/**
 * Gets the option from an {@link OptionList} with the given `name`. Handles
 * {@link Option} arrays as well as {@link OptionGroup} arrays.
 *
 * @group Option Lists
 */
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;
/**
 * Gets the first option from an {@link OptionList}.
 *
 * @group Option Lists
 */
declare function getFirstOption<Opt extends FullOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
declare function getFirstOption<Opt extends ValueOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
declare function getFirstOption<Opt extends Option>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
/**
 * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
 * If the array is already flat, it is returned as is.
 *
 * @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 Option Lists
 */
declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptionGroup<T>[]) => OptionGroup<ToFullOption<T>>[];
/**
 * Generates a new {@link Option} or {@link OptionGroup} array with duplicates
 * removed based on the identifier property (`value` or `name`).
 *
 * @group Option Lists
 */
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>>;
}
/** 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;
}
/**
 * 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.
 *
 * Note: `labelMap` overrides only apply to array/option group input (where string options are
 * expanded); record input derives labels from the record values themselves.
 *
 * 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 prepareOptionList: <O extends FullOption>(props: PrepareOptionListParams<O>) => PreparedOptionList<O>;
//#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/pathUtils.d.ts
/**
 * 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.
 *
 * @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/QueryManager.d.ts
/**
 * 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
 * _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;
  /**
   * Translations, accepting the same shape as the `translations` prop. Only the placeholder
   * properties of `fields`, `operators`, and `values` are used, and only when the corresponding
   * `autoSelect*` option is `false`; the remaining keys describe UI elements that have no
   * meaning outside the `QueryBuilder` component. Labels are typed as `unknown` so the React
   * `Translations` type, whose labels are `ReactNode`, can be passed as-is.
   */
  translations?: Partial<BaseTranslations<unknown>>;
  /** The default `field` for rules created by {@link QueryManager.createRule}. */
  getDefaultField?: DefaultFieldProp<F>;
  /** The default `operator` for a given field. */
  getDefaultOperator?: DefaultOperatorProp<F>;
  /** 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;
  /**
   * 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}. */
  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;
}
//#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}.
 */
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, ControlKey, 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, 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, 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, clsx, coerceBigIntValue, coerceInputType, controlKeys, controlKind, controlPropKeys, convertFromIC, convertQuery, convertToIC, createQueryActions, createRule, createRuleGroup, defaultCoalesceMs, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultJoinChar, defaultMatchModes, defaultMaxHistory, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultTranslations, defaultValidator, derivePathInfo, deriveQueryBuilderClassNames, deriveRuleClassName, deriveRuleClassNames, deriveRuleContext, deriveRuleGroupClassNames, deriveRuleGroupContext, deriveRuleGroupOuterClassName, deriveRuleOuterClassName, exceedsMaxLevels, filterFieldsByComparator, findID, findPath, generateAccessibleDescription, generateID, getCommonAncestorPath, getFieldData, getFirstOption, getGuardAbortReason, getMatchModesUtil, getMultiValueUpdate, getOption, getParametersAsList, getParentPath, getParseNumberMethod, getPathOfID, getRuleDefaultValue$1 as getRuleDefaultValue, getRuleGroupCombinator, getRuleInputType, getRuleValidationResult, getRuleValueEditorType, getRuleValueSourceOptions, getRuleValues, 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, isValidationResult, joinWith, lc, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, move, moveInPlace, normalizeValueSelectorValue, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, objectEntries, objectKeys, optionsEqual, parseNumber, pathIsDisabled, pathIsDisabledByPaths, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, resolveCandidateQuery, resolveDefaultOperator, resolveOperatorList, resolveValueEditorType, resolveValueList, rootPath, setAutoFreeze, shouldCoalesce, signatureOf, splitBy, standardClassnames, strictAbortReasons, structuralSignature, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, unchangedSignature, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, valuesEqual };
//# sourceMappingURL=derivations.d.mts.map