@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/aql/ExpressionEvaluation.d.ts

@@ -0,0 +1,184 @@
+import type { IRowNode } from 'ag-grid-enterprise';
+import type { AdaptableModule } from '../AdaptableState/Common/Types';
+import type { CellDataChangedInfo } from '../AdaptableState/Common/CellDataChangedInfo';
+/**
+ * Result envelope of every synchronous `expressionApi.evaluate*` / `filter*` call.
+ *
+ * Evaluation failures are *expected* input errors (expression typos, unknown
+ * columns, missing row target, unavailable functions), so the API never
+ * throws — check `success` and read `value` / `errorMessage` accordingly.
+ */
+export type ExpressionEvaluationResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    errorMessage: string;
+};
+export interface EvaluateExpressionOptions {
+    /**
+     * Emulate a specific feature module's filtered function pool (e.g. "would
+     * this expression pass in the Alert module?").
+     *
+     * Default: the unfiltered super-pool (`'Expression'`) — every system and
+     * custom function is available; only
+     * `expressionOptions.isExpressionFunctionAvailable` (called with
+     * `module: 'Expression'`) can restrict it.
+     */
+    module?: AdaptableModule;
+}
+/**
+ * dataType metadata for external-data keys that are not grid columns.
+ * When a `columnId` is both a grid column and listed here, this override wins.
+ */
+export interface ExternalDataColumn {
+    columnId: string;
+    dataType?: 'number' | 'text' | 'date' | 'boolean' | 'array';
+}
+/**
+ * What-if substitute for one column of the row being evaluated.
+ * Does not mutate grid (or data-set) data; other rows are unaffected.
+ */
+export interface CellValueOverride {
+    columnId: string;
+    value: unknown;
+}
+/**
+ * Request for `evaluateStandardExpression`.
+ * A row target is required: pass exactly one of `rowNode` / `primaryKeyValue` / `data`.
+ */
+export interface EvaluateStandardExpressionRequest extends EvaluateExpressionOptions {
+    /** Standard AdaptableQL Expression to evaluate. */
+    expression: string;
+    /** The grid row to evaluate against. */
+    rowNode?: IRowNode;
+    /** Alternative row target: resolved via the grid's primary key. */
+    primaryKeyValue?: unknown;
+    /**
+     * A plain-object row, evaluated via the external-data host (no AG Grid
+     * `valueGetter`s — values are whatever the object contains). Mutually
+     * exclusive with `rowNode` / `primaryKeyValue`.
+     */
+    data?: Record<string, unknown>;
+    /**
+     * dataType metadata for keys on `data` that are not grid columns.
+     * Ignored unless `data` is provided.
+     */
+    columns?: ExternalDataColumn[];
+    /**
+     * What-if override: substitute this column's value on the row being
+     * evaluated, without mutating data.
+     */
+    cellValueOverride?: CellValueOverride;
+    /**
+     * Column id substituted for `$SCOPE` references. `$SCOPE` expressions fail
+     * with an evaluation error when this is not provided.
+     */
+    columnScope?: string;
+    /**
+     * Cell change consumed by the data-change functions (`ANY_CHANGE`,
+     * `CHANGED_COLUMN`, …). Those functions fail with an evaluation error when
+     * this is not provided.
+     */
+    dataChangedEvent?: CellDataChangedInfo;
+}
+/**
+ * Request for `evaluateAggregatedExpression`.
+ *
+ * Default target is all grid rows. Pass `dataSet` to aggregate over a
+ * caller-supplied array instead, or `rowScope` / `rowFilter` to narrow the
+ * grid row set. `dataSet` is mutually exclusive with `rowScope` / `rowFilter`.
+ */
+export interface EvaluateAggregatedExpressionRequest extends EvaluateExpressionOptions {
+    /** Aggregated AdaptableQL Expression to evaluate. */
+    expression: string;
+    /**
+     * Aggregate over these plain-object rows instead of the grid. AG Grid
+     * `valueGetter`s do not run. Mutually exclusive with `rowScope` / `rowFilter`.
+     */
+    dataSet?: Record<string, unknown>[];
+    /**
+     * dataType metadata for keys on `dataSet` rows that are not grid columns.
+     * Ignored unless `dataSet` is provided.
+     */
+    columns?: ExternalDataColumn[];
+    /**
+     * Grid-row set to aggregate over. `'all'` (default) uses every loaded row;
+     * `'visible'` uses rows the user currently sees (after grid / AdapTable
+     * filters). Group rows are excluded in both cases. Mutually exclusive with
+     * `dataSet`.
+     */
+    rowScope?: 'all' | 'visible';
+    /**
+     * Extra predicate applied to the scoped grid rows (logical AND with any
+     * `WHERE` clause in the expression). Receives AG Grid `IRowNode`s.
+     * Mutually exclusive with `dataSet`.
+     */
+    rowFilter?: (rowNode: IRowNode) => boolean;
+}
+/** Request for `filterRowNodes`. */
+export interface FilterRowNodesRequest extends EvaluateExpressionOptions {
+    /** Boolean AdaptableQL Expression to evaluate against each row. */
+    expression: string;
+    /**
+     * Grid-row set to filter. `'all'` (default) uses every loaded row;
+     * `'visible'` uses rows the user currently sees.
+     */
+    rowScope?: 'all' | 'visible';
+    /** Extra predicate applied before the expression (logical AND). */
+    rowFilter?: (rowNode: IRowNode) => boolean;
+    /**
+     * Applied to each candidate row as it is evaluated ("which rows would
+     * match if this column were this value?").
+     */
+    cellValueOverride?: CellValueOverride;
+}
+/** Request for `filterDataSet`. */
+export interface FilterDataSetRequest extends EvaluateExpressionOptions {
+    /** Boolean AdaptableQL Expression to evaluate against each row. */
+    expression: string;
+    /** Plain-object rows to filter. Matching objects are returned by reference. */
+    dataSet: Record<string, unknown>[];
+    /** dataType metadata for keys that are not grid columns. */
+    columns?: ExternalDataColumn[];
+}
+/**
+ * Materialized snapshot of an aggregated Expression, computed over the
+ * target rows at call time. It does NOT update when data changes — re-evaluate
+ * (or bind the expression to a Calculated Column / Alert) for reactive scenarios.
+ */
+export interface AggregatedExpressionEvaluationValue {
+    /** The whole-set aggregation value. */
+    value: number | undefined;
+    /**
+     * Present when the Expression is a condition (e.g. `SUM([PnL]) > '5M'`).
+     * `true` when at least one aggregation group satisfies the condition.
+     */
+    matches?: boolean;
+    /**
+     * Per-group values when the expression uses `GROUP_BY` (absent otherwise).
+     * For multi-level `GROUP_BY`, entries include the intermediate group levels
+     * (`groupKeys.length` < number of group levels). Note: `Date` group values
+     * are keyed as timestamps (numbers).
+     */
+    groupValues?: {
+        groupKeys: unknown[];
+        value: number;
+    }[];
+    /**
+     * Per-row projection of the aggregation — the row's group value for
+     * `GROUP_BY` expressions, and the only meaningful output of per-row
+     * functions (`RANK`, `LAG`, `CUMULATIVE`, `PERCENTAGE`, …). Returns
+     * `undefined` when a `WHERE` clause excluded the row's group.
+     *
+     * Accepts an `IRowNode` for grid-target evaluations, or a data-set row
+     * object when the call used `dataSet`.
+     */
+    getValueForRow: (row: IRowNode | Record<string, unknown>) => unknown;
+    /**
+     * Number of rows aggregated (after any `WHERE` filter). Lets callers detect
+     * partial data, e.g. under the server-side row model where only loaded rows
+     * are available client-side.
+     */
+    rowCount: number;
+}

