@react-querybuilder/core 8.20.2 → 8.21.0

package/dist/parseGremlin.d.mts

@@ -1,28 +1,27 @@
-import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-DlVg-QXo.mjs";
-
+import { T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.mjs";
 //#region src/utils/parseGremlin/parseGremlin.d.ts
 /**
-* Options for {@link parseGremlin}.
-*/
+ * Options for {@link parseGremlin}.
+ */
 interface ParseGremlinOptions {
   independentCombinators?: boolean;
 }
 /**
-* Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.
-*
-* Accepts a full Gremlin traversal or a chain of `.has()` steps.
-* Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are
-* consumed but discarded — only `.has()` filter predicates are returned.
-*
-* @example
-* ```ts
-* // Full traversal — extracts .has() conditions only
-* parseGremlin("g.V().hasLabel('Person').has('age', gt(30))");
-*
-* // Bare .has() chain
-* parseGremlin(".has('age', gt(30)).has('name', 'Alice')");
-* ```
-*/
+ * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.
+ *
+ * Accepts a full Gremlin traversal or a chain of `.has()` steps.
+ * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are
+ * consumed but discarded — only `.has()` filter predicates are returned.
+ *
+ * @example
+ * ```ts
+ * // Full traversal — extracts .has() conditions only
+ * parseGremlin("g.V().hasLabel('Person').has('age', gt(30))");
+ *
+ * // Bare .has() chain
+ * parseGremlin(".has('age', gt(30)).has('name', 'Alice')");
+ * ```
+ */
 declare function parseGremlin(gremlin: string): DefaultRuleGroupType;
 declare function parseGremlin(gremlin: string, options: Omit<ParseGremlinOptions, "independentCombinators"> & {
   independentCombinators?: false;

package/dist/parseGremlin.d.ts

@@ -1,28 +1,27 @@
-import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-DlVg-QXo.js";
-
+import { T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.js";
 //#region src/utils/parseGremlin/parseGremlin.d.ts
 /**
-* Options for {@link parseGremlin}.
-*/
+ * Options for {@link parseGremlin}.
+ */
 interface ParseGremlinOptions {
   independentCombinators?: boolean;
 }
 /**
-* Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.
-*
-* Accepts a full Gremlin traversal or a chain of `.has()` steps.
-* Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are
-* consumed but discarded — only `.has()` filter predicates are returned.
-*
-* @example
-* ```ts
-* // Full traversal — extracts .has() conditions only
-* parseGremlin("g.V().hasLabel('Person').has('age', gt(30))");
-*
-* // Bare .has() chain
-* parseGremlin(".has('age', gt(30)).has('name', 'Alice')");
-* ```
-*/
+ * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.
+ *
+ * Accepts a full Gremlin traversal or a chain of `.has()` steps.
+ * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are
+ * consumed but discarded — only `.has()` filter predicates are returned.
+ *
+ * @example
+ * ```ts
+ * // Full traversal — extracts .has() conditions only
+ * parseGremlin("g.V().hasLabel('Person').has('age', gt(30))");
+ *
+ * // Bare .has() chain
+ * parseGremlin(".has('age', gt(30)).has('name', 'Alice')");
+ * ```
+ */
 declare function parseGremlin(gremlin: string): DefaultRuleGroupType;
 declare function parseGremlin(gremlin: string, options: Omit<ParseGremlinOptions, "independentCombinators"> & {
   independentCombinators?: false;

package/dist/parseJSONata.d.mts

@@ -1,35 +1,222 @@
-import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-DlVg-QXo.mjs";
-import { t as ParserCommonOptions } from "./import-ShTj5IdB.mjs";
+import { L as Except, P as ExpressionNode, R as Merge, T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.mjs";
+import { t as ParserCommonOptions } from "./import-BVdxeIBO.mjs";
+//#region ../../node_modules/type-fest/source/override-properties.d.ts
+/**
+Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
+
+This is useful when you want to override existing properties with a different type and make sure that these properties really exist in the original.
+
+@example
+```
+import type {OverrideProperties} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: string;
+};
+
+type Bar = OverrideProperties<Foo, {b: number}>;
+//=> {a: string; b: number}
 
+// @ts-expect-error
+type Baz = OverrideProperties<Foo, {c: number}>;
+// Error, type '{ c: number; }' does not satisfy the constraint '{ c: never; }'
+
+// @ts-expect-error
+type Fizz = OverrideProperties<Foo, {b: number; c: number}>;
+// Error, type '{ b: number; c: number; }' does not satisfy the constraint '{ b: number; c: never; }'
+```
+
+@category Object
+*/
+type OverrideProperties<TOriginal,
+// This first bit where we use `Partial` is to enable autocomplete
+// and the second bit with the mapped type is what enforces that we don't try
+// to override properties that doesn't exist in the original type.
+TOverride extends Partial<Record<keyof TOriginal, unknown>> & { [Key in keyof TOverride]: Key extends keyof TOriginal ? TOverride[Key] : never; }> = Merge<TOriginal, TOverride>;
+//#endregion
+//#region src/utils/parseJSONata/types.d.ts
+interface JSONataExprNode {
+  type: string;
+  value?: any;
+  position?: number;
+  arguments?: JSONataExprNode[];
+  name?: string;
+  procedure?: JSONataExprNode;
+  steps?: JSONataExprNode[];
+  expressions?: JSONataExprNode[];
+  stages?: JSONataExprNode[];
+  lhs?: JSONataExprNode;
+  rhs?: JSONataExprNode;
+}
+interface JSONataPath extends JSONataExprNode {
+  type: "path";
+  steps: [JSONataExprNode, ...JSONataExprNode[]];
+}
+interface JSONataName extends JSONataExprNode {
+  type: "name";
+  value: string;
+}
+interface JSONataIdentifier extends JSONataPath {
+  steps: [JSONataName, ...JSONataName[]];
+}
+interface JSONataBlock extends JSONataExprNode {
+  type: "block";
+  expressions: [JSONataExprNode];
+}
+interface JSONataString extends JSONataExprNode {
+  type: "string";
+  value: string;
+}
+interface JSONataNumber extends JSONataExprNode {
+  type: "number";
+  value: number;
+}
+interface JSONataBoolean extends JSONataExprNode {
+  type: "value";
+  value: boolean;
+}
+interface JSONataNull extends JSONataExprNode {
+  type: "value";
+  value: null;
+}
+interface JSONataRegex extends JSONataExprNode {
+  type: "regex";
+  value: RegExp;
+}
+interface JSONataBinaryNode extends JSONataExprNode {
+  type: "binary";
+  lhs: JSONataExprNode;
+  rhs: JSONataExprNode;
+}
+interface JSONataAnd extends JSONataBinaryNode {
+  value: "and";
+}
+interface JSONataOr extends JSONataBinaryNode {
+  value: "or";
+}
+interface JSONataEqual extends JSONataBinaryNode {
+  value: "=";
+}
+interface JSONataNotEqual extends JSONataBinaryNode {
+  value: "!=";
+}
+interface JSONataGreaterThan extends JSONataBinaryNode {
+  value: ">";
+}
+interface JSONataGreaterThanOrEqual extends JSONataBinaryNode {
+  value: ">=";
+}
+interface JSONataLessThan extends JSONataBinaryNode {
+  value: "<";
+}
+interface JSONataLessThanOrEqual extends JSONataBinaryNode {
+  value: "<=";
+}
+interface JSONataIn extends JSONataBinaryNode {
+  value: "in";
+  lhs: JSONataPath;
+  rhs: JSONataList;
+}
+interface JSONataNot extends JSONataExprNode {
+  type: "function";
+  value: "(";
+  arguments: [JSONataExprNode];
+  procedure: OverrideProperties<JSONataExprNode, {
+    value: "not";
+    type: "variable";
+  }>;
+}
+interface JSONataContains extends JSONataExprNode {
+  type: "function";
+  value: "(";
+  arguments: [JSONataPath, JSONataString | JSONataRegex];
+  procedure: OverrideProperties<JSONataExprNode, {
+    value: "contains";
+    type: "variable";
+  }>;
+}
+interface JSONataToMillis extends JSONataExprNode {
+  type: "function";
+  value: "(";
+  arguments: [JSONataString, ...JSONataString[]];
+  procedure: OverrideProperties<JSONataExprNode, {
+    value: "toMillis";
+    type: "variable";
+  }>;
+}
+interface JSONataList extends JSONataExprNode {
+  type: "unary";
+  value: "[";
+  expressions: JSONataExprNode[];
+}
+/**
+ * A JSONata operand subtree that {@link parseJSONata!ParseJSONataOptions.getExpression} may
+ * receive — an arithmetic infix node (`+ - * / %`) or a function-call node
+ * (`$abs`/`$min`/`$max`/`$uppercase`/`$lowercase`, etc.).
+ */
+type JSONataExpressionOperand = JSONataExprNode;
+/** Context passed to {@link parseJSONata!ParseJSONataOptions.getExpression}. */
+interface ParseJSONataExpressionContext {
+  /** Returns `true` if the field is configured (or if no `fields` were supplied). */
+  fieldExists: (fieldName: string) => boolean;
+}
+//#endregion
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**
-* Options object for {@link parseJSONata}.
-*
-* Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.
-*/
-interface ParseJSONataOptions extends ParserCommonOptions {}
+ * Options object for {@link parseJSONata}.
+ *
+ * Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.
+ */
+interface ParseJSONataOptions extends ParserCommonOptions {
+  /**
+   * Handler that converts a JSONata arithmetic/function operand subtree into an
+   * {@link ExpressionNode}. Return `null` to reject (the rule is dropped). Supplied by
+   * `@react-querybuilder/expr` (`expressionParserJSONata`). When omitted, expression
+   * operands are ignored (rule dropped).
+   */
+  getExpression?: (node: JSONataExpressionOperand, ctx: ParseJSONataExpressionContext) => ExpressionNode | null;
+}
 /**
-* Converts a JSONata string expression into a query suitable for the
-* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
-* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
-*/
+ * Converts a JSONata string expression into a query suitable for the
+ * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+ * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+ */
 declare function parseJSONata(jsonataInput: string): DefaultRuleGroupType;
 /**
-* Converts a JSONata string expression into a query suitable for the
-* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
-* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
-*/
+ * Converts a JSONata string expression into a query suitable for the
+ * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+ * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+ */
 declare function parseJSONata(jsonataInput: string, options: Except<ParseJSONataOptions, "independentCombinators"> & {
   independentCombinators?: false;
 }): DefaultRuleGroupType;
 /**
-* Converts a JSONata string expression into a query suitable for the
-* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
-* ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
-*/
+ * Converts a JSONata string expression into a query suitable for the
+ * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+ * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
+ */
 declare function parseJSONata(jsonataInput: string, options: Except<ParseJSONataOptions, "independentCombinators"> & {
   independentCombinators: true;
 }): DefaultRuleGroupTypeIC;
 //#endregion
-export { ParseJSONataOptions, parseJSONata };
+//#region src/utils/parseJSONata/utils.d.ts
+type Any = any;
+declare const isJSONataIdentifier: (expr: Any) => expr is JSONataIdentifier;
+declare const isJSONataString: (expr: Any) => expr is JSONataString;
+declare const isJSONataNumber: (expr: Any) => expr is JSONataNumber;
+declare const isJSONataBoolean: (expr: Any) => expr is JSONataBoolean;
+declare const isJSONataNull: (expr: Any) => expr is JSONataNull;
+declare const isJSONataList: (expr: Any) => expr is JSONataList;
+/**
+ * A JSONata comparison operand that is a candidate expression subtree: an arithmetic infix node
+ * (`+ - * / %`) or a function-call node (excluding the `not`/`contains` predicates handled
+ * elsewhere). The expr-supplied `getExpression` handler decides whether it maps to a known
+ * function.
+ */
+declare const isJSONataExpressionOperand: (expr: Any) => expr is JSONataExprNode;
+declare const getValidValue: (expr: Any) => Any;
+declare const getFieldFromPath: (path: JSONataPath) => string;
+//#endregion
+export { JSONataAnd, JSONataBinaryNode, JSONataBlock, JSONataBoolean, JSONataContains, JSONataEqual, JSONataExprNode, JSONataExpressionOperand, JSONataGreaterThan, JSONataGreaterThanOrEqual, JSONataIdentifier, JSONataIn, JSONataLessThan, JSONataLessThanOrEqual, JSONataList, JSONataName, JSONataNot, JSONataNotEqual, JSONataNull, JSONataNumber, JSONataOr, JSONataPath, JSONataRegex, JSONataString, JSONataToMillis, ParseJSONataExpressionContext, ParseJSONataOptions, getFieldFromPath, getValidValue, isJSONataBoolean, isJSONataExpressionOperand, isJSONataIdentifier, isJSONataList, isJSONataNull, isJSONataNumber, isJSONataString, parseJSONata };
 //# sourceMappingURL=parseJSONata.d.mts.map

package/dist/parseJSONata.d.ts

@@ -1,35 +1,222 @@
-import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-DlVg-QXo.js";
-import { t as ParserCommonOptions } from "./import-Qs1-kgv5.js";
+import { L as Except, P as ExpressionNode, R as Merge, T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.js";
+import { t as ParserCommonOptions } from "./import-Ddc3d_8q.js";
+//#region ../../node_modules/type-fest/source/override-properties.d.ts
+/**
+Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
+
+This is useful when you want to override existing properties with a different type and make sure that these properties really exist in the original.
+
+@example
+```
+import type {OverrideProperties} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: string;
+};
+
+type Bar = OverrideProperties<Foo, {b: number}>;
+//=> {a: string; b: number}
 
+// @ts-expect-error
+type Baz = OverrideProperties<Foo, {c: number}>;
+// Error, type '{ c: number; }' does not satisfy the constraint '{ c: never; }'
+
+// @ts-expect-error
+type Fizz = OverrideProperties<Foo, {b: number; c: number}>;
+// Error, type '{ b: number; c: number; }' does not satisfy the constraint '{ b: number; c: never; }'
+```
+
+@category Object
+*/
+type OverrideProperties<TOriginal,
+// This first bit where we use `Partial` is to enable autocomplete
+// and the second bit with the mapped type is what enforces that we don't try
+// to override properties that doesn't exist in the original type.
+TOverride extends Partial<Record<keyof TOriginal, unknown>> & { [Key in keyof TOverride]: Key extends keyof TOriginal ? TOverride[Key] : never; }> = Merge<TOriginal, TOverride>;
+//#endregion
+//#region src/utils/parseJSONata/types.d.ts
+interface JSONataExprNode {
+  type: string;
+  value?: any;
+  position?: number;
+  arguments?: JSONataExprNode[];
+  name?: string;
+  procedure?: JSONataExprNode;
+  steps?: JSONataExprNode[];
+  expressions?: JSONataExprNode[];
+  stages?: JSONataExprNode[];
+  lhs?: JSONataExprNode;
+  rhs?: JSONataExprNode;
+}
+interface JSONataPath extends JSONataExprNode {
+  type: "path";
+  steps: [JSONataExprNode, ...JSONataExprNode[]];
+}
+interface JSONataName extends JSONataExprNode {
+  type: "name";
+  value: string;
+}
+interface JSONataIdentifier extends JSONataPath {
+  steps: [JSONataName, ...JSONataName[]];
+}
+interface JSONataBlock extends JSONataExprNode {
+  type: "block";
+  expressions: [JSONataExprNode];
+}
+interface JSONataString extends JSONataExprNode {
+  type: "string";
+  value: string;
+}
+interface JSONataNumber extends JSONataExprNode {
+  type: "number";
+  value: number;
+}
+interface JSONataBoolean extends JSONataExprNode {
+  type: "value";
+  value: boolean;
+}
+interface JSONataNull extends JSONataExprNode {
+  type: "value";
+  value: null;
+}
+interface JSONataRegex extends JSONataExprNode {
+  type: "regex";
+  value: RegExp;
+}
+interface JSONataBinaryNode extends JSONataExprNode {
+  type: "binary";
+  lhs: JSONataExprNode;
+  rhs: JSONataExprNode;
+}
+interface JSONataAnd extends JSONataBinaryNode {
+  value: "and";
+}
+interface JSONataOr extends JSONataBinaryNode {
+  value: "or";
+}
+interface JSONataEqual extends JSONataBinaryNode {
+  value: "=";
+}
+interface JSONataNotEqual extends JSONataBinaryNode {
+  value: "!=";
+}
+interface JSONataGreaterThan extends JSONataBinaryNode {
+  value: ">";
+}
+interface JSONataGreaterThanOrEqual extends JSONataBinaryNode {
+  value: ">=";
+}
+interface JSONataLessThan extends JSONataBinaryNode {
+  value: "<";
+}
+interface JSONataLessThanOrEqual extends JSONataBinaryNode {
+  value: "<=";
+}
+interface JSONataIn extends JSONataBinaryNode {
+  value: "in";
+  lhs: JSONataPath;
+  rhs: JSONataList;
+}
+interface JSONataNot extends JSONataExprNode {
+  type: "function";
+  value: "(";
+  arguments: [JSONataExprNode];
+  procedure: OverrideProperties<JSONataExprNode, {
+    value: "not";
+    type: "variable";
+  }>;
+}
+interface JSONataContains extends JSONataExprNode {
+  type: "function";
+  value: "(";
+  arguments: [JSONataPath, JSONataString | JSONataRegex];
+  procedure: OverrideProperties<JSONataExprNode, {
+    value: "contains";
+    type: "variable";
+  }>;
+}
+interface JSONataToMillis extends JSONataExprNode {
+  type: "function";
+  value: "(";
+  arguments: [JSONataString, ...JSONataString[]];
+  procedure: OverrideProperties<JSONataExprNode, {
+    value: "toMillis";
+    type: "variable";
+  }>;
+}
+interface JSONataList extends JSONataExprNode {
+  type: "unary";
+  value: "[";
+  expressions: JSONataExprNode[];
+}
+/**
+ * A JSONata operand subtree that {@link parseJSONata!ParseJSONataOptions.getExpression} may
+ * receive — an arithmetic infix node (`+ - * / %`) or a function-call node
+ * (`$abs`/`$min`/`$max`/`$uppercase`/`$lowercase`, etc.).
+ */
+type JSONataExpressionOperand = JSONataExprNode;
+/** Context passed to {@link parseJSONata!ParseJSONataOptions.getExpression}. */
+interface ParseJSONataExpressionContext {
+  /** Returns `true` if the field is configured (or if no `fields` were supplied). */
+  fieldExists: (fieldName: string) => boolean;
+}
+//#endregion
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**
-* Options object for {@link parseJSONata}.
-*
-* Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.
-*/
-interface ParseJSONataOptions extends ParserCommonOptions {}
+ * Options object for {@link parseJSONata}.
+ *
+ * Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.
+ */
+interface ParseJSONataOptions extends ParserCommonOptions {
+  /**
+   * Handler that converts a JSONata arithmetic/function operand subtree into an
+   * {@link ExpressionNode}. Return `null` to reject (the rule is dropped). Supplied by
+   * `@react-querybuilder/expr` (`expressionParserJSONata`). When omitted, expression
+   * operands are ignored (rule dropped).
+   */
+  getExpression?: (node: JSONataExpressionOperand, ctx: ParseJSONataExpressionContext) => ExpressionNode | null;
+}
 /**
-* Converts a JSONata string expression into a query suitable for the
-* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
-* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
-*/
+ * Converts a JSONata string expression into a query suitable for the
+ * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+ * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+ */
 declare function parseJSONata(jsonataInput: string): DefaultRuleGroupType;
 /**
-* Converts a JSONata string expression into a query suitable for the
-* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
-* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
-*/
+ * Converts a JSONata string expression into a query suitable for the
+ * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+ * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+ */
 declare function parseJSONata(jsonataInput: string, options: Except<ParseJSONataOptions, "independentCombinators"> & {
   independentCombinators?: false;
 }): DefaultRuleGroupType;
 /**
-* Converts a JSONata string expression into a query suitable for the
-* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
-* ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
-*/
+ * Converts a JSONata string expression into a query suitable for the
+ * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+ * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
+ */
 declare function parseJSONata(jsonataInput: string, options: Except<ParseJSONataOptions, "independentCombinators"> & {
   independentCombinators: true;
 }): DefaultRuleGroupTypeIC;
 //#endregion
-export { ParseJSONataOptions, parseJSONata };
+//#region src/utils/parseJSONata/utils.d.ts
+type Any = any;
+declare const isJSONataIdentifier: (expr: Any) => expr is JSONataIdentifier;
+declare const isJSONataString: (expr: Any) => expr is JSONataString;
+declare const isJSONataNumber: (expr: Any) => expr is JSONataNumber;
+declare const isJSONataBoolean: (expr: Any) => expr is JSONataBoolean;
+declare const isJSONataNull: (expr: Any) => expr is JSONataNull;
+declare const isJSONataList: (expr: Any) => expr is JSONataList;
+/**
+ * A JSONata comparison operand that is a candidate expression subtree: an arithmetic infix node
+ * (`+ - * / %`) or a function-call node (excluding the `not`/`contains` predicates handled
+ * elsewhere). The expr-supplied `getExpression` handler decides whether it maps to a known
+ * function.
+ */
+declare const isJSONataExpressionOperand: (expr: Any) => expr is JSONataExprNode;
+declare const getValidValue: (expr: Any) => Any;
+declare const getFieldFromPath: (path: JSONataPath) => string;
+//#endregion
+export { JSONataAnd, JSONataBinaryNode, JSONataBlock, JSONataBoolean, JSONataContains, JSONataEqual, JSONataExprNode, JSONataExpressionOperand, JSONataGreaterThan, JSONataGreaterThanOrEqual, JSONataIdentifier, JSONataIn, JSONataLessThan, JSONataLessThanOrEqual, JSONataList, JSONataName, JSONataNot, JSONataNotEqual, JSONataNull, JSONataNumber, JSONataOr, JSONataPath, JSONataRegex, JSONataString, JSONataToMillis, ParseJSONataExpressionContext, ParseJSONataOptions, getFieldFromPath, getValidValue, isJSONataBoolean, isJSONataExpressionOperand, isJSONataIdentifier, isJSONataList, isJSONataNull, isJSONataNumber, isJSONataString, parseJSONata };
 //# sourceMappingURL=parseJSONata.d.ts.map