@adaptabletools/adaptable 23.1.0-canary.2 → 24.0.0-canary.0

package/src/migration/legacyPredicateLowering.js

@@ -0,0 +1,151 @@
+import { colRef, literalForRawValue, literalOrPathArg, qlPrimitive, } from "../../vendor/aql/index.js";
+import { mapColumnDataTypeToExpressionFunctionType } from '../aql/adaptableQlUtils';
+import { mapQlPredicateToExpression, } from "../../vendor/aql/index.js";
+const notWrapped = (inner) => qlPrimitive('NOT', [inner]);
+const numberLiteral = (value) => ({ kind: 'literal', type: 'number', value });
+const inclusiveRangeQlPredicate = (subject, lower, upper) => ({
+    kind: 'group',
+    combinator: 'AND',
+    children: [
+        qlPrimitive('GTE', [subject, lower]),
+        qlPrimitive('LTE', [subject, upper]),
+    ],
+});
+const outsideInclusiveRangeQlPredicate = (subject, lower, upper) => ({
+    kind: 'group',
+    combinator: 'OR',
+    children: [
+        qlPrimitive('LT', [subject, lower]),
+        qlPrimitive('GT', [subject, upper]),
+    ],
+});
+const rangeBounds = (literals) => {
+    const [lower, upper] = literals.slice(0, 2);
+    if (lower === undefined || upper === undefined) {
+        return null;
+    }
+    return [lower, upper];
+};
+export const predicateIdToQlPredicate = (predicateId, inputs, column) => {
+    const col = colRef(column.columnId);
+    const dataType = mapColumnDataTypeToExpressionFunctionType(column.dataType);
+    const values = (inputs ?? []).filter((input) => input !== undefined);
+    const literals = values.map((value) => literalForRawValue(value, dataType));
+    const inList = () => ({
+        kind: 'list',
+        items: values.map((value) => literalOrPathArg(value, dataType)),
+    });
+    switch (predicateId) {
+        case 'Equals':
+        case 'Is':
+            return qlPrimitive('EQ', [col, ...literals.slice(0, 1)]);
+        case 'NotEquals':
+        case 'IsNot':
+            return qlPrimitive('NEQ', [col, ...literals.slice(0, 1)]);
+        case 'GreaterThan':
+        case 'After':
+            return qlPrimitive('GT', [col, ...literals.slice(0, 1)]);
+        case 'GreaterThanOrEqual':
+        case 'OnOrAfter':
+            return qlPrimitive('GTE', [col, ...literals.slice(0, 1)]);
+        case 'LessThan':
+        case 'Before':
+            return qlPrimitive('LT', [col, ...literals.slice(0, 1)]);
+        case 'LessThanOrEqual':
+        case 'OnOrBefore':
+            return qlPrimitive('LTE', [col, ...literals.slice(0, 1)]);
+        case 'Between':
+        case 'Range':
+        case 'InRange': {
+            const bounds = rangeBounds(literals);
+            return bounds ? inclusiveRangeQlPredicate(col, bounds[0], bounds[1]) : null;
+        }
+        case 'NotBetween': {
+            const bounds = rangeBounds(literals);
+            return bounds ? outsideInclusiveRangeQlPredicate(col, bounds[0], bounds[1]) : null;
+        }
+        case 'In':
+            return qlPrimitive('IN', [col, inList()]);
+        case 'NotIn':
+            return notWrapped(qlPrimitive('IN', [col, inList()]));
+        case 'Positive':
+            return qlPrimitive('GT', [col, numberLiteral(0)]);
+        case 'Negative':
+            return qlPrimitive('LT', [col, numberLiteral(0)]);
+        case 'Zero':
+            return qlPrimitive('EQ', [col, numberLiteral(0)]);
+        case 'Contains':
+            return qlPrimitive('CONTAINS', [col, ...literals.slice(0, 1)]);
+        case 'NotContains':
+            return notWrapped(qlPrimitive('CONTAINS', [col, ...literals.slice(0, 1)]));
+        case 'StartsWith':
+            return qlPrimitive('STARTS_WITH', [col, ...literals.slice(0, 1)]);
+        case 'EndsWith':
+            return qlPrimitive('ENDS_WITH', [col, ...literals.slice(0, 1)]);
+        case 'Regex':
+            return qlPrimitive('REGEX', [col, ...literals.slice(0, 1)]);
+        case 'Today':
+            return qlPrimitive('IS_TODAY', [col]);
+        case 'Yesterday':
+            return qlPrimitive('IS_YESTERDAY', [col]);
+        case 'Tomorrow':
+            return qlPrimitive('IS_TOMORROW', [col]);
+        case 'ThisWeek':
+            return qlPrimitive('IS_THIS_WEEK', [col]);
+        case 'ThisMonth':
+            return qlPrimitive('IS_THIS_MONTH', [col]);
+        case 'ThisQuarter':
+            return qlPrimitive('IS_THIS_QUARTER', [col]);
+        case 'ThisYear':
+            return qlPrimitive('IS_THIS_YEAR', [col]);
+        case 'InPast':
+            return qlPrimitive('IS_PAST', [col]);
+        case 'InFuture':
+            return qlPrimitive('IS_FUTURE', [col]);
+        case 'NextWorkDay':
+            return qlPrimitive('IS_NEXT_WORKDAY', [col]);
+        case 'LastWorkDay':
+            return qlPrimitive('IS_PREV_WORKDAY', [col]);
+        case 'Holiday':
+            return qlPrimitive('IS_HOLIDAY', [col]);
+        case 'WorkDay':
+            return qlPrimitive('IS_WORKDAY', [col]);
+        case 'On':
+            return qlPrimitive('IS_SAME_DAY', [col, ...literals.slice(0, 1)]);
+        case 'NotOn':
+            return notWrapped(qlPrimitive('IS_SAME_DAY', [col, ...literals.slice(0, 1)]));
+        case 'Blanks':
+            return qlPrimitive('IS_BLANK', [col]);
+        case 'NonBlanks':
+            return qlPrimitive('IS_NOT_BLANK', [col]);
+        case 'True':
+            return qlPrimitive('EQ', [col, { kind: 'literal', type: 'boolean', value: true }]);
+        case 'False':
+            return qlPrimitive('EQ', [col, { kind: 'literal', type: 'boolean', value: false }]);
+        case 'BooleanToggle': {
+            const input = values[0];
+            if (input === 'checked') {
+                return qlPrimitive('EQ', [col, { kind: 'literal', type: 'boolean', value: true }]);
+            }
+            if (input === 'unchecked') {
+                return qlPrimitive('EQ', [col, { kind: 'literal', type: 'boolean', value: false }]);
+            }
+            return qlPrimitive('EQ', [col]);
+        }
+        case 'AnyChange':
+            return qlPrimitive('ANY_CHANGE', [col]);
+        default:
+            return null;
+    }
+};
+export const predicateIdToQlPrimitive = (predicateId, inputs, column) => {
+    const predicate = predicateIdToQlPredicate(predicateId, inputs, column);
+    return predicate?.kind === 'predicate' ? predicate : null;
+};
+export const predicateToExpression = (column, predicate) => {
+    const qlPredicate = predicateIdToQlPredicate(predicate.PredicateId, predicate.Inputs, column);
+    if (!qlPredicate) {
+        return null;
+    }
+    return mapQlPredicateToExpression(qlPredicate);
+};