package/src/aql/ExpressionEvaluation.js

@@ -0,0 +1 @@
+export {};

package/src/aql/applyExpressionFunctionAvailability.d.ts

@@ -0,0 +1,19 @@
+import type { AdaptableModule } from '../AdaptableState/Common/Types';
+import type { BaseContext } from '../AdaptableState/Common/BaseContext';
+import type { GlobalExpressionFunctionAvailabilityContext } from '../AdaptableOptions/ExpressionOptions';
+import type { AdaptableExpressionFunctionMetadata, ExpressionFunctionType } from './types';
+export type ApplyAvailabilityOptions = {
+    functionType: ExpressionFunctionType;
+    module: AdaptableModule | undefined;
+    customNames: Set<string>;
+    globalOverride?: (context: GlobalExpressionFunctionAvailabilityContext) => boolean;
+    buildBaseContext: () => BaseContext;
+    logWarn: (message: string) => void;
+};
+/**
+ * Filters a function pool to those available for a module: per-function
+ * `isAvailable`, then the central `isExpressionFunctionAvailable` override.
+ * Structural primitives (`PROTECTED_CORE_EXPRESSION_FUNCTIONS`) keep their
+ * system `isAvailable` but cannot be removed by the global override.
+ */
+export declare function applyExpressionFunctionAvailability<T extends string, D extends AdaptableExpressionFunctionMetadata>(pool: Record<T, D>, options: ApplyAvailabilityOptions): Record<T, D>;

