import { E as RuleGroupTypeAny, I as SetRequired, N as RuleType, S as ValueProcessorOptions, _ as RuleGroupProcessor, a as DiagnosticsResult, b as ValueProcessorByRule, c as ExportOperatorMap, d as NLTranslationKey, f as NLTranslations, h as RQBJsonLogic, i as ConstituentWordOrder, l as FormatQueryOptions, m as ParameterizedSQL, o as ExportFormat, p as ParameterizedNamedSQL, s as ExportObjectFormats, u as GroupVariantCondition, v as RuleProcessor, x as ValueProcessorLegacy, y as SQLPreset } from "./index-CX9mehdL.js";
//#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "cel" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorCEL: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorMongoDB.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "mongodb" format.
 *
 * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorMongoDB: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorSpEL.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "spel" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorSpEL: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultValueProcessorByRule.d.ts
/**
 * Default value processor used by {@link formatQuery} for "sql" format.
 *
 * @group Export
 */
declare const defaultValueProcessorByRule: ValueProcessorByRule;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "cel" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorCEL: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.d.ts
/**
 * Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
 *
 * @group Export
 */
declare const cypherCombinatorMap: {
  and: "AND";
  or: "OR";
};
/**
 * Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorCypher: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorDrizzle.d.ts
/**
 * Minimal structural shape of Drizzle's `Operators` object. Declared locally so the public type
 * surface of this package never references `drizzle-orm`, which is an optional peer dependency.
 * (Referencing it would force consumers to install it to typecheck without `skipLibCheck`.)
 *
 * @group Export
 */
interface DrizzleOperatorsLike {
  and: (...conditions: any[]) => any;
  or: (...conditions: any[]) => any;
  not: (...conditions: any[]) => any;
}
/**
 * Return type of {@link defaultRuleGroupProcessorDrizzle}—the function assignable to the `where`
 * property in the Drizzle relational queries API. The Drizzle `SQL` result type is inferred from
 * the caller's own operators object, so it stays exact without importing `drizzle-orm` here.
 *
 * @group Export
 */
type DrizzleWhereCallback = <Ops extends DrizzleOperatorsLike>(columns: object, drizzleOperators: Ops) => ReturnType<Ops["and"]>;
/**
 * Default rule group processor used by {@link formatQuery} for the "drizzle" format. The returned
 * function can be assigned to the `where` property in the Drizzle relational queries API.
 *
 * @example
 * const where = formatQuery(query, 'drizzle');
 * const results = db.query.users.findMany({ where });
 *
 * @returns Function that takes a Drizzle table config and an object of Drizzle operators.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorDrizzle: RuleGroupProcessor<DrizzleWhereCallback>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorElasticSearch.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "elasticsearch" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorElasticSearch: RuleGroupProcessor<Record<string, unknown>>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "gremlin" format.
 *
 * At the top level, filter rules produce chained `.has()` steps (implicit AND).
 * Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
 * `__` anonymous traversal prefixes.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorGremlin: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "jsonata" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorJSONata: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorJsonLogic.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "jsonlogic" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorJsonLogic: RuleGroupProcessor<RQBJsonLogic>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorLDAP.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "ldap" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorLDAP: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDB.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "mongodb" format.
 *
 * Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorMongoDB: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDBQuery.d.ts
/**
 * Default fallback object used by {@link formatQuery} for "mongodb_query" format.
 *
 * @group Export
 */
declare const mongoDbFallback: {
  readonly $and: readonly [{
    readonly $expr: true;
  }];
};
/**
 * Rule group processor used by {@link formatQuery} for "mongodb_query" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorMongoDBQuery: RuleGroupProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorNL.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorNL: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorParameterized.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "parameterized" and
 * "parameterized_named" formats.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorParameterized: RuleGroupProcessor<ParameterizedSQL | ParameterizedNamedSQL>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorPrisma.d.ts
/**
 * Default fallback object used by {@link formatQuery} for "prisma" format.
 *
 * @group Export
 */
declare const prismaFallback: {};
/**
 * Rule group processor used by {@link formatQuery} for "prisma" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorPrisma: RuleGroupProcessor<Record<string, unknown> | undefined>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorSequelize.d.ts
/**
 * Structural stand-in for Sequelize's `WhereOptions`. Declared locally so the public type surface
 * of this package never references `sequelize`, which is an optional peer dependency.
 * (Referencing it would force consumers to install it to typecheck without `skipLibCheck`.)
 * Assignable to `WhereOptions` at the call site, e.g. `Model.findAll({ where })`.
 *
 * @group Export
 */