package/src/migration/migrateGreenfieldExpressionTexts.d.ts

@@ -0,0 +1,12 @@
+import type { AdaptableState } from '../AdaptableState/AdaptableState';
+import type { MigrationLogger } from './AdaptableUpgradeHelper';
+export interface GreenfieldExpressionMigrationCounts {
+    migrated: number;
+    unparseable: number;
+}
+/**
+ * Walk every persisted AQL string and rewrite leftover legacy spellings to
+ * greenfield via {@link migrateExpression}. Idempotent. Unparseable text is
+ * left unchanged and counted (never dropped).
+ */
+export declare function migrateGreenfieldExpressionTexts(state: AdaptableState, logger?: MigrationLogger): GreenfieldExpressionMigrationCounts;

package/src/migration/migrateGreenfieldExpressionTexts.js

@@ -0,0 +1,195 @@
+import { migrateExpression, parse } from "../../vendor/aql/index.js";
+import { toMigrateOptions } from '../aql/legacyExpressionKinds';
+import { inferExpressionKindFromText } from '../AdaptableState/Common/AdaptableQuery';
+import { getNamedQueryReturnType } from '../AdaptableState/NamedQueryState';
+import { isAdaptableSharedEntity, } from '../AdaptableState/TeamSharingState';
+import { rewriteLegacyBetweenInExpression } from './legacyBetweenExpressionMigration';
+const namedQueryKind = (returnType) => returnType === 'boolean' ? 'boolean' : 'scalar';
+function sameExpressionAst(left, right) {
+    try {
+        const leftAst = JSON.stringify(stripRanges(parse(left).ast));
+        const rightAst = JSON.stringify(stripRanges(parse(right).ast));
+        return leftAst === rightAst;
+    }
+    catch {
+        return false;
+    }
+}
+function stripRanges(value) {
+    if (Array.isArray(value)) {
+        return value.map(stripRanges);
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key === 'range') {
+                continue;
+            }
+            out[key] = stripRanges(child);
+        }
+        return out;
+    }
+    return value;
+}
+export function migrateGreenfieldExpressionTexts(state, logger) {
+    const counts = { migrated: 0, unparseable: 0 };
+    const rewrite = (holder, key, kind) => {
+        if (!holder) {
+            return;
+        }
+        const text = holder[key];
+        if (typeof text !== 'string' || !text.trim()) {
+            return;
+        }
+        const betweenRewrite = rewriteLegacyBetweenInExpression(text);
+        const source = betweenRewrite.changed ? betweenRewrite.expression : text;
+        const result = migrateExpression(source, toMigrateOptions(kind));
+        if (result.error) {
+            counts.unparseable += 1;
+            logger?.warn(`Left unparseable expression unchanged (${key}): ${text} — ${result.error}`);
+            return;
+        }
+        if (betweenRewrite.changed || result.changed) {
+            if (!betweenRewrite.changed &&
+                sameExpressionAst(text, result.expression)) {
+                return;
+            }
+            holder[key] = result.expression;
+            counts.migrated += 1;
+        }
+    };
+    const rewriteQuery = (query, kinds) => {
+        if (!query || typeof query !== 'object') {
+            return;
+        }
+        const expressionKind = kinds.expression ?? 'boolean';
+        const aggregatedKind = kinds.aggregated ?? 'aggregatedScalar';
+        rewrite(query, 'Expression', expressionKind);
+        rewrite(query, 'BooleanExpression', 'boolean');
+        rewrite(query, 'ScalarExpression', 'scalar');
+        rewrite(query, 'AggregatedExpression', aggregatedKind);
+        rewrite(query, 'AggregatedBooleanExpression', 'aggregatedBoolean');
+        rewrite(query, 'AggregatedScalarExpression', 'aggregatedScalar');
+        rewrite(query, 'ObservableExpression', 'boolean');
+    };
+    const rewriteQueryProperty = (holder, key, kinds) => {
+        const value = holder?.[key];
+        if (typeof value === 'string') {
+            const inferred = inferExpressionKindFromText(value);
+            const kind = inferred === 'aggregated'
+                ? (kinds.aggregated ?? 'aggregatedScalar')
+                : (kinds.expression ?? 'boolean');
+            rewrite(holder, key, kind);
+            return;
+        }
+        rewriteQuery(value, kinds);
+    };
+    const RULE_KINDS = { expression: 'boolean', aggregated: 'aggregatedBoolean' };
+    for (const namedQuery of state.NamedQuery?.NamedQueries ?? []) {
+        rewriteQuery(namedQuery, {
+            expression: namedQueryKind(getNamedQueryReturnType(namedQuery)),
+        });
+    }
+    for (const column of state.CalculatedColumn?.CalculatedColumns ?? []) {
+        rewriteQueryProperty(column, 'Query', {
+            expression: 'scalar',
+            aggregated: 'aggregatedScalar',
+        });
+    }
+    for (const definition of state.Alert?.AlertDefinitions ?? []) {
+        rewriteQueryProperty(definition, 'Rule', RULE_KINDS);
+    }
+    for (const definition of state.FlashingCell?.FlashingCellDefinitions ?? []) {
+        rewriteQueryProperty(definition, 'Rule', RULE_KINDS);
+    }
+    for (const column of state.FormatColumn?.FormatColumns ?? []) {
+        rewriteQueryProperty(column, 'Rule', RULE_KINDS);
+    }
+    for (const nudge of state.PlusMinus?.PlusMinusNudges ?? []) {
+        rewriteQueryProperty(nudge, 'Rule', RULE_KINDS);
+    }
+    for (const report of state.Export?.Reports ?? []) {
+        rewriteQueryProperty(report, 'Query', {
+            expression: 'boolean',
+        });
+    }
+    for (const styledColumn of state.StyledColumn?.StyledColumns ?? []) {
+        for (const badge of styledColumn.BadgeStyle?.Badges ?? []) {
+            const legacyBadge = badge;
+            rewriteQueryProperty(legacyBadge, 'Rule', { expression: 'boolean' });
+            if (legacyBadge.Expression && typeof legacyBadge.Expression === 'object') {
+                rewriteQuery(legacyBadge.Expression, { expression: 'boolean' });
+            }
+        }
+    }
+    for (const layout of state.Layout?.Layouts ?? []) {
+        const gridFilter = layout.GridFilter;
+        rewrite(gridFilter, 'Expression', 'aggregatedBoolean');
+        for (const filter of layout.ColumnFilters ?? []) {
+            rewrite(filter, 'Expression', 'boolean');
+        }
+    }
+    for (const shared of state.TeamSharing?.SharedEntities ?? []) {
+        migrateSharedEntity(shared, rewriteQuery, rewriteQueryProperty, rewrite);
+    }
+    if (counts.migrated > 0) {
+        logger?.info(`Migrated ${counts.migrated} expression(s) to greenfield syntax.`);
+    }
+    if (counts.unparseable > 0) {
+        logger?.warn(`Left ${counts.unparseable} unparseable expression(s) unchanged.`);
+    }
+    return counts;
+}
+const migrateSharedEntity = (shared, rewriteQuery, rewriteQueryProperty, rewrite) => {
+    if (!isAdaptableSharedEntity(shared)) {
+        return;
+    }
+    const entity = shared.Entity;
+    if (!entity || typeof entity !== 'object') {
+        return;
+    }
+    const kinds = kindsForSharedModule(shared.Module, entity);
+    if (entity.Query != null) {
+        rewriteQueryProperty(entity, 'Query', kinds);
+    }
+    if (entity.Rule != null) {
+        rewriteQueryProperty(entity, 'Rule', {
+            expression: 'boolean',
+            aggregated: 'aggregatedBoolean',
+        });
+    }
+    if (typeof entity.Expression === 'string' ||
+        entity.AggregatedExpression ||
+        entity.ObservableExpression) {
+        rewriteQuery(entity, kinds);
+    }
+    if (entity.GridFilter && typeof entity.GridFilter === 'object') {
+        rewrite(entity.GridFilter, 'Expression', 'aggregatedBoolean');
+    }
+    if (Array.isArray(entity.ColumnFilters)) {
+        for (const filter of entity.ColumnFilters) {
+            rewrite(filter, 'Expression', 'boolean');
+        }
+    }
+    const badgeStyle = entity.BadgeStyle;
+    for (const badge of badgeStyle?.Badges ?? []) {
+        rewriteQueryProperty(badge, 'Rule', { expression: 'boolean' });
+        if (badge.Expression && typeof badge.Expression === 'object') {
+            rewriteQuery(badge.Expression, { expression: 'boolean' });
+        }
+    }
+};
+const kindsForSharedModule = (module, entity) => {
+    switch (module) {
+        case 'CalculatedColumn':
+            return { expression: 'scalar', aggregated: 'aggregatedScalar' };
+        case 'NamedQuery':
+            return {
+                expression: namedQueryKind(typeof entity.ReturnType === 'string' ? entity.ReturnType : 'boolean'),
+            };
+        case 'Export':
+            return { expression: 'boolean' };
+        default:
+            return { expression: 'boolean', aggregated: 'aggregatedBoolean' };
+    }
+};