package/src/aql/applyExpressionFunctionAvailability.js

@@ -0,0 +1,49 @@
+import { SUPER_POOL_MODULES } from './expressionFunctionAvailability';
+import { PROTECTED_CORE_EXPRESSION_FUNCTIONS } from './resolveCustomExpressionFunctions';
+export function applyExpressionFunctionAvailability(pool, options) {
+    const { functionType, module, customNames, globalOverride, buildBaseContext, logWarn } = options;
+    const isSuperPool = !module || SUPER_POOL_MODULES.includes(module);
+    const result = {};
+    for (const functionName of Object.keys(pool)) {
+        const expressionFunction = pool[functionName];
+        if (!expressionFunction) {
+            continue;
+        }
+        const buildAvailabilityContext = () => ({
+            module,
+            functionName,
+            functionType,
+            expressionFunction,
+            isCustom: customNames.has(functionName),
+            ...buildBaseContext(),
+        });
+        let available = true;
+        if (Array.isArray(expressionFunction.isAvailable)) {
+            available = isSuperPool ? true : expressionFunction.isAvailable.includes(module);
+        }
+        else if (typeof expressionFunction.isAvailable === 'function') {
+            available = expressionFunction.isAvailable(buildAvailabilityContext());
+        }
+        if (PROTECTED_CORE_EXPRESSION_FUNCTIONS.has(functionName)) {
+            if (available &&
+                typeof globalOverride === 'function' &&
+                globalOverride({ ...buildAvailabilityContext(), defaultAvailability: available }) === false) {
+                logWarn(`expressionOptions.isExpressionFunctionAvailable attempted to disable the structural function '${functionName}'; ignored — structural AQL primitives cannot be removed`);
+            }
+            if (available) {
+                result[functionName] = expressionFunction;
+            }
+            continue;
+        }
+        if (typeof globalOverride === 'function') {
+            available = globalOverride({
+                ...buildAvailabilityContext(),
+                defaultAvailability: available,
+            });
+        }
+        if (available) {
+            result[functionName] = expressionFunction;
+        }
+    }
+    return result;
+}

package/src/aql/badgeRuleQl.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Badge Style rule ⇄ AQL `QlGroup` bridge (pure helpers, no React).
+ *
+ * The read/write semantics of the Expression-based badge Rule editor.
+ * Mirrors the ColumnFilter bridge (`deriveColumnFilterGroup` /
+ * `buildColumnFilterFromGroup`) with one badge-specific difference:
+ * an empty rule is a *meaningful* state ("Always show") rather than
+ * a deactivation.
+ */
+import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import { BadgeStyleDefinition } from '../AdaptableState/StyledColumns/BadgeStyle';
+import type { QueryBuilderMapper } from '../components/aql/QueryBuilder/mapper';
+import { QlGroup } from "../../vendor/aql/index.js";
+/**
+ * Read half of the bridge: derives the editable `QlGroup` for a badge's
+ * rule from its `Rule` expression string. An empty group means "Always show", so
+ *     unlike the ColumnFilter there is no data-type default seed.
+ */
+export declare const deriveBadgeRuleGroup: (column: AdaptableColumn | undefined, badge: BadgeStyleDefinition, mapper: QueryBuilderMapper) => QlGroup;
+/**
+ * Write half of the bridge: builds the next badge from an edited group.
+ * Keeps only the complete conditions (`pruneToCompletePredicates`),
+ * serialises them to the `Rule` string. An empty complete-set means "Always
+ * show".
+ */
+export declare const buildBadgeRuleFromGroup: (column: AdaptableColumn | undefined, badge: BadgeStyleDefinition, group: QlGroup, mapper: QueryBuilderMapper) => BadgeStyleDefinition;