interface SequelizeWhereOptionsLike {
  [key: string | symbol]: unknown;
}
/**
 * Rule group processor used by {@link formatQuery} for "sequelize" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorSequelize: RuleGroupProcessor<SequelizeWhereOptionsLike | undefined>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "sparql" format.
 *
 * SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorSPARQL: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorSpEL.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "spel" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "sql" format.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
//#endregion
//#region src/utils/formatQuery/tanStackDbTypes.d.ts
/**
 * Return type of the TanStack DB where-callback. Intentionally `unknown`: TanStack DB's own
 * `WhereCallback` returns `any`, so a precise type constrains nothing at the call site, and
 * naming `@tanstack/db` here would drag an optional peer dependency into the published types.
 */
type TanStackDbWhereCallbackReturnType = unknown;
type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
/**
 * Default rule group processor used by {@link formatQuery} for the "tanstack_db" format.
 * Returns a `WhereCallback` suitable for TanStack DB's `.where()` method.
 *
 * @example
 * const where = formatQuery(query, { format: 'tanstack_db', context: { tanstackDb: tsdb } });
 * const results = useLiveQuery(q => q.from({ todo: todosCollection }).where(where));
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
//#endregion
//#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
/**
 * Rule group processor used by {@link formatQuery} for "diagnostics" format.
 *
 * Produces a {@link DiagnosticsResult} containing an annotated copy of the query
 * tree (`query`) with `valid`, `reasons`, `path`, and `level` properties on every
 * rule and group; a flat `diagnostics` array; aggregate `stats`; and a per-field
 * `fieldSummary`.
 *
 * @group Export
 */
declare const defaultRuleGroupProcessorDiagnostics: RuleGroupProcessor<DiagnosticsResult>;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorCypher.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "cypher" and "gql" formats.
 *
 * @group Export
 */
declare const defaultRuleProcessorCypher: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorDrizzle.d.ts
/**
 * Default rule processor used by {@link formatQuery} for the "drizzle" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorDrizzle: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "elasticsearch" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorElasticSearch: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorGremlin.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "gremlin" format.
 *
 * Each rule becomes a `.has()` step (or `.hasNot()`/`.has()` for null checks).
 *
 * @group Export
 */
declare const defaultRuleProcessorGremlin: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorJSONata.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "jsonata" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorJSONata: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorJsonLogic.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "jsonlogic" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorJsonLogic: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorLDAP.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "ldap" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorLDAP: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorMongoDBQuery.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "mongodb_query" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorMongoDBQuery: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorNL.d.ts
/**
 * Default operator map used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
 */
declare const defaultExportOperatorMap: ExportOperatorMap;
/**
 * Default operator processor used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
 */
declare const defaultOperatorProcessorNL: RuleProcessor;
/**
 * Default rule processor used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorNL: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorParameterized.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "parameterized" and
 * "parameterized_named" formats.
 *
 * @group Export
 */
declare const defaultRuleProcessorParameterized: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorPrisma.d.ts
/**
 * Default rule processor used by {@link formatQuery} for "prisma" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorPrisma: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorSequelize.d.ts
/**
 * Default rule processor used by {@link formatQuery} for the "sequelize" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorSequelize: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorSPARQL.d.ts
/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
 *
 * @group Export
 */
declare const sparqlVar: (name: string) => string;
/**
 * Default rule processor used by {@link formatQuery} for "sparql" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorSPARQL: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorSQL.d.ts
/**
 * Default operator processor used by {@link formatQuery} for "sql" and "parameterized*" formats.
 *
 * @group Export
 */
declare const defaultOperatorProcessorSQL: RuleProcessor;
/**
 * Default rule processor used by {@link formatQuery} for "sql" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorSQL: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
/**
 * Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
 *
 * @group Export
 */
declare const defaultRuleProcessorTanStackDB: RuleProcessor;
//#endregion
//#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
/**
 * Default value processor used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
 */
declare const defaultValueProcessorNL: ValueProcessorByRule;
//#endregion
//#region src/utils/formatQuery/formatQuery.d.ts
/**
 * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
 *
 * @group Export
 */
declare const sqlDialectPresets: Record<SQLPreset, FormatQueryOptions>;
/**
 * A collection of option presets for {@link formatQuery}.
 *
 * @group Export
 */
declare const formatQueryOptionPresets: Record<string, FormatQueryOptions>;
/**
 * Generates a formatted (indented two spaces) JSON string from a query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny): string;
/**
 * Generates a result based on the provided rule group processor.
 *
 * @group Export
 */
