@react-querybuilder/core 8.9.1 → 8.9.2

package/dist/convertQuery-H7RhQiIc.mjs

@@ -0,0 +1,75 @@
+import { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc } from "./isRuleGroup-CnhYpLOM.mjs";
+import { produce } from "immer";
+
+//#region src/utils/convertQuery.ts
+const combinatorLevels = [
+	"or",
+	"xor",
+	"and"
+];
+const isSameString = (a, b) => lc(a) === b;
+const generateRuleGroupICWithConsistentCombinators = (rg, baseCombinatorLevel = 0) => {
+	const baseCombinator = combinatorLevels[baseCombinatorLevel];
+	if (!rg.rules.includes(baseCombinator)) return baseCombinatorLevel < combinatorLevels.length - 2 ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1) : rg;
+	return produce(rg, (draft) => {
+		let cursor = 0;
+		while (cursor < draft.rules.length - 2) {
+			if (isSameString(draft.rules[cursor + 1], baseCombinator)) {
+				cursor += 2;
+				continue;
+			}
+			const nextBaseCombinatorIndex = draft.rules.findIndex((r, i) => i > cursor && typeof r === "string" && lc(r) === baseCombinator);
+			if (nextBaseCombinatorIndex === -1) {
+				draft.rules.splice(cursor, draft.rules.length, generateRuleGroupICWithConsistentCombinators({ rules: draft.rules.slice(cursor) }, baseCombinatorLevel + 1));
+				break;
+			} else draft.rules.splice(cursor, nextBaseCombinatorIndex - cursor, generateRuleGroupICWithConsistentCombinators({ rules: draft.rules.slice(cursor, nextBaseCombinatorIndex) }, baseCombinatorLevel + 1));
+		}
+	});
+};
+/**
+* Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.
+*
+* This function is idempotent: {@link RuleGroupType} queries will be
+* returned as-is.
+*
+* @group Query Tools
+*/
+const convertFromIC = (rg) => {
+	if (isRuleGroupType(rg)) return rg;
+	const processedRG = generateRuleGroupICWithConsistentCombinators(rg);
+	const rulesAsMixedList = processedRG.rules.map((r) => typeof r === "string" || !isRuleGroup(r) ? r : convertFromIC(r));
+	const combinator = rulesAsMixedList.length < 2 ? "and" : rulesAsMixedList[1];
+	const rules = rulesAsMixedList.filter((r) => typeof r !== "string");
+	return {
+		...processedRG,
+		combinator,
+		rules
+	};
+};
+/**
+* Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.
+*
+* This function is idempotent: {@link RuleGroupTypeIC} queries will be
+* returned as-is.
+*
+* @group Query Tools
+*/
+const convertToIC = (rg) => {
+	if (isRuleGroupTypeIC(rg)) return rg;
+	const { combinator,...queryWithoutCombinator } = rg;
+	const rules = [];
+	const { length } = rg.rules;
+	for (const [idx, r] of rg.rules.entries()) {
+		if (isRuleGroup(r)) rules.push(convertToIC(r));
+		else rules.push(r);
+		if (combinator && idx < length - 1) rules.push(combinator);
+	}
+	return {
+		...queryWithoutCombinator,
+		rules
+	};
+};
+
+//#endregion
+export { convertFromIC, convertToIC };
+//# sourceMappingURL=convertQuery-H7RhQiIc.mjs.map