package/src/aql/badgeRuleQl.js

@@ -0,0 +1,27 @@
+import { asQlGroup, isQlPredicateError, mapQlPredicateToExpression, pruneToCompletePredicates, } from "../../vendor/aql/index.js";
+import { mapColumnDataTypeToExpressionFunctionType } from './adaptableQlUtils';
+export const deriveBadgeRuleGroup = (column, badge, mapper) => {
+    if (!column) {
+        return asQlGroup(null);
+    }
+    if (badge.Rule) {
+        const parsed = mapper.parse(badge.Rule);
+        if (parsed && !isQlPredicateError(parsed)) {
+            return asQlGroup(parsed);
+        }
+    }
+    return asQlGroup(null);
+};
+export const buildBadgeRuleFromGroup = (column, badge, group, mapper) => {
+    const completeGroup = pruneToCompletePredicates(group, mapper.functionPool, () => column
+        ? mapColumnDataTypeToExpressionFunctionType(column.dataType)
+        : undefined);
+    const next = { ...badge };
+    if (completeGroup.children.length > 0) {
+        next.Rule = mapQlPredicateToExpression(completeGroup);
+    }
+    else {
+        delete next.Rule;
+    }
+    return next;
+};

package/src/aql/chipColumnPlaceholder.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Sentinel column id inserted by Expression Editor skeleton chips
+ * (`CHANGE_COUNT{[col-here], …}`, `SUM{[col-here]}`, …). Selected after
+ * insert so typing replaces it; recognised by missing-column lint / hover
+ * as an authoring placeholder rather than an unknown grid column.
+ */
+export declare const CHIP_COLUMN_PLACEHOLDER = "col-here";
+/** Full token including brackets — what caret-enter clears / column-insert replaces. */
+export declare const CHIP_COLUMN_PLACEHOLDER_TOKEN = "[col-here]";
+/** Lint / hover copy when the chip column placeholder is still in the expression. */
+export declare const CHIP_COLUMN_PLACEHOLDER_MESSAGE = "Replace col-here with one of your columns";
+/**
+ * Sentinel duration literal for Observable skeleton chips
+ * (`WITHIN(duration-here)`). Parses as `DURATION_PLACEHOLDER` in AQL — not a
+ * real window.
+ */
+export declare const CHIP_DURATION_PLACEHOLDER = "duration-here";
+/** Lint / hover copy when `duration-here` is still in the expression. */
+export declare const CHIP_DURATION_PLACEHOLDER_MESSAGE = "Replace duration-here with a duration (e.g. 5m, 2h, 1d) or remove the WITHIN clause if its not required";
+export declare function isChipColumnPlaceholder(columnId: string): boolean;
+export declare function isChipDurationPlaceholder(text: string): boolean;
+/** True when the AST still carries a skeleton-chip `[col-here]` or `duration-here`. */
+export declare function astContainsChipPlaceholder(ast: unknown): boolean;
+/** @deprecated Prefer {@link astContainsChipPlaceholder}. */
+export declare const astContainsChipColumnPlaceholder: typeof astContainsChipPlaceholder;
+export type TextRange = {
+    from: number;
+    to: number;
+};
+/** Every `[col-here]` span in `text` (non-overlapping, left-to-right). */
+export declare function findChipColumnPlaceholderRanges(text: string): TextRange[];
+/** Every `duration-here` span in `text`. */
+export declare function findChipDurationPlaceholderRanges(text: string): TextRange[];
+/**
+ * The `[col-here]` token that contains or touches `range`, if any.
+ * Used when the caret sits inside the placeholder or the chip left
+ * `col-here` selected (without the brackets).
+ */
+export declare function findChipColumnPlaceholderRangeCovering(text: string, range: TextRange): TextRange | null;
+/** The `duration-here` token that contains or touches `range`, if any. */
+export declare function findChipDurationPlaceholderRangeCovering(text: string, range: TextRange): TextRange | null;