declare function formatQuery<TResult = unknown>(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
  ruleGroupProcessor: RuleGroupProcessor<TResult>;
}): TResult;
/**
 * Generates a {@link index!ParameterizedSQL ParameterizedSQL} object from a query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized" | (FormatQueryOptions & {
  format: "parameterized";
})): ParameterizedSQL;
/**
 * Generates a {@link index!ParameterizedNamedSQL ParameterizedNamedSQL} object from a query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "parameterized_named" | (FormatQueryOptions & {
  format: "parameterized_named";
})): ParameterizedNamedSQL;
/**
 * Generates a {@link index!RQBJsonLogic JsonLogic} object from a query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonlogic" | (FormatQueryOptions & {
  format: "jsonlogic";
})): RQBJsonLogic;
/**
 * Generates an ElasticSearch query object from an RQB query object.
 *
 * NOTE: Support for the ElasticSearch format is experimental.
 * You may have better results exporting "sql" format then using
 * [ElasticSearch SQL](https://www.elastic.co/guide/en/elasticsearch/reference/current/xpack-sql.html).
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "elasticsearch" | (FormatQueryOptions & {
  format: "elasticsearch";
})): Record<string, any>;
/**
 * Generates a MongoDB query object from an RQB query object.
 *
 * This is equivalent to the "mongodb" format, but returns a JSON object
 * instead of a string.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb_query" | (FormatQueryOptions & {
  format: "mongodb_query";
})): Record<string, any>;
/**
 * Generates a JSON.stringify'd MongoDB query object from an RQB query object.
 *
 * This is equivalent to the "mongodb_query" format, but returns a string
 * instead of a JSON object.
 *
 * @deprecated Use the "mongodb_query" format for greater flexibility.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "mongodb" | (FormatQueryOptions & {
  format: "mongodb";
})): string;
/**
 * Generates a Prisma ORM query object from an RQB query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "prisma" | (FormatQueryOptions & {
  format: "prisma";
})): Record<string, any>;
/**
 * Generates a Drizzle ORM query function from an RQB query object. The function can
 * be assigned to the `where` property in the Drizzle relational queries API.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (FormatQueryOptions & {
  format: "drizzle";
})): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
/**
 * Generates a TanStack DB WhereCallback from an RQB query object. The callback can
 * be passed directly to TanStack DB's `.where()` method.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
  format: "tanstack_db";
})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
/**
 * be assigned to the `where` property in the Sequelize query functions.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "sequelize" | (FormatQueryOptions & {
  format: "sequelize";
})): ReturnType<typeof defaultRuleGroupProcessorSequelize>;
/**
 * Generates a JSONata query string from an RQB query object.
 *
 * NOTE: Either `parseNumbers: "strict-limited"` or `parseNumbers: true`
 * are recommended for this format.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "jsonata" | (FormatQueryOptions & {
  format: "jsonata";
})): string;
/**
 * Generates an LDAP query string from an RQB query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "ldap" | (FormatQueryOptions & {
  format: "ldap";
})): string;
/**
 * Generates a {@link DiagnosticsResult} from a query object, containing an annotated
 * query tree, a flat diagnostics array, aggregate stats, and a per-field summary.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "diagnostics" | (FormatQueryOptions & {
  format: "diagnostics";
})): DiagnosticsResult;
/**
 * Generates a formatted (indented two spaces) JSON string from a query object.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions): string;
/**
 * Generates a query string in the requested format.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: Exclude<ExportFormat, ExportObjectFormats>): string;
/**
 * Generates a query string in the requested format.
 *
 * @group Export
 */
declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: FormatQueryOptions & {
  format: Exclude<ExportFormat, ExportObjectFormats>;
}): string;
//#endregion
//#region src/utils/formatQuery/utils.d.ts
/**
 * Maps a {@link DefaultOperatorName} to a SQL operator.
 *
 * @group Export
 */
declare const mapSQLOperator: (rqbOperator: string) => string;
/**
 * Returns a preset-aware SQL string-concatenation function. Emits `CONCAT(a, b, ...)` when
 * `concatOperator` is `"CONCAT"` (case-insensitive), otherwise joins with the infix operator
 * (e.g. `a || b`, `a + b`).
 *
 * @group Export
 */
declare const getSQLConcat: (concatOperator?: string) => (...values: string[]) => string;
/**
 * Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
 * → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
 * yield `['', '']`.
 *
 * @group Export
 */