package/dist/convertQuery-H7RhQiIc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertQuery-H7RhQiIc.mjs","names":["rules: (RuleGroupTypeIC | RuleType | string)[]"],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import { produce } from 'immer';\nimport type {\n  RuleGroupArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  return produce(rg, draft => {\n    let cursor = 0;\n\n    // Group all chains of combinators in the rule array that are not the base combinator\n    while (cursor < draft.rules.length - 2) {\n      if (isSameString(draft.rules[cursor + 1], baseCombinator)) {\n        cursor += 2;\n        continue;\n      }\n\n      const nextBaseCombinatorIndex = draft.rules.findIndex(\n        (r, i) => i > cursor && typeof r === 'string' && lc(r) === baseCombinator\n      );\n\n      if (nextBaseCombinatorIndex === -1) {\n        // No more instances of this combinator, so group all remaining rules and exit the loop\n        draft.rules.splice(\n          cursor,\n          draft.rules.length,\n          generateRuleGroupICWithConsistentCombinators(\n            // oxlint-disable-next-line typescript/no-explicit-any\n            { rules: draft.rules.slice(cursor) as any },\n            baseCombinatorLevel + 1\n          )\n        );\n        break;\n      } else {\n        // Group all rules between the current cursor and the next instance of the base combinator\n        draft.rules.splice(\n          cursor,\n          nextBaseCombinatorIndex - cursor,\n          generateRuleGroupICWithConsistentCombinators(\n            // oxlint-disable-next-line typescript/no-explicit-any\n            { rules: draft.rules.slice(cursor, nextBaseCombinatorIndex) as any },\n            baseCombinatorLevel + 1\n          )\n        );\n      }\n    }\n  });\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupType = RuleGroupType>(\n  rg: RuleGroupTypeAny\n): RG => {\n  if (isRuleGroupType(rg)) {\n    return rg as RG;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rulesAsMixedList = processedRG.rules.map(r =>\n    typeof r === 'string' || !isRuleGroup(r) ? r : convertFromIC(r)\n  );\n  const combinator = rulesAsMixedList.length < 2 ? 'and' : (rulesAsMixedList[1] as string);\n  const rules = rulesAsMixedList.filter(r => typeof r !== 'string') as RuleGroupArray;\n  return { ...processedRG, combinator, rules } as RG;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RGIC extends RuleGroupTypeIC = RuleGroupTypeIC>(\n  rg: RuleGroupTypeAny\n): RGIC => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as RGIC;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (const [idx, r] of rg.rules.entries()) {\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as RGIC;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;;;AAWA,MAAM,mBAAmB;CAAC;CAAM;CAAO;CAAM;AAE7C,MAAM,gBAAgB,GAAY,MAAc,GAAG,EAAE,KAAK;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;AAGxC,KAAI,CAAC,GAAG,MAAM,SAAS,eAAsB,CAG3C,QAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,EAAE,GACzE;AAGN,QAAO,QAAQ,KAAI,UAAS;EAC1B,IAAI,SAAS;AAGb,SAAO,SAAS,MAAM,MAAM,SAAS,GAAG;AACtC,OAAI,aAAa,MAAM,MAAM,SAAS,IAAI,eAAe,EAAE;AACzD,cAAU;AACV;;GAGF,MAAM,0BAA0B,MAAM,MAAM,WACzC,GAAG,MAAM,IAAI,UAAU,OAAO,MAAM,YAAY,GAAG,EAAE,KAAK,eAC5D;AAED,OAAI,4BAA4B,IAAI;AAElC,UAAM,MAAM,OACV,QACA,MAAM,MAAM,QACZ,6CAEE,EAAE,OAAO,MAAM,MAAM,MAAM,OAAO,EAAS,EAC3C,sBAAsB,EACvB,CACF;AACD;SAGA,OAAM,MAAM,OACV,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,MAAM,MAAM,MAAM,QAAQ,wBAAwB,EAAS,EACpE,sBAAsB,EACvB,CACF;;GAGL;;;;;;;;;;AAWJ,MAAa,iBACX,OACO;AACP,KAAI,gBAAgB,GAAG,CACrB,QAAO;CAET,MAAM,cAAc,6CAA6C,GAAG;CACpE,MAAM,mBAAmB,YAAY,MAAM,KAAI,MAC7C,OAAO,MAAM,YAAY,CAAC,YAAY,EAAE,GAAG,IAAI,cAAc,EAAE,CAChE;CACD,MAAM,aAAa,iBAAiB,SAAS,IAAI,QAAS,iBAAiB;CAC3E,MAAM,QAAQ,iBAAiB,QAAO,MAAK,OAAO,MAAM,SAAS;AACjE,QAAO;EAAE,GAAG;EAAa;EAAY;EAAO;;;;;;;;;;AAW9C,MAAa,eACX,OACS;AACT,KAAI,kBAAkB,GAAG,CACvB,QAAO;CAET,MAAM,EAAE,WAAY,GAAG,2BAA2B;CAClD,MAAMA,QAAiD,EAAE;CACzD,MAAM,EAAE,WAAW,GAAG;AACtB,MAAK,MAAM,CAAC,KAAK,MAAM,GAAG,MAAM,SAAS,EAAE;AACzC,MAAI,YAAY,EAAE,CAChB,OAAM,KAAK,YAAY,EAAE,CAAC;MAE1B,OAAM,KAAK,EAAE;AAEf,MAAI,cAAc,MAAM,SAAS,EAC/B,OAAM,KAAK,WAAW;;AAG1B,QAAO;EAAE,GAAG;EAAwB;EAAO"}