package/src/aql/chipColumnPlaceholder.js

@@ -0,0 +1,67 @@
+import { isAST_Function, walker, } from "../../vendor/aql/index.js";
+export const CHIP_COLUMN_PLACEHOLDER = 'col-here';
+export const CHIP_COLUMN_PLACEHOLDER_TOKEN = `[${CHIP_COLUMN_PLACEHOLDER}]`;
+export const CHIP_COLUMN_PLACEHOLDER_MESSAGE = `Replace ${CHIP_COLUMN_PLACEHOLDER} with one of your columns`;
+export const CHIP_DURATION_PLACEHOLDER = 'duration-here';
+export const CHIP_DURATION_PLACEHOLDER_MESSAGE = 'Replace duration-here with a duration (e.g. 5m, 2h, 1d) or remove the WITHIN clause if its not required';
+export function isChipColumnPlaceholder(columnId) {
+    return columnId === CHIP_COLUMN_PLACEHOLDER;
+}
+export function isChipDurationPlaceholder(text) {
+    return text === CHIP_DURATION_PLACEHOLDER;
+}
+export function astContainsChipPlaceholder(ast) {
+    let found = false;
+    walker(ast, (node) => {
+        if (found || !isAST_Function(node)) {
+            return;
+        }
+        if (node.type === 'COL' &&
+            node.args.length === 1 &&
+            typeof node.args[0] === 'string' &&
+            isChipColumnPlaceholder(node.args[0])) {
+            found = true;
+            return;
+        }
+        if (node.type === 'DURATION_PLACEHOLDER') {
+            found = true;
+        }
+    });
+    return found;
+}
+export const astContainsChipColumnPlaceholder = astContainsChipPlaceholder;
+function findTokenRanges(text, token) {
+    const ranges = [];
+    let index = 0;
+    while (index < text.length) {
+        const at = text.indexOf(token, index);
+        if (at < 0) {
+            break;
+        }
+        ranges.push({ from: at, to: at + token.length });
+        index = at + token.length;
+    }
+    return ranges;
+}
+export function findChipColumnPlaceholderRanges(text) {
+    return findTokenRanges(text, CHIP_COLUMN_PLACEHOLDER_TOKEN);
+}
+export function findChipDurationPlaceholderRanges(text) {
+    return findTokenRanges(text, CHIP_DURATION_PLACEHOLDER);
+}
+export function findChipColumnPlaceholderRangeCovering(text, range) {
+    for (const placeholder of findChipColumnPlaceholderRanges(text)) {
+        if (range.from <= placeholder.to && range.to >= placeholder.from) {
+            return placeholder;
+        }
+    }
+    return null;
+}
+export function findChipDurationPlaceholderRangeCovering(text, range) {
+    for (const placeholder of findChipDurationPlaceholderRanges(text)) {
+        if (range.from <= placeholder.to && range.to >= placeholder.from) {
+            return placeholder;
+        }
+    }
+    return null;
+}

package/src/aql/columnFilterQl.d.ts