declare const getLikeWildcards: (operatorLC: string) => [string, string];
/**
 * Wraps an already-serialized SQL fragment (a quoted field name or an expression) with the
 * `LIKE` wildcards for the given (lowercase) string-match operator, concatenating the literal
 * `%` markers via the preset-aware {@link getSQLConcat}. Returns the fragment untouched for
 * operators without wildcards.
 *
 * @group Export
 */
declare const wrapLikeFragment: (fragment: string, operatorLC: string, { concatOperator, quoteValuesWith, wrapValueWith }?: {
  concatOperator?: string;
  quoteValuesWith?: string;
  wrapValueWith?: [string, string];
}) => string;
/**
 * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
 *
 * @group Export
 */
declare const mongoOperators: {
  "=": string;
  "!=": string;
  "<": string;
  "<=": string;
  ">": string;
  ">=": string;
  in: string;
  notin: string;
  notIn: string;
};
/**
 * Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
 *
 * @group Export
 */
declare const prismaOperators: {
  "=": string;
  "!=": string;
  "<": string;
  "<=": string;
  ">": string;
  ">=": string;
  in: string;
  notin: string;
};
/**
 * Maps a {@link DefaultCombinatorName} to a CEL combinator.
 *
 * @group Export
 */
declare const celCombinatorMap: {
  and: "&&";
  or: "||";
};
/**
 * Register these operators with `jsonLogic` before applying the result
 * of `formatQuery(query, 'jsonlogic')`.
 *
 * @example
 * ```
 * for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {
 *   jsonLogic.add_operation(op, func);
 * }
 * jsonLogic.apply({ "startsWith": [{ "var": "firstName" }, "Stev"] }, data);
 * ```
 *
 * @group Export
 */
declare const jsonLogicAdditionalOperators: Record<"startsWith" | "endsWith", (a: string, b: string) => boolean>;
/**
 * Returns a new query object with all `string`-type `value` properties converted
 * to `number` where appropriate.
 *
 * Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
 *
 * @group Export
 */
declare const numerifyValues: (rg: RuleGroupTypeAny, options: SetRequired<FormatQueryOptions, "fields">) => RuleGroupTypeAny;
/**
 * Determines whether a value is _anything_ except an empty `string` or `NaN`.
 *
 * @group Export
 */
declare const isValidValue: (value: unknown) => boolean;
/**
 * Determines whether {@link formatQuery} should render the given value as a number.
 * As long as `parseNumbers` is `true`, `number` and `bigint` values will return `true` and
 * `string` values will return `true` if they test positive against {@link numericRegex}.
 *
 * @group Export
 */
declare const shouldRenderAsNumber: (value: unknown, parseNumbers?: boolean) => boolean;
/**
 * Used by {@link formatQuery} to determine whether the given value processor is a
 * "legacy" value processor by counting the number of arguments. Legacy value
 * processors take 3 arguments (not counting any arguments with default values), while
 * rule-based value processors take no more than 2 arguments.
 *
 * @group Export
 */
declare const isValueProcessorLegacy: (valueProcessor: ValueProcessorLegacy | ValueProcessorByRule) => valueProcessor is ValueProcessorLegacy;
/**
 * Converts the `quoteFieldNamesWith` option into an array of two strings.
 * If the option is a string, the array elements are both that string.
 *
 * @default
 * ['', '']
 *
 * @group Export
 */
declare const getQuoteFieldNamesWithArray: (quoteFieldNamesWith?: null | string | [string, string]) => [string, string];
/**
 * Given a field name and relevant {@link ValueProcessorOptions}, returns the field name
 * wrapped in the configured quote character(s).
 *
 * @group Export
 */
declare const getQuotedFieldName: (fieldName: string, { quoteFieldNamesWith, fieldIdentifierSeparator }: ValueProcessorOptions) => string;
/**
 * Given a [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
 * like "svo" or "sov", returns a permutation of `["S", "V", "O"]` based on the first occurrence of
 * each letter in the input string (case insensitive). This widens the valid input from abbreviations
 * like "svo" to more expressive strings like "subject-verb-object" or "sub ver obj". Any missing
 * letters are appended in the default order "SVO" (e.g., "object" would yield `["O", "S", "V"]`).
 *
 * @group Export
 */
declare const normalizeConstituentWordOrder: (input: string) => ConstituentWordOrder;
/**
 * Prefixes a named-parameter value with the given `paramPrefix` unless the value already
 * begins with it. Used by {@link formatQuery} to render rules whose `valueSource` is
 * `"parameter"` (e.g. `"p1"` with prefix `":"` → `":p1"`; `":p1"` → `":p1"`).
 *
 * @group Export
 */