package/src/migration/migrateLayoutTagsToRegistry.d.ts

@@ -0,0 +1,15 @@
+import { AdaptableState } from '../AdaptableState/AdaptableState';
+import { LayoutTagOptions } from '../AdaptableOptions/LayoutOptions';
+import type { MigrationLogger } from './AdaptableUpgradeHelper';
+/**
+ * Converts Layout extensions expressed through object Tags (v23 `layoutTagOptions.autoCheckTagsForLayouts`)
+ * into the `Layout.LayoutExtensions` registry.
+ *
+ * - only runs when `autoCheckTagsForLayouts` was enabled - otherwise Tags carried no Layout meaning
+ * - Tags matching a Layout name are moved into the registry and removed from the object; other Tags are kept
+ * - merges into any existing registry and strips the converted Tags, so re-running on every load is a no-op
+ * - an object with Layout Tags whose Name is shared with another object in the same Module is renamed
+ *   `Name (2)`, `Name (3)`... since the registry references objects by Name
+ * - Team Sharing entities are not changed here; Layout Tags on shared entities are converted on import
+ */
+export declare function migrateLayoutTagsToRegistry(state: AdaptableState, logger: MigrationLogger, layoutTagOptions?: LayoutTagOptions): void;

package/src/migration/migrateLayoutTagsToRegistry.js

