index
Functions
| Function | Description |
|---|---|
| createExpressionValidator | Configure-once factory returning a QueryValidator that flags rules whose lhs/rhs expressions are invalid — unknown function, arity mismatch, or empty field reference — checked against functionMeta merged over the built-in defaultFunctionMeta (the same merge QueryBuilderExpressions applies, so one metadata registry drives the UI and validation alike). |
| getExpressionParserCEL | Generates a getExpression handler for @react-querybuilder/core/parseCEL!parseCEL. Pass customInverse to add arithmetic operators / function-call names or override built-ins (merged over defaultCELInverse), and customMeta to supply arity metadata for custom functions. The returned handler builds an ExpressionNode from a CEL operand subtree and auto-validates it, returning null (rule dropped) for unknown operators/functions or arity mismatches — the import-side mirror of getExpressionRuleProcessorCEL. |
| getExpressionParserJSONata | Generates a getExpression handler for @react-querybuilder/core/parseJSONata!parseJSONata. Pass customInverse to add functions/operators or override built-ins (merged over defaultJSONataInverse), and customMeta to supply arity metadata for custom functions. The returned handler builds an ExpressionNode from a JSONata operand subtree and auto-validates it, returning null (rule dropped) for unknown functions/operators or arity mismatches — the import-side mirror of getExpressionRuleProcessorJSONata. |
| getExpressionParserJsonLogic | Generates a getExpression handler for @react-querybuilder/core/parseJsonLogic!parseJsonLogic. Pass customInverse to add operations or override built-ins (merged over defaultJsonLogicInverse), and customMeta to supply arity metadata for custom functions. The returned handler builds an ExpressionNode from a JsonLogic operand subtree and auto-validates it, returning null (rule dropped) for unknown operations or arity mismatches — the import-side mirror of getExpressionRuleProcessorJsonLogic. |
| getExpressionParserMongoDB | Generates a getExpression handler for @react-querybuilder/core/parseMongoDB!parseMongoDB. Pass customInverse to add operators or override built-ins (merged over defaultMongoDBInverse), and customMeta to supply arity metadata for custom functions. The returned handler builds an ExpressionNode from a MongoDB aggregation-expression operand and auto-validates it, returning null (rule dropped) for unknown operators or arity mismatches — the import-side mirror of getExpressionRuleProcessorMongoDBQuery. |
| getExpressionParserSpEL | Generates a getExpression handler for @react-querybuilder/core/parseSpEL!parseSpEL. Pass customInverse to add arithmetic operators, functions, or methods (or override built-ins; merged over defaultSpELInverse), and customMeta to supply arity metadata. The returned handler builds an ExpressionNode from a SpEL operand subtree and auto-validates it, returning null (rule dropped) for unknown operators or arity mismatches — the import-side mirror of getExpressionRuleProcessorSpEL. |
| getExpressionParserSQL | Generates a getExpression handler for @react-querybuilder/core/parseSQL!parseSQL. Pass customInverse to add functions/operators or override built-ins (merged over defaultSQLInverse), and customMeta to supply arity metadata for custom functions. The returned handler builds an ExpressionNode from a SQL operand subtree and auto-validates it, returning null (rule dropped) for unknown functions/operators or arity mismatches — the import-side mirror of getExpressionRuleProcessorSQL. |
| getExpressionRuleProcessorCEL | Generates a rule processor with expression support for formatQuery with the "cel" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultCELSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorCypher | Generates a rule processor with expression support for formatQuery with the "cypher"/"gql" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultCypherSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorDrizzle | Generates a rule processor with expression support for use by formatQuery with the "drizzle" format. Expression rules compose Drizzle SQL fragments from context.columns (arithmetic, abs, least/greatest, upper/lower, etc.). Requires context.columns and context.drizzleOperators (whose sql tag is used) — the same context the stock processor needs. Pass custom serializers to add functions or override built-ins; they are merged over defaultDrizzleSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorElasticSearch | Generates a rule processor with expression support for use by formatQuery with the "elasticsearch" format. Expression rules emit a Painless script filter ({ bool: { filter: { script: { script } } } }), mirroring how the stock processor already scripts field-to-field comparisons. Supports scalar comparisons and expression-sourced between/notBetween. Pass custom serializers to add functions or override built-ins; they are merged over defaultPainlessSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorJSONata | Generates a rule processor with expression support for formatQuery with the "jsonata" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultJSONataSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorJsonLogic | Generates a rule processor with expression support for use by formatQuery with the "jsonlogic" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultJsonLogicSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorMongoDB | Generates a rule processor with expression support for use by formatQuery with the (deprecated) "mongodb" format. Wraps getExpressionRuleProcessorMongoDBQuery, JSON-stringifying its output. |
| getExpressionRuleProcessorMongoDBQuery | Generates a rule processor with expression support for use by formatQuery with the "mongodb_query" format. Expression rules emit MongoDB aggregation-expression form ({ $expr: { ... } }), where field operands become "$field" paths and functions map to native aggregation operators ($add, $multiply, $toUpper, etc.). String-match operators render via $indexOfCP/$substrCP (literal-substring semantics). Pass custom serializers to add functions or override built-ins; they are merged over defaultMongoDBSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorNL | Generates a rule processor with expression support for use by formatQuery with the "natural_language" format. Expression rules render their LHS (and any expression RHS/bounds) as an English noun phrase (e.g. the product of Price and Quantity is greater than 100). Pass custom serializers to add functions or override built-ins; they are merged over defaultNLSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorParameterized | Generates a rule processor with expression support for use by formatQuery with the "parameterized" and "parameterized_named" formats. Pass custom serializers to add functions or override built-ins; they are merged over defaultParameterizedSerializers. Bound values are pushed following the standard accumulator contract. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorSequelize | Generates a rule processor with expression support for use by formatQuery with the "sequelize" format. Expression rules render their LHS (and any expression RHS/bounds) as a SQL fragment (arithmetic via infix, functions via ABS/UPPER/LEAST/…), wrapped in sequelize.literal(...) and compared with sequelize.where(...). Requires these context helpers: sequelizeOperators (the Op object), sequelizeWhere (the where fn), sequelizeLiteral (the literal fn), and sequelizeCol (the col fn). Pass custom serializers to add functions or override built-ins; they are merged over defaultSQLSerializers. Rules without expressions, missing context, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorSPARQL | Generates a rule processor with expression support for formatQuery with the "sparql" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultSPARQLSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorSpEL | Generates a rule processor with expression support for formatQuery with the "spel" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultSpELSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorSQL | Generates a rule processor with expression support for use by formatQuery with the "sql" format. Pass custom serializers to add functions or override built-ins; they are merged over defaultSQLSerializers. Rules without expressions, or with an unsupported operator, fall back to the stock processor. |
| getExpressionRuleProcessorTanStackDB | Generates a rule processor with expression support for use by formatQuery with the "tanstack_db" format. Expression rules compose TanStack DB expressions from ref columns (arithmetic via add/subtract/…, upper/lower). Requires the same context the stock processor needs: tanStackDbOperators, _tanstackDbRefs, and _tanstackDbPrimaryRef. Pass custom serializers to add functions or override built-ins; they are merged over defaultTanStackDbSerializers. Rules without expressions, missing context, or with an unsupported operator/function, fall back to the stock processor (or are omitted). |
| getRuleExpressions | Resolves a rule's expression operands: lhs from rule.lhs, and the right-hand side from rule.value when valueSource is "expression". For between/notBetween operators the value is a 2-tuple [lower, upper] split into rhs/rhs2; all other operators carry a single rhs. Returns undefined when the rule carries no expression on either side. |
| makeStringExprProcessor | Builds a getExpressionRuleProcessor… factory for a string-output format. The returned factory accepts optional serializers merged over the format's built-ins. Supports scalar comparisons, is null/is not null, and expression-sourced between/notBetween; rules without expressions (or with any other operator) defer to the stock processor. |
| mergeCELInverse | Merges a custom CELInverse over the built-in defaultCELInverse. |
| mergeFunctionMeta | Merges one or more function-metadata registries (later entries win), defaulting the first source to defaultFunctionMeta so callers extend the built-ins by default. |
| mergeJSONataInverse | Merges a custom JSONataInverse (partial) over the built-in defaultJSONataInverse. |
| mergeJsonLogicInverse | Merges a custom JsonLogicInverse (partial) over the built-in defaultJsonLogicInverse. |
| mergeMongoDBInverse | Merges a custom MongoDBInverse over the built-in defaultMongoDBInverse. |
| mergeSpELInverse | Merges a custom SpELInverse over the built-in defaultSpELInverse. |
| mergeSQLInverse | Merges a custom SQLInverse (partial) over the built-in defaultSQLInverse. |
| quoteLeaf | Quotes a non-numeric leaf value with quote, escaping embedded quote chars when asked. |
| serializeDrizzle | Recursively serializes an expression node to a Drizzle operand (Column, SQL fragment, or literal). field nodes resolve to columns[field]; parameter nodes emit the name as a string literal; value nodes emit the raw (number-coerced) literal (interpolated as a bound parameter by callers); func nodes delegate to the registered Drizzle serializer. Throws if a referenced column is missing. |
| serializeInfix | Recursively serializes an expression node to a string fragment for the "infix" string formats (cel, spel, cypher, sparql, jsonata). field/value leaves defer to the InfixDialect; parameter nodes use renderParameter (bare name) when the dialect defines it, else render the name as a literal; func nodes delegate to the registered serializer (a (opts, ...args) => string), resolved for the active preset and invoked opts-first. |
| serializeMongoAgg | Recursively serializes an expression node to a MongoDB aggregation-expression value. field nodes become the field-path string "$field"; parameter nodes emit the name as a string literal; value nodes emit the raw (number-coerced) literal; func nodes delegate to the registered aggregation serializer (an operator name wrapping the args in { [op]: args }, or an opts-first function). |
| serializeTanStackDb | Recursively serializes an expression node to a TanStack DB expression. field nodes resolve to ref columns; parameter nodes emit the name as a string literal; value nodes emit the raw (number-coerced) literal; func nodes delegate to the registered serializer. Throws for unknown functions (caller validates first to omit such rules). |
| validateExpression | Recursively validates an expression node. Flags unknown functions (not present in the known set — see ValidateExpressionOptions.functions), arity mismatches (against ValidateExpressionOptions.meta), and empty field/parameter references. formatQuery skips rules whose expressions fail validation (the rule processors return empty/false). |
Interfaces
| Interface | Description |
|---|---|
| CELInverse | Inverse of defaultCELSerializers for the import direction (parsing). operators maps CEL arithmetic node types (Addition, Subtraction, Multiplication, Division, Modulo) to fn keys; functions maps CEL FunctionCall names to fn keys (empty by default — custom only). The min/max emulated templates ((a < b ? a : b) / (a > b ? a : b)) are recovered structurally, not via this registry. |
| DrizzleSerializeContext | Drizzle serialization context: the sql template tag and the columns map (both taken from formatQuery's context), used to resolve field operands to Drizzle Columns. |
| DrizzleSqlTag | Drizzle's sql template tag (plus its .join/.raw helpers), typed loosely to avoid a hard dependency on drizzle-orm. Provided to Drizzle expression serializers so they can compose column/value operands into SQL fragments. |
| ExpressionFunctionMeta | UI/validation metadata for a function usable in an expression. Arithmetic operators (+ - * /) are modeled as ordinary functions. This describes only how a function appears and how many arguments it accepts — the per-format serializers live in their own (internal) maps, mirroring the datetime package's format-specific processors. |
| ExpressionValidationResult | Result of validateExpression. |
| InfixDialect | Per-format hooks for the shared string ("infix") expression walker. renderField quotes a field reference for the target language (e.g. bare field, ?field); renderLeaf renders a value leaf (numbers bare, strings quoted/escaped per dialect). renderParameter (optional) renders a parameter node: dialects with native bind syntax (CEL/SpEL) emit the bare name; when omitted, the name is emitted as a string literal (paradigm B). |
| JSONataInverse | Inverse of defaultJSONataSerializers: maps JSONata infix operators and function names back to fn keys for the import direction (parsing). Mirrors the SQLInverse shape. |
| ResolvedExpressions | Expression operands resolved from a rule's lhs property and its value/valueSource (when valueSource is "expression"). Returned by getRuleExpressions. |
| SpELInverse | Inverse of defaultSpELSerializers for the import direction (parsing). operators maps SpEL arithmetic node types (op-plus/op-minus/op-divide/op-multiply/op-modulus) to fn keys, functions maps static/bare call names (T(java.lang.Math).abs(...), myFunc(...)) to fn keys, and methods maps instance method names (.toUpperCase()) to fn keys. |
| SQLInverse | Inverse of defaultSQLSerializers: maps SQL surface syntax back to fn keys for the import direction (parsing). operators is keyed by arithmetic BitExpression operator token; functions is keyed by upper-cased FunctionCall name. Ambiguous inverses accept all known spellings (%/MOD → mod, LEAST/MIN → min, GREATEST/MAX → max). |
| StringExprConfig | Configuration for a string-output ("infix") expression rule processor. Describes how to render each supported operator category around already-serialized lhs/rhs fragments, plus the InfixDialect used to serialize the expression trees themselves. |
| TanStackDbSerializeContext | TanStack DB serialization context: the ops object (expression functions) and a resolveField resolver mapping a field name to its ref column (dotted → refs.prefix.rest, bare → refs[primaryRef].field), matching the stock processor. |
| ValidateExpressionOptions | Inputs validateExpression checks a node against. |
Type Aliases
| Type Alias | Description |
|---|---|
| CELExpressionParser | A getExpression handler for @react-querybuilder/core/parseCEL!parseCEL. |
| DrizzleSerializer | Drizzle serializer: receives the sql tag, the format options, then the already-serialized argument operands (Drizzle Columns, SQL fragments, or literal values), and returns an SQL fragment. Used for the "drizzle" format. |
| DrizzleSerializerRegistry | Map of registry keys to DrizzleSerializer entries. |
| ExpressionFunctionMetaRegistry | Map of registry keys to ExpressionFunctionMeta definitions. |
| ExpressionNode | A single node in an expression tree. Expressions are recursive: a func node's arguments are themselves ExpressionNodes, enabling arbitrary nesting. |
| JSONataExpressionParser | A getExpression handler for @react-querybuilder/core/parseJSONata!parseJSONata. |
| JsonLogicExpressionParser | A getExpression handler for @react-querybuilder/core/parseJsonLogic!parseJsonLogic. |
| JsonLogicInverse | Inverse of defaultJsonLogicSerializers: maps a JsonLogic operation object's key back to an fn key for the import direction (parsing). Two-argument operators (+ - * / %), variadic (min/max), and unary (abs/upper/lower) all share one flat key→fn map; the parser reads a node's payload as an array (or wraps a scalar) to recover its arguments. |
| JsonLogicOperator | A JSONLogic custom-operator implementation (the code arg of json-logic-js's add_operation). |
| JsonLogicSerializer | JSONLogic serializer: an operator name (wrapping the serialized args in { [op]: args }), or a function receiving the format options followed by the serialized args. |
| JsonLogicSerializerRegistry | Map of registry keys to JsonLogicSerializer entries. |
| MongoAggSerializer | MongoDB aggregation-expression serializer: an operator name (wrapping the serialized args in { [op]: args }), or a function receiving the format options followed by the serialized args. Used for the "mongodb_query" / "mongodb" formats. |
| MongoAggSerializerRegistry | Map of registry keys to MongoAggSerializer entries. |
| MongoDBExpressionParser | A getExpression handler for @react-querybuilder/core/parseMongoDB!parseMongoDB. |
| MongoDBInverse | Inverse of defaultMongoDBSerializers: maps MongoDB aggregation-operator names to fn keys for the import direction (parsing). Keyed by operator token (e.g. $multiply). |
| ParameterizedSerializerRegistry | Map of registry keys to SQLSerializer entries (the "parameterized" / "parameterized_named" formats). Identical in shape and signature to SQLSerializerRegistry — serializers receive placeholder/field strings the same way the "sql" serializers receive literals. |
| SpELExpressionParser | A getExpression handler for @react-querybuilder/core/parseSpEL!parseSpEL. |
| SQLExpressionParser | A getExpression handler for @react-querybuilder/core/parseSQL!parseSQL. |
| SQLSerializer | A SQL (or parameterized-SQL) serializer entry: either a single SQLSerializerFn, or a preset-keyed map for dialect variance. The default is used for any preset without an explicit override (e.g. min/max emit LEAST/GREATEST by default but MIN/MAX for the sqlite preset). |
| SQLSerializerFn | SQL serializer function: receives the format options (for preset/parseNumbers awareness) followed by the already-serialized argument strings, and returns a SQL fragment. |
| SQLSerializerRegistry | Map of registry keys to SQLSerializer entries (the "sql" format). |
| StringMatchKind | Canonical string-match category emitted by a StringExprConfig.renderStringMatch. |
| TanStackDbSerializer | TanStack DB serializer: receives the tanStackDbOperators object (its expression functions — add, upper, etc.), the format options, then the already-serialized argument operands (ref columns, nested expression results, or literal values), and returns a TanStack DB expression. Used for the "tanstack_db" format. |
| TanStackDbSerializerRegistry | Map of registry keys to TanStackDbSerializer entries. |
Variables
| Variable | Description |
|---|---|
| celTemplateFns | fn keys recovered from CEL emulated templates (structural match, not via CELInverse). |
| defaultCELInverse | Built-in CELInverse registry (mirror of the invertible defaultCELSerializers). |
| defaultCELSerializers | Built-in "cel" (CEL) expression serializers. Arithmetic and mod use native infix operators; abs/min/max use native conditional expressions; upper/lower use the CEL strings-extension .upperAscii()/.lowerAscii() macros. |
| defaultCypherSerializers | Built-in "cypher"/"gql" (openCypher / GQL) expression serializers. Arithmetic and mod use native infix operators; abs/toUpper/toLower are native functions; scalar min/max (Cypher's min/max are aggregates) are emulated with CASE expressions. |
| defaultDrizzleSerializers | Built-in "drizzle" serializers. Arithmetic and mod emit parenthesized infix SQL (+ - * / %); abs emits abs(...); min/max emit least(...)/greatest(...) (or min(...)/max(...) for the sqlite preset); upper/lower emit upper(...)/ lower(...). Each serializer receives Drizzle's sql tag, the format options, then the serialized argument operands. |
| defaultFunctionMeta | Built-in expression function metadata (UI label + arity) for the arithmetic operators (+ - * /), variadic min/max, binary mod, unary abs, and string upper/lower. Serialization lives in the per-format serializer maps (defaultSQLSerializers, defaultParameterizedSerializers, defaultJsonLogicSerializers); this map drives the expression UI and the format-agnostic validator. |
| defaultJSONataInverse | Built-in JSONataInverse registry (mirror of defaultJSONataSerializers). |
| defaultJSONataSerializers | Built-in "jsonata" (JSONata) expression serializers. Arithmetic and mod use native infix operators; abs/min/max/uppercase/lowercase map to the built-in $-prefixed functions ($min/$max take an array argument). |
| defaultJsonLogicInverse | Built-in JsonLogicInverse registry (mirror of defaultJsonLogicSerializers). |
| defaultJsonLogicSerializers | Built-in "jsonlogic" serializers. Arithmetic (+ - * /), min/max, and mod (%) map to stock JSONLogic operators; abs, upper, and lower emit same-named custom operators (register them on your JSONLogic instance via jsonLogicExpressionOperators before applying the exported logic). Each function serializer is opts-first ((opts, ...args) => unknown); the built-ins ignore opts. |
| defaultMongoDBInverse | Built-in MongoDBInverse registry (mirror of defaultMongoDBSerializers). |
| defaultMongoDBSerializers | Built-in "mongodb_query" aggregation-expression serializers. Arithmetic ($add, $subtract, $multiply, $divide), min/max ($min/$max), mod ($mod), and abs ($abs) map to native aggregation operators; upper/lower map to $toUpper/ $toLower. Each function serializer is opts-first ((opts, ...args) => unknown); the built-ins ignore opts. |
| defaultNLSerializers | Built-in "natural_language" serializers rendering each function as an English noun phrase (e.g. the product of X and Y, the absolute value of X). min/max join their operands with commas. Each serializer is opts-first ((opts, ...args) => string). |
| defaultPainlessSerializers | Built-in "elasticsearch" (Painless script) serializers. Arithmetic and mod emit parenthesized infix (+ - * / %); abs emits Math.abs(...); min/max fold into nested Math.min/Math.max; upper/lower emit .toUpperCase()/.toLowerCase(). Each serializer is opts-first ((opts, ...args) => string). |
| defaultParameterizedSerializers | Built-in "parameterized" / "parameterized_named" serializers. The parameterized walker binds value leaves as placeholders and passes the resulting placeholder/field strings to these serializers exactly as the "sql" walker passes literal strings — so the built-in function serializers are identical to defaultSQLSerializers (re-exported here). |
| defaultSPARQLSerializers | Built-in "sparql" (SPARQL 1.1 FILTER expression) serializers. Arithmetic uses native infix operators; abs/ucase/lcase are native functions. SPARQL FILTER has no scalar mod/min/max, so mod is emulated with FLOOR and min/max with IF. |
| defaultSpELInverse | Built-in SpELInverse registry (mirror of defaultSpELSerializers). |
| defaultSpELSerializers | Built-in "spel" (Spring Expression Language) expression serializers. Arithmetic and mod use native infix operators; abs/min/max delegate to java.lang.Math; upper/lower use String#toUpperCase()/toLowerCase(). |
| defaultSQLInverse | Built-in SQLInverse registry (mirror of defaultSQLSerializers). |
| defaultSQLSerializers | Built-in "sql" serializers: arithmetic (+ - * /, infix and parenthesized for precedence safety), variadic min/max, binary mod, unary abs, and string upper/lower. Each serializer is opts-first ((opts, ...args) => string); the built-ins ignore opts except min/max, which vary by SQL preset. |
| defaultTanStackDbSerializers | Built-in "tanstack_db" serializers. Arithmetic maps to TanStack DB's add/subtract/ multiply/divide expression functions; upper/lower map to upper/lower. TanStack DB has no scalar abs/mod, and min/max are aggregates (invalid in a where predicate), so those functions are intentionally omitted — expression rules using them are omitted from the output. Each serializer receives the ops object, the format options, then the serialized argument operands. |
| expressionParserCEL | Ready-to-use CEL expression parser bound to defaultCELInverse. |
| expressionParserJSONata | Ready-to-use JSONata expression parser bound to defaultJSONataInverse. |
| expressionParserJsonLogic | Ready-to-use JsonLogic expression parser bound to defaultJsonLogicInverse. |
| expressionParserMongoDB | Ready-to-use MongoDB expression parser bound to defaultMongoDBInverse. |
| expressionParserSpEL | Ready-to-use SpEL expression parser bound to defaultSpELInverse. |
| expressionParserSQL | Ready-to-use SQL expression parser bound to defaultSQLInverse. |
| expressionRuleProcessorCEL | Ready-to-use "cel" rule processor bound to defaultCELSerializers. |
| expressionRuleProcessorCypher | Ready-to-use "cypher"/"gql" rule processor bound to defaultCypherSerializers. |
| expressionRuleProcessorDrizzle | Ready-to-use "drizzle" rule processor bound to defaultDrizzleSerializers. |
| expressionRuleProcessorElasticSearch | Ready-to-use "elasticsearch" rule processor bound to defaultPainlessSerializers. |
| expressionRuleProcessorJSONata | Ready-to-use "jsonata" rule processor bound to defaultJSONataSerializers. |
| expressionRuleProcessorJsonLogic | Ready-to-use "jsonlogic" rule processor bound to defaultJsonLogicSerializers. |
| expressionRuleProcessorMongoDB | Ready-to-use (deprecated) "mongodb" rule processor bound to defaultMongoDBSerializers. |
| expressionRuleProcessorMongoDBQuery | Ready-to-use "mongodb_query" rule processor bound to defaultMongoDBSerializers. |
| expressionRuleProcessorNL | Ready-to-use "natural_language" rule processor bound to defaultNLSerializers. |
| expressionRuleProcessorParameterized | Ready-to-use "parameterized"/"parameterized_named" rule processor bound to defaultParameterizedSerializers. |
| expressionRuleProcessorSequelize | Ready-to-use "sequelize" rule processor bound to defaultSQLSerializers. |
| expressionRuleProcessorSPARQL | Ready-to-use "sparql" rule processor bound to defaultSPARQLSerializers. |
| expressionRuleProcessorSpEL | Ready-to-use "spel" rule processor bound to defaultSpELSerializers. |
| expressionRuleProcessorSQL | Ready-to-use "sql" rule processor bound to defaultSQLSerializers. |
| expressionRuleProcessorTanStackDB | Ready-to-use "tanstack_db" rule processor bound to defaultTanStackDbSerializers. |
| jsonLogicExpressionOperators | Runtime implementations for the non-stock operators emitted by defaultJsonLogicSerializers. Keys match the operator names produced by the default abs/upper/lower serializers. |
caution
API documentation is generated from the latest commit on the main branch. It may be somewhat inconsistent with official releases of React Query Builder.