declare const withParamPrefix: (value: unknown, paramPrefix?: string) => string;
/**
 * Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
 * {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
 *
 * @group Export
 */
declare const stripParamPrefix: (value: unknown, paramPrefix?: string) => string;
/**
 * Default translations used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
 */
declare const defaultNLTranslations: NLTranslations;
/**
 * Used by {@link formatQuery} to get a translation based on certain conditions
 * for the "natural_language" format.
 *
 * @group Export
 */
declare const getNLTranslataion: (key: NLTranslationKey, translations: NLTranslations, conditions?: GroupVariantCondition[]) => string;
type ProcessedMatchMode = {
  mode: "all";
  threshold?: number | null | undefined;
} | {
  mode: "none";
  threshold?: number | null | undefined;
} | {
  mode: "some";
  threshold?: number | null | undefined;
} | {
  mode: "atleast";
  threshold: number;
} | {
  mode: "atmost";
  threshold: number;
} | {
  mode: "exactly";
  threshold: number;
};
/**
 * Transforms
 * - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
 * - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
 *
 * Returns:
 * - Processed `{ mode, threshold }` object for valid subqueries
 * - `null` if match mode is not applicable for the rule
 * - `false` if match mode is valid, but either
 *   1. `threshold` is required and invalid, or
 *   2. `value` is not a valid rule group.
 */
declare const processMatchMode: (rule: RuleType) => null | false | ProcessedMatchMode;
/**
 * Base alias assigned to the element binding of a subquery generated for a rule's
 * {@link MatchMode `match` mode} (e.g. `unnest(field) as elem_alias`).
 */
declare const subqueryElementAliasBase = "elem_alias";
/**
 * Returns the element alias for a subquery at the given nesting depth. Depth 0 (the common,
 * non-nested case) uses {@link subqueryElementAliasBase} unchanged; deeper levels are suffixed
 * with the depth, so a subquery nested within a subquery cannot shadow its parent's binding.
 *
 * Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
 *
 * @group Export
 */
declare const getSubqueryElementAlias: (subqueryDepth?: number) => string;
/**
 * "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
 * objects with a `$bigint` property having a value of a string representation of
 * the actual `bigint`-type value.
 *
 * Inverse of {@link bigIntJsonParseReviver}.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
 */
declare const bigIntJsonStringifyReplacer: (_key: string, value: unknown) => unknown;
/**
 * "Reviver" method for JSON.parse's second argument. Converts objects having a single
 * `$bigint: string` property to an actual `bigint` value.
 *
 * Inverse of {@link bigIntJsonStringifyReplacer}.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
 */
declare const bigIntJsonParseReviver: (_key: string, value: unknown) => unknown;
//#endregion
//#region src/utils/formatQuery/index.d.ts
/**
 * Default value processor used by {@link formatQuery} for "sql" format.
 *
 * @deprecated Prefer {@link defaultValueProcessorByRule}.
 *
 * @group Export
 */
declare const defaultValueProcessor: ValueProcessorLegacy;
/**
 * @deprecated Prefer {@link defaultRuleProcessorMongoDB}.
 *
 * @group Export
 */
declare const defaultMongoDBValueProcessor: ValueProcessorLegacy;
/**
 * @deprecated Prefer {@link defaultRuleProcessorCEL}.
 *
 * @group Export
 */
declare const defaultCELValueProcessor: ValueProcessorLegacy;
/**
 * @deprecated Prefer {@link defaultRuleProcessorSpEL}.
 *
 * @group Export
 */
declare const defaultSpELValueProcessor: ValueProcessorLegacy;
/**
 * @deprecated Renamed to {@link defaultRuleProcessorCEL}.
 *
 * @group Export
 */
declare const defaultValueProcessorCELByRule: RuleProcessor;
/**
 * @deprecated Renamed to {@link defaultRuleProcessorMongoDB}.
 *
 * @group Export
 */
declare const defaultValueProcessorMongoDBByRule: RuleProcessor;
/**
 * @deprecated Renamed to {@link defaultRuleProcessorSpEL}.
 *
 * @group Export
 */
declare const defaultValueProcessorSpELByRule: RuleProcessor;
//#endregion
export { DrizzleOperatorsLike, DrizzleWhereCallback, SequelizeWhereOptionsLike, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, cypherCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getLikeWildcards, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, getSQLConcat, getSubqueryElementAlias, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sparqlVar, sqlDialectPresets, stripParamPrefix, subqueryElementAliasBase, withParamPrefix, wrapLikeFragment };
//# sourceMappingURL=formatQuery.d.ts.map