@@ -0,0 +1,111 @@
+import { LAYOUT_EXTENSION_MODULES, addObjectToLayout, getAllLayoutExtensionObjects, } from '../Utilities/Helpers/Layouts/LayoutExtensionHelper';
+const getTags = (object) => Array.isArray(object.Tags) ? object.Tags.filter((tag) => typeof tag === 'string') : [];
+const getName = (object) => typeof object.Name === 'string' && object.Name ? object.Name : undefined;
+const makeUniqueName = (name, usedNames) => {
+    let index = 2;
+    while (usedNames.has(`${name} (${index})`)) {
+        index++;
+    }
+    return `${name} (${index})`;
+};
+export function migrateLayoutTagsToRegistry(state, logger, layoutTagOptions) {
+    const layoutNames = new Set((state.Layout?.Layouts ?? [])
+        .map((layout) => layout?.Name)
+        .filter((name) => typeof name === 'string' && !!name));
+    if (!layoutNames.size) {
+        return;
+    }
+    if (typeof layoutTagOptions?.isObjectExtendedInLayout === 'function') {
+        logger.warn('`layoutTagOptions.isObjectExtendedInLayout` is no longer supported (v24) and is ignored. ' +
+            'Define which objects belong to which Layouts in `Layout.LayoutExtensions` instead.');
+    }
+    const autoCheck = layoutTagOptions?.autoCheckTagsForLayouts === true;
+    let registry = state.Layout.LayoutExtensions;
+    const converted = [];
+    const renamed = [];
+    const skippedNoName = [];
+    const unconverted = [];
+    const nowGlobal = [];
+    for (const module of LAYOUT_EXTENSION_MODULES) {
+        const objects = getAllLayoutExtensionObjects(state, module);
+        if (!objects.length) {
+            continue;
+        }
+        const hasLayoutTags = (object) => getTags(object).some((tag) => layoutNames.has(tag));
+        const occurrences = new Map();
+        for (const object of objects) {
+            const name = getName(object);
+            if (name) {
+                occurrences.set(name, [...(occurrences.get(name) ?? []), object]);
+            }
+        }
+        const usedNames = new Set(occurrences.keys());
+        for (const object of objects) {
+            const tags = getTags(object);
+            if (!tags.length) {
+                continue;
+            }
+            const layoutTags = tags.filter((tag) => layoutNames.has(tag));
+            const label = `${module} '${getName(object) ?? '(unnamed)'}'`;
+            if (!layoutTags.length) {
+                if (autoCheck) {
+                    nowGlobal.push(label);
+                }
+                continue;
+            }
+            if (!autoCheck) {
+                unconverted.push(label);
+                continue;
+            }
+            let name = getName(object);
+            if (!name) {
+                skippedNoName.push(label);
+                continue;
+            }
+            const sameName = occurrences.get(name) ?? [];
+            const keepsName = sameName[0] === object && sameName.every(hasLayoutTags);
+            if (sameName.length > 1 && !keepsName) {
+                const uniqueName = makeUniqueName(name, usedNames);
+                usedNames.add(uniqueName);
+                renamed.push(`${module} '${name}' -> '${uniqueName}'`);
+                object.Name = uniqueName;
+                name = uniqueName;
+            }
+            for (const layoutName of layoutTags) {
+                registry = addObjectToLayout(registry, layoutName, module, name);
+            }
+            const remainingTags = tags.filter((tag) => !layoutNames.has(tag));
+            if (remainingTags.length) {
+                object.Tags = remainingTags;
+            }
+            else {
+                delete object.Tags;
+            }
+            converted.push(label);
+        }
+    }
+    if (registry !== state.Layout.LayoutExtensions) {
+        const layoutOrder = [...layoutNames];
+        const position = (layoutName) => {
+            const index = layoutOrder.indexOf(layoutName);
+            return index === -1 ? layoutOrder.length : index;
+        };
+        state.Layout.LayoutExtensions = [...registry].sort((a, b) => position(a.LayoutName) - position(b.LayoutName));
+    }
+    if (converted.length) {
+        logger.info(`Moved Layout extensions of ${converted.length} object(s) from Tags to Layout.LayoutExtensions (v24): ${converted.join(', ')}`);
+    }
+    if (renamed.length) {
+        logger.warn(`Renamed ${renamed.length} object(s) sharing a Name within their Module, so each can be extended into Layouts separately (v24): ${renamed.join(', ')}`);
+    }
+    if (skippedNoName.length) {
+        logger.warn(`Could not move Layout Tags for ${skippedNoName.length} object(s) without a Name; they now apply in all Layouts (v24): ${skippedNoName.join(', ')}`);
+    }
+    if (nowGlobal.length) {
+        logger.info(`${nowGlobal.length} object(s) had Tags but none matched a Layout, so were previously hidden in every Layout; they now apply in all Layouts (v24): ${nowGlobal.join(', ')}`);
+    }
+    if (unconverted.length) {
+        logger.info(`${unconverted.length} object(s) have Tags matching Layout names, but these were not converted into Layout Extensions ` +
+            `because \`layoutTagOptions.autoCheckTagsForLayouts\` is not enabled (v24): ${unconverted.join(', ')}`);
+    }
+}