@@ -0,0 +1,232 @@
+/**
+ * ColumnFilter ↔ AQL `QlPredicate` helper module.
+ *
+ * Pure functions only — no React. Used by `useColumnFilterQlPredicate`
+ * and the `*New` ColumnFilter components (the legacy predicate-based
+ * editor chain has been removed).
+ */
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import { QlArg, QlGroup, QlLogicalOperator, QlPredicate, QlPrimitive, ResolvedOperatorSlot } from "../../vendor/aql/index.js";
+import { AdaptableFilterComponentLocation, AdaptableIcon, ColumnFilter, ExpressionFunctionInputType } from '../types';
+import type { QueryBuilderMapper } from '../components/aql/QueryBuilder/mapper';
+export declare const isQlPredicateComplete: (api: AdaptableApi, predicate: QlPredicate | null | undefined) => boolean;
+export declare const pruneToCompletePredicates: (api: AdaptableApi, group: QlGroup) => QlGroup;
+/**
+ * Normalises any `QlPredicate` to the root shape the ColumnFilter UI
+ * works with — alias of the shared `asQlGroup`.
+ */
+export declare const asColumnFilterGroup: (predicate: QlPredicate | null, combinator?: QlLogicalOperator) => QlGroup;
+/**
+ * View-model for one operator entry in the ColumnFilter operator
+ * dropdown. `operator` is an AQL function name (e.g. `IN`, `NOT_IN`).
+ */
+export interface ColumnFilterOperatorDef {
+    /** AQL operator / function name (e.g. `IN`, `NOT_IN`, `IS_SAME_DAY`). */
+    operator: string;
+    label: string;
+    icon?: AdaptableIcon | {
+        text: string;
+    };
+    /**
+     * Resolved rhs slots for the given column (subject slots substituted
+     * with the column's data type).
+     */
+    slots: ResolvedOperatorSlot[];
+    shortcuts?: string[];
+}
+/** Stable select/key value for a ColumnFilter operator dropdown entry. */
+export declare const getColumnFilterOperatorValue: (def: ColumnFilterOperatorDef) => string;
+/**
+ * Display label for an operator — the function def's `label`, falling
+ * back to the function name (its id) when no `label` is defined.
+ */
+export declare const getColumnFilterOperatorLabel: (operator: string, subjectType?: ExpressionFunctionInputType) => string;
+/**
+ * Names of the AQL operators available in the ColumnFilter UI for the
+ * given column. Thin wrapper over the QueryBuilder pool helpers, bound
+ * to the `'ColumnFilter'` module pool. Keeps the legacy autoGroupCol
+ * exclusion (no `IS_BLANK` / `IS_NOT_BLANK`).
+ */
+export declare const getColumnFilterOperators: (api: AdaptableApi, column: AdaptableColumn) => string[];
+/**
+ * Builds the `{label, icon, shortcuts, slots}` view-model for an
+ * operator, resolving subject slots against the column's data type.
+ */
+export declare const getColumnFilterOperatorDef: (api: AdaptableApi, operator: string, column: AdaptableColumn) => ColumnFilterOperatorDef | null;
+export declare const getColumnFilterOperatorDefs: (api: AdaptableApi, column: AdaptableColumn) => ColumnFilterOperatorDef[];
+/**
+ * Operator shortcuts, with `columnFilterOptions.quickFilterWildcards`
+ * overrides applied. The option is keyed by AQL operator name
+ * (e.g. `GT`, `IN`).
+ */
+export declare const getOperatorShortcuts: (api: AdaptableApi, operator: string) => string[];
+/**
+ * Finds the operator matching a Quick Filter keystroke for the given
+ * column. Replaces `findPredicateDefByShortcut`.
+ */
+export declare const findOperatorByShortcut: (api: AdaptableApi, column: AdaptableColumn, key: string) => string | undefined;
+export declare const buildColumnFilterExpression: (qlPredicate: QlPredicate | null) => string;
+/**
+ * Best-effort Expression string for ColumnFilterChanged: full group when
+ * complete, otherwise the persistable subset, otherwise undefined.
+ */
+export declare const expressionForColumnFilterChangedEvent: (api: AdaptableApi, group: QlGroup) => string | undefined;
+/**
+ * Fresh primitive for the given operator, seeded with the column
+ * subject as `args[0]` (subject-less operators get no args).
+ */
+export declare const createColumnFilterPrimitive: (operator: string | undefined, columnId: string) => QlPrimitive;
+/**
+ * Resolves the ColumnFilter operator dropdown entry matching a draft
+ * child by operator name (e.g. `NOT_IN` → Not In).
+ */
+export declare const findColumnFilterOperatorDef: (defs: ColumnFilterOperatorDef[], child: QlPredicate | null | undefined) => ColumnFilterOperatorDef | null;
+/**
+ * Inner editable primitive for a ColumnFilter draft child.
+ */
+export declare const getEditableColumnFilterPrimitive: (child: QlPredicate | null | undefined) => QlPrimitive | null;
+/**
+ * The rhs operands of a primitive (everything after the implicit subject
+ * column). Unlike `getPrimitiveInputValues`, this keeps the raw `QlArg`
+ * structure (wire shape, no slot mapping) so callers can tell literals
+ * from column/field/function refs.
+ */
+export declare const getPrimitiveRhsArgs: (primitiveNode: QlPrimitive) => QlArg[];
+/**
+ * True when a rhs operand cannot be edited inline with the simple value
+ * inputs — i.e. it's a column/field reference, a function call, or a
+ * boolean sub-expression. Such primitives render as a read-only label
+ * (clicking it opens the full column filter window).
+ */
+export declare const primitiveHasNonEditableRhs: (primitiveNode: QlPrimitive) => boolean;
+/**
+ * Selected values of IN / NOT IN in a ColumnFilter Expression.
+ * Successor of reading `Predicates[].Inputs` for PredicateId In / NotIn.
+ */
+export declare const getColumnFilterInListValues: (columnFilter: ColumnFilter | undefined) => unknown[];
+/**
+ * Raw editor values of a primitive's rhs, one per operator slot
+ * (`QlLiteral` → value, `QlList` → value[], unfilled slot → `undefined`).
+ * Bridges the `QlPrimitive` model to the existing value-input components
+ * (which work on raw values). Slot mapping — including unfolding IN's
+ * wire `QlList` — is delegated to the shared slot view
+ * (`primitiveSlots.ts`).
+ */
+export declare const getPrimitiveInputValues: (primitiveNode: QlPrimitive, slots?: ResolvedOperatorSlot[]) => unknown[];
+/**
+ * Returns a copy of the primitive with its rhs args rebuilt from raw
+ * editor values, typed per the operator's resolved slots. Empty values are
+ * omitted; `writeRhsSlots` restores the canonical wire shape.
+ */
+export declare const withPrimitiveInputValues: (primitiveNode: QlPrimitive, values: unknown[], slots: ResolvedOperatorSlot[]) => QlPrimitive;
+/**
+ * True when the primitive has an operator that requires values but none
+ * are present — the "empty editor" state (mirrors `isPredicateEmpty`).
+ */
+export declare const isColumnFilterPrimitiveEmpty: (primitiveNode: QlPrimitive | undefined, def: ColumnFilterOperatorDef | undefined | null) => boolean;
+export declare const encodeInFilterFunctionToken: (functionName: string) => string;
+export declare const isInFilterFunctionToken: (value: unknown) => value is string;
+export declare const decodeInFilterFunctionToken: (value: unknown) => string | null;
+/**
+ * True when `name` is a known no-input (unary, subject-only) boolean
+ * Expression Function — the only functions eligible as `expressionFunction`
+ * In-filter items (e.g. IS_BLANK, IS_POSITIVE, IS_YESTERDAY). Multi-argument
+ * predicates (EQ, CONTAINS, IN, ...) are excluded.
+ */
+export declare const isNoInputBooleanFunction: (name: string | undefined) => boolean;
+/**
+ * True when a no-input boolean function is applicable to the Column's data
+ * type (its single operand accepts `any` or the Column's type). Used to
+ * silently skip inapplicable `expressionFunction` items (e.g. IS_YESTERDAY
+ * on a text column).
+ */
+export declare const isInFilterFunctionApplicableToColumn: (name: string | undefined, column: AdaptableColumn) => boolean;
+/**
+ * View of a ColumnFilter group that represents an "In filter": a single
+ * `IN` / `NOT_IN` primitive on `columnId`, optionally OR-combined with
+ * no-input boolean Expression-Function predicates on the same Column (the
+ * `expressionFunction` extras).
+ */
+export interface InFilterContext {
+    inPrimitive: QlPrimitive;
+    operator: string;
+    functionNames: string[];
+}
+/**
+ * Detects the In-filter shape and returns its parts, or `null` for any
+ * other shape (so the floating filter keeps treating non-`IN` groups the
+ * normal way). A standalone function predicate (e.g. `IS_BLANK([col])` with
+ * no `IN`) is intentionally *not* matched — it shows as its own operator.
+ */
+export declare const getInFilterContext: (columnId: string, group: QlGroup | null | undefined) => InFilterContext | null;
+/**
+ * Builds the ColumnFilter group for an In filter from its edited parts:
+ * the `IN` / `NOT_IN` primitive (always present, even when the literal list
+ * is empty, so the operator selection persists) OR-combined with one
+ * `FN([column])` predicate per selected `expressionFunction`.
+ */
+export declare const buildInFilterGroup: (columnId: string, operator: string, literals: unknown[], functionNames: string[], slots: ResolvedOperatorSlot[]) => QlGroup;
+/**
+ * **QueryBuilder editing bridge — fold.** The persisted In-filter shape is a
+ * pure OR group (`[col] IN (...) OR IS_BLANK([col])`), i.e. one row per clause.
+ * The QueryBuilder renders one row per child, so to mirror the floating filter
+ * (a single `IN` row with "Empty" ticked in its value dropdown) we collapse the
+ * whole group into a *single* `IN` primitive whose value list also carries a
+ * UI-only token per OR-combined function. This token lives only inside the
+ * uncontrolled editor's model and is expanded back out on change
+ * (`unfoldInFilterFromEditing`), so nothing impure is ever persisted.
+ *
+ * No-op unless the group is exactly the collapsible In-filter shape (`IN` +
+ * ≥1 no-input boolean function). `NOT_IN` and mixed/complex groups pass
+ * through untouched so they keep rendering as separate rows.
+ */
+export declare const foldInFilterFunctionsForEditing: (columnId: string, group: QlGroup, operatorDefs: ColumnFilterOperatorDef[]) => QlGroup;
+/**
+ * **QueryBuilder editing bridge — unfold.** Inverse of
+ * `foldInFilterFunctionsForEditing`: any `IN` primitive whose value list
+ * contains UI function tokens is split back into a pure `IN` (literals only)
+ * OR-combined with one real `FN([column])` predicate per token, so the
+ * persisted / applied Expression stays pure. No-op when no tokens are present.
+ */
+export declare const unfoldInFilterFunctionsFromEditing: (columnId: string, group: QlGroup, operatorDefs: ColumnFilterOperatorDef[]) => QlGroup;
+/**
+ * Human-readable label for the floating filter trigger. Drops the
+ * subject column (it's already the header), e.g. `[price] > 10` → `> 10`.
+ */
+export declare const qlGroupToLabel: (group: QlGroup, defs: ColumnFilterOperatorDef[]) => string;
+/**
+ * `default*ColumnFilter` and `PreferredFilter` values are AQL operator /
+ * function names (e.g. `GT`, `NOT_CONTAINS`, `IS_SAME_DAY`) — the same
+ * vocabulary the operator dropdown uses. A value is "known" when it
+ * resolves to a real system function, so the default-seed and the
+ * persisted `PreferredFilter` share one source of truth.
+ */
+export declare const isKnownPreferredFilter: (value: string | undefined | null) => boolean;
+/**
+ * Resolves the `PreferredFilter` (an AQL operator name) for the first
+ * (primary) condition in a ColumnFilter group. Returns `null` when no
+ * known operator is selected.
+ */
+export declare const resolvePreferredFilterFromGroup: (_api: AdaptableApi, _columnId: string, group: QlGroup) => string | null;
+/**
+ * Read half of the bridge: derives the editable `QlGroup` for a column's
+ * filter, in precedence order:
+ *  1. persisted `Expression` (parsed via the ColumnFilter module mapper);
+ *  2. persisted `PreferredFilter` (incomplete UI seed, no row filtering);
+ *  3. the data-type default operator seed (`default*ColumnFilter`).
+ */
+export declare const deriveColumnFilterGroup: (api: AdaptableApi, column: AdaptableColumn | undefined, columnFilter: ColumnFilter | undefined, mapper: QueryBuilderMapper, filterComponent: AdaptableFilterComponentLocation) => QlGroup;
+/**
+ * Write half of the bridge: builds the next `ColumnFilter` from an edited
+ * group.
+ *
+ * - Complete conditions → `{ ColumnId, Expression }` (`PreferredFilter` stripped).
+ * - Incomplete with a selected operator → `{ ColumnId, PreferredFilter }`
+ *   (`Expression` stripped), unless that PreferredFilter is already stored
+ *   and there is no Expression to clear (then `null` — draft-only update).
+ * - Previously persisted payload but no operator left → `'clear'` (caller
+ *   removes the Layout entry).
+ * - Nothing to persist → `null`.
+ */
+export declare const buildColumnFilterFromGroup: (api: AdaptableApi, existing: ColumnFilter | undefined, columnId: string, group: QlGroup) => ColumnFilter | "clear" | null;