package/dist/export-r-V7bU31.d.mts

@@ -0,0 +1,452 @@
+import { DefaultOperatorName, Except, FlexibleOptionList, FullField, FullOperator, FullOptionList, InputType, ParseNumbersPropConfig, QueryValidator, RuleGroupTypeAny, RuleType, RuleValidator, ValidationMap, ValidationResult, ValueSource } from "./basic-BfD-7CN3.mjs";
+import { RulesLogic } from "json-logic-js";
+
+//#region src/types/export.d.ts
+
+/**
+* Available export formats for {@link formatQuery}.
+*
+* @group Export
+*/
+type ExportFormat = "json" | "sql" | "json_without_ids" | "parameterized" | "parameterized_named" | "mongodb" | "mongodb_query" | "cel" | "jsonlogic" | "spel" | "elasticsearch" | "jsonata" | "natural_language" | "ldap" | "drizzle" | "prisma" | "sequelize";
+/**
+* Export formats for {@link formatQuery} that produce objects instead of strings.
+*
+* @group Export
+*/
+type ExportObjectFormats = "parameterized" | "parameterized_named" | "jsonlogic" | "elasticsearch" | "jsonata" | "mongodb_query";
+/**
+* Available presets for the "sql" export format.
+*
+* @group Export
+*/
+type SQLPreset = "ansi" | "sqlite" | "postgresql" | "mysql" | "mssql" | "oracle";
+/**
+* A map of operators to strings to be used in the output of {@link formatQuery}. If the
+* result can differ based on the `valueSource`, the key should map to an array where the
+* second element represents the string to be used when `valueSource` is "field". The first
+* element will be used in all other cases.
+*
+* @group Export
+*/
+type ExportOperatorMap = Partial<Record<Lowercase<DefaultOperatorName> | DefaultOperatorName, string | [string, string]>>;
+/**
+* Options object shape for {@link formatQuery}.
+*
+* @group Export
+*/
+interface FormatQueryOptions {
+  /**
+  * The {@link ExportFormat}.
+  */
+  format?: ExportFormat;
+  /**
+  * This function will be used to process the `operator` from each rule
+  * for query language formats. If not defined, the appropriate
+  * `defaultOperatorProcessor*` for the format will be used.
+  */
+  operatorProcessor?: RuleProcessor;
+  /**
+  * This function will be used to process the `value` from each rule
+  * for query language formats. If not defined, the appropriate
+  * `defaultValueProcessor*` for the format will be used.
+  */
+  valueProcessor?: ValueProcessorLegacy | ValueProcessorByRule;
+  /**
+  * This function will be used to process each rule. If not defined, the appropriate
+  * `defaultRuleProcessor*` for the given format will be used.
+  */
+  ruleProcessor?: RuleProcessor;
+  /**
+  * This function will be used to process each rule group. If not defined, the appropriate
+  * `defaultRuleGroupProcessor*` for the format will be used.
+  *
+  * If this function is defined, it will override the `format` option. This also allows
+  * `formatQuery` to produce completely custom output formats.
+  */
+  ruleGroupProcessor?: RuleGroupProcessor;
+  /**
+  * In the "sql", "parameterized", "parameterized_named", and "jsonata" export
+  * formats, field names will be bracketed by this string. If an array of strings
+  * is passed, field names will be preceded by the first element and
+  * succeeded by the second element.
+  *
+  * Tip: Use `fieldIdentifierSeparator` to bracket identifiers individually within field names.
+  *
+  * @default '' // the empty string
+  *
+  * @example
+  * formatQuery(query, { format: 'sql', quoteFieldNamesWith: '"' })
+  * // `"First name" = 'Steve'`
+  *
+  * @example
+  * formatQuery(query, { format: 'sql', quoteFieldNamesWith: ['[', ']'] })
+  * // "[First name] = 'Steve'"
+  */
+  quoteFieldNamesWith?: string | [string, string];
+  /**
+  * When used in conjunction with the `quoteFieldNamesWith` option, field names will
+  * be split by this string, each part being individually processed as per the rules
+  * of the `quoteFieldNamesWith` configuration. The parts will then be re-joined
+  * by the same string.
+  *
+  * A common value for this option is `'.'`.
+  *
+  * A value of `''` (the empty string) will disable splitting/rejoining.
+  *
+  * @default ''
+  *
+  * @example
+  * formatQuery(query, {
+  *   format: 'sql',
+  *   quoteFieldNamesWith: ['[', ']'],
+  *   fieldIdentifierSeparator: '.',
+  * })
+  * // "[dbo].[Musicians].[First name] = 'Steve'"
+  */
+  fieldIdentifierSeparator?: string;
+  /**
+  * Character to use for quoting string values in the SQL format.
+  * @default `'`
+  */
+  quoteValuesWith?: string;
+  /**
+  * Validator function for the entire query. Can be the same function passed
+  * as `validator` prop to {@link QueryBuilder}.
+  */
+  validator?: QueryValidator;
+  /**
+  * This can be the same {@link FullField} array passed to {@link QueryBuilder}, but
+  * really all you need to provide is the `name` and `validator` for each field.
+  *
+  * The full field object from this array, where the field's identifying property
+  * matches the rule's `field`, will be passed to the rule processor.
+  */
+  fields?: FlexibleOptionList<FullField>;
+  /**
+  * This can be the same `getOperators` function passed to {@link QueryBuilder}.
+  *
+  * The full operator object from this array, where the operator's identifying property
+  * matches the rule's `operator`, will be passed to the rule processor.
+  */
+  getOperators?(field: string, misc: {
+    fieldData: FullField;
+  }): FlexibleOptionList<FullOperator> | null;
+  /**
+  * This string will be inserted in place of invalid groups for non-JSON formats.
+  * Defaults to `'(1 = 1)'` for "sql"/"parameterized"/"parameterized_named" and
+  * `'$and:[{$expr:true}]'` for "mongodb".
+  */
+  fallbackExpression?: string;
+  /**
+  * This string will be placed in front of named parameters (aka bind variables)
+  * when using the "parameterized_named" export format.
+  *
+  * @default ":"
+  */
+  paramPrefix?: string;
+  /**
+  * Maintains the parameter prefix in the `params` object keys when using the
+  * "parameterized_named" export format. Recommended when using SQLite.
+  *
+  * @default false
+  *
+  * @example
+  * console.log(formatQuery(query, {
+  *   format: "parameterized_named",
+  *   paramPrefix: "$",
+  *   paramsKeepPrefix: true
+  * }).params)
+  * // { $firstName: "Stev" }
+  * // Default (`paramsKeepPrefix` is `false`):
+  * // { firstName: "Stev" }
+  */
+  paramsKeepPrefix?: boolean;
+  /**
+  * Renders parameter placeholders as a series of sequential numbers
+  * instead of '?' like the default. This option will respect the
+  * `paramPrefix` option like the 'parameterized_named' format.
+  *
+  * @default false
+  */
+  numberedParams?: boolean;
+  /**
+  * Preserves the order of values for "between" and "notBetween" rules, even if a larger
+  * value comes before a smaller value (which will always evaluate to false).
+  */
+  preserveValueOrder?: boolean;
+  /**
+  * Renders values as either `number`-types or unquoted strings, as
+  * appropriate and when possible. Each `string`-type value is evaluated
+  * against {@link numericRegex} to determine if it can be represented as a
+  * plain numeric value. If so, `parseFloat` is used to convert it to a number.
+  */
+  parseNumbers?: ParseNumbersPropConfig;
+  /**
+  * Any rules where the field is equal to this value will be ignored.
+  *
+  * @default '~'
+  */
+  placeholderFieldName?: string;
+  /**
+  * Any rules where the operator is equal to this value will be ignored.
+  *
+  * @default '~'
+  */
+  placeholderOperatorName?: string;
+  /**
+  * Any rules where the value is equal to this value will be ignored.
+  *
+  * @default '~'
+  */
+  placeholderValueName?: string;
+  /**
+  * Operator to use when concatenating wildcard characters and field names in "sql" format.
+  * The ANSI standard is `||`, while SQL Server uses `+`. MySQL does not implement a concatenation
+  * operator by default, and therefore requires use of the `CONCAT` function.
+  *
+  * If `concatOperator` is set to `"CONCAT"` (case-insensitive), the `CONCAT` function will be
+  * used. Note that Oracle SQL does not support more than two values in the `CONCAT` function,
+  * so this option should not be used in that context. The default setting (`"||"`) is already
+  * compatible with Oracle SQL.
+  *
+  * @default '||'
+  */
+  concatOperator?: "||" | "+" | "CONCAT" | (string & {});
+  /**
+  * Option presets to maximize compatibility with various SQL dialects.
+  */
+  preset?: SQLPreset;
+  /**
+  * Map of operators to their translations for the "natural_language" format. If the
+  * result can differ based on the `valueSource`, the key should map to an array where the
+  * second element represents the string to be used when `valueSource` is "field". The first
+  * element will be used in all other cases.
+  */
+  operatorMap?: ExportOperatorMap;
+  /**
+  * [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
+  * for the "natural_language" format. Can be abbreviated like "SVO" or spelled out like
+  * "subject-verb-object".
+  *
+  * - Subject = field
+  * - Verb = operator
+  * - Object = value
+  */
+  wordOrder?: ConstituentWordOrderString | Lowercase<ConstituentWordOrderString> | ({} & string);
+  /**
+  * Translatable strings used by the "natural_language" format.
+  */
+  translations?: Partial<Record<NLTranslationKey, string>>;
+  context?: Record<string, any>;
+}
+/**
+* Options object for {@link ValueProcessorByRule} functions.
+*
+* @group Export
+*/
+interface ValueProcessorOptions extends FormatQueryOptions {
+  valueProcessor?: ValueProcessorByRule;
+  escapeQuotes?: boolean;
+  /**
+  * The full field object, if `fields` was provided in the
+  * {@link formatQuery} options parameter.
+  */
+  fieldData?: FullField;
+  /**
+  * Included for the "parameterized_named" format only. Keys of this object represent
+  * field names and values represent the current list of parameter names for that
+  * field based on the query rules processed up to that point. Use this list to
+  * ensure that parameter names generated by the custom rule processor are unique.
+  */
+  fieldParamNames?: Record<string, string[]>;
+  /**
+  * Included for the "parameterized_named" format only. Call this function with a
+  * field name to get a unique parameter name, as yet unused during query processing.
+  */
+  getNextNamedParam?: (field: string) => string;
+  /**
+  * Additional prefix and suffix characters to wrap the value in. Useful for augmenting
+  * the default value processor results with special syntax (e.g., for dates or function
+  * calls).
+  */
+  wrapValueWith?: [string, string];
+  /**
+  * Parse numbers in the rule value.
+  *
+  * @default false
+  */
+  parseNumbers?: boolean;
+}
+/**
+* Options object curated by {@link formatQuery} and passed to a {@link RuleGroupProcessor}.
+*
+* @group Export
+*/
+interface FormatQueryFinalOptions extends Required<Except<FormatQueryOptions, "context" | "valueProcessor" | "validator" | "placeholderValueName" | "ruleGroupProcessor" | "parseNumbers">> {
+  fields: FullOptionList<FullField>;
+  getParseNumberBoolean: (inputType?: InputType | null) => boolean | undefined;
+  parseNumbers?: ParseNumbersPropConfig | undefined;
+  placeholderValueName?: string | undefined;
+  valueProcessor: ValueProcessorByRule;
+  validator?: QueryValidator;
+  validateRule: FormatQueryValidateRule;
+  validationMap: ValidationMap;
+  context?: Record<string, unknown>;
+}
+/**
+* Function that produces a processed value for a given {@link RuleType}.
+*
+* @group Export
+*/
+type ValueProcessorByRule = (rule: RuleType, options?: ValueProcessorOptions) => string;
+/**
+* Function that produces a processed value for a given `field`, `operator`, `value`,
+* and `valueSource`.
+*
+* @group Export
+*/
+type ValueProcessorLegacy = (field: string, operator: string, value: any, valueSource?: ValueSource) => string;
+/**
+* Function to produce a result that {@link formatQuery} uses when processing a
+* {@link RuleType} object.
+*
+* See the default rule processor for each format to know what type to return.
+* | Format                   | Default rule processor                    |
+* | ------------------------ | ----------------------------------------- |
+* | `sql`                    | {@link defaultRuleProcessorSQL}           |
+* | `parameterized`          | {@link defaultRuleProcessorParameterized} |
+* | `parameterized_named`    | {@link defaultRuleProcessorParameterized} |
+* | `mongodb` _(deprecated)_ | {@link defaultRuleProcessorMongoDB}       |
+* | `mongodb_query`          | {@link defaultRuleProcessorMongoDBQuery}  |
+* | `cel`                    | {@link defaultRuleProcessorCEL}           |
+* | `spel`                   | {@link defaultRuleProcessorSpEL}          |
+* | `jsonlogic`              | {@link defaultRuleProcessorJsonLogic}     |
+* | `elasticsearch`          | {@link defaultRuleProcessorElasticSearch} |
+* | `jsonata`                | {@link defaultRuleProcessorJSONata}       |
+*
+* @group Export
+*/
+type RuleProcessor = (rule: RuleType, options?: ValueProcessorOptions, meta?: {
+  processedParams?: Record<string, any> | any[];
+  context?: Record<string, any>;
+}) => any;
+/**
+* Function to produce a result that {@link formatQuery} uses when processing a
+* {@link RuleGroupType} or {@link RuleGroupTypeIC} object.
+*
+* See the default rule group processor for each format to know what type to return.
+* | Format                   | Default rule group processor                   |
+* | ------------------------ | ---------------------------------------------- |
+* | `sql`                    | {@link defaultRuleGroupProcessorSQL}           |
+* | `parameterized`          | {@link defaultRuleGroupProcessorParameterized} |
+* | `parameterized_named`    | {@link defaultRuleGroupProcessorParameterized} |
+* | `mongodb` _(deprecated)_ | {@link defaultRuleGroupProcessorMongoDB}       |
+* | `mongodb_query`          | {@link defaultRuleGroupProcessorMongoDBQuery}  |
+* | `cel`                    | {@link defaultRuleGroupProcessorCEL}           |
+* | `spel`                   | {@link defaultRuleGroupProcessorSpEL}          |
+* | `jsonlogic`              | {@link defaultRuleGroupProcessorJsonLogic}     |
+* | `elasticsearch`          | {@link defaultRuleGroupProcessorElasticSearch} |
+* | `jsonata`                | {@link defaultRuleGroupProcessorJSONata}       |
+*
+* @group Export
+*/
+type RuleGroupProcessor<TResult = unknown> = (ruleGroup: RuleGroupTypeAny, options: FormatQueryFinalOptions, meta?: {
+  processedParams?: Record<string, any> | any[];
+  context?: Record<string, any>;
+}) => TResult;
+/**
+* Rule validator for {@link formatQuery}.
+*
+* @group Export
+*/
+type FormatQueryValidateRule = (rule: RuleType) => readonly [boolean | ValidationResult | undefined, RuleValidator | undefined];
+/**
+* Object produced by {@link formatQuery} for the `"parameterized"` format.
+*
+* @group Export
+*/
+interface ParameterizedSQL {
+  /** The SQL `WHERE` clause fragment with `?` placeholders for each value. */
+  sql: string;
+  /**
+  * Parameter values in the same order their respective placeholders
+  * appear in the `sql` string.
+  */
+  params: any[];
+}
+/**
+* Object produced by {@link formatQuery} for the `"parameterized_named"` format.
+*
+* @group Export
+*/
+interface ParameterizedNamedSQL {
+  /** The SQL `WHERE` clause fragment with bind variable placeholders for each value. */
+  sql: string;
+  /**
+  * Map of bind variable names from the `sql` string to the associated values.
+  */
+  params: Record<string, any>;
+}
+/**
+* @group Export
+*/
+interface RQBJsonLogicStartsWith {
+  startsWith: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+/**
+* @group Export
+*/
+interface RQBJsonLogicEndsWith {
+  endsWith: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+/**
+* JsonLogic rule object with additional operators generated by {@link formatQuery}
+* and accepted by {@link parseJsonLogic!parseJsonLogic}.
+*
+* @group Export
+*/
+type RQBJsonLogic = RulesLogic<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith>;
+/**
+* Constituent word order (as array) for the "natural_language" format.
+*
+* - S (subject) = field
+* - V (verb) = operator
+* - O (object) = value
+*
+* @group Export
+*/
+type ConstituentWordOrder = ["S", "V", "O"] | ["S", "O", "V"] | ["O", "S", "V"] | ["O", "V", "S"] | ["V", "S", "O"] | ["V", "O", "S"];
+/**
+* Constituent word order (as string) for the "natural_language" format.
+*
+* - S (subject) = field
+* - V (verb) = operator
+* - O (object) = value
+*
+* @group Export
+*/
+type ConstituentWordOrderString = "SVO" | "SOV" | "OSV" | "OVS" | "VSO" | "VOS";
+type RepeatStrings<S extends string[], Depth extends number[] = []> = Depth["length"] extends 2 ? "" : "" | `_${S[number]}${RepeatStrings<S, [...Depth, 1]>}`;
+type ZeroOrMoreGroupVariants = RepeatStrings<["xor", "not"]>;
+/**
+* Rule group condition identifier for the "natural_language" format.
+*
+* @group Export
+*/
+type GroupVariantCondition = "not" | "xor";
+/**
+* Keys for the `translations` config object used by the "natural_language" format.
+*
+* @group Export
+*/
+type NLTranslationKey = "and" | "or" | "true" | "false" | `groupPrefix${ZeroOrMoreGroupVariants}` | `groupSuffix${ZeroOrMoreGroupVariants}`;
+/**
+* `translations` config object for "natural_language" format.
+*
+* @group Export
+*/
+type NLTranslations = Partial<Record<NLTranslationKey, string>>;
+//#endregion
+export { ConstituentWordOrder, ExportFormat, ExportObjectFormats, ExportOperatorMap, FormatQueryOptions, GroupVariantCondition, NLTranslationKey, NLTranslations, ParameterizedNamedSQL, ParameterizedSQL, RQBJsonLogic, RuleGroupProcessor, RuleProcessor, SQLPreset, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions };
+//# sourceMappingURL=export-r-V7bU31.d.mts.map