package/src/migration/predicateExpressionMigration.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure predicate → AQL `Expression` lowering used by the eager state
+ * migration (`VersionUpgrade24`).
+ *
+ * Wraps the frozen `predicateIdToQlPrimitive` /
+ * `mapQlPredicateToExpression` lowering in `legacyPredicateLowering.ts`
+ * with the two pieces the migration needs but the UI bridges get for free:
+ *
+ *  1. A synthetic column data type. At migration time we have no column
+ *     metadata, so we derive it from the predicate id (date/number/boolean
+ *     predicates are unambiguous) and fall back to the JS type of the
+ *     stored inputs. Only `date` actually changes literal typing
+ *     (`DATE(...)`); the rest is cosmetic because `literalForRawValue`
+ *     already types literals by their runtime JS type.
+ *  2. A `$SCOPE` subject for rule predicates that carry no `ColumnId`
+ *     (they evaluate against the scoped column at runtime, exactly what
+ *     `$SCOPE` resolves to).
+ *
+ * Every helper is **all-or-nothing**: if any predicate in the set cannot
+ * be lowered to a complete AQL primitive (custom predicate defs,
+ * `PercentChange` — AQL `PERCENT_CHANGE` is number-returning — or an
+ * incomplete/empty predicate) the helper returns `null` and the caller
+ * must leave the legacy predicate representation intact. This preserves
+ * the runtime fallback and keeps the migration idempotent.
+ *
+ * `AnyChange` lowers to `ANY_CHANGE([col])` / `ANY_CHANGE($SCOPE)`.
+ */
+import { ColumnFilter } from '../AdaptableState/Common/ColumnFilter';
+import { LegacyPredicate } from './legacyPredicateLowering';
+import { QlPredicate, QlPrimitive } from "../../vendor/aql/index.js";
+/** Minimal column-predicate shape (ColumnId optional for scoped rules). */
+type LegacyColumnPredicate = LegacyPredicate & {
+    ColumnId?: string;
+};
+/**
+ * Lowers a single legacy predicate to a complete AQL `QlPredicate`.
+ *
+ * @param subjectColumnId the column the predicate applies to, or `null`
+ *   to emit a `$SCOPE` subject (rule predicate without a `ColumnId`).
+ * @returns the predicate, or `null` when the predicate has no lossless
+ *   AQL equivalent or is incomplete.
+ */
+export declare const lowerPredicateToQlPredicate: (predicate: LegacyPredicate, subjectColumnId: string | null) => QlPredicate | null;
+/** @deprecated Use {@link lowerPredicateToQlPredicate} — range predicates lower to groups. */
+export declare const lowerPredicateToPrimitive: (predicate: LegacyPredicate, subjectColumnId: string | null) => QlPrimitive | null;
+/**
+ * Lowers all `Predicates` of a `ColumnFilter` (joined by its
+ * `PredicatesOperator`, default `AND`) to a single AQL expression. Every
+ * predicate shares the filter's `ColumnId` as subject.
+ *
+ * Returns `null` when the filter has no predicates or any predicate is
+ * unconvertible — the caller keeps the legacy `Predicates`.
+ */
+export declare const columnFilterPredicatesToExpression: (columnFilter: ColumnFilter) => string | null;
+/**
+ * Converts a single incomplete ColumnFilter Predicate (empty Inputs —
+ * operator seed only) to a `PreferredFilter` AQL operator name.
+ *
+ * Returns `null` when the filter is not a single known incomplete
+ * predicate (caller may still preserve custom / unconvertible Predicates).
+ */
+export declare const columnFilterPredicatesToPreferredFilter: (columnFilter: ColumnFilter) => string | null;
+/**
+ * Lowers the `Predicates` of a rule (Alert / Flashing Cell / Format
+ * Column) to a single `BooleanExpression`. Predicates combine with `AND`
+ * (matching the runtime `handleColumnPredicates` `.every`); each
+ * predicate uses its own `ColumnId`, or `$SCOPE` when absent.
+ *
+ * Returns `null` when there are no predicates or any is unconvertible.
+ */
+export declare const rulePredicatesToBooleanExpression: (predicates: LegacyColumnPredicate[] | undefined) => string | null;
+/**
+ * Lowers a single Badge Style `Predicate` (subject = the styled column)
+ * to a `BooleanExpression`. Returns `null` when unconvertible.
+ */
+export declare const badgePredicateToBooleanExpression: (predicate: LegacyPredicate, columnId: string) => string | null;
+export {};