import type { LiquidExpression, LiquidConditionalExpression, ComplexLiquidExpression } from '../ast';
import type { Position } from '../types';
export declare enum LogicalOperator {
    And = "and",
    Or = "or"
}
export declare enum EqualityOperator {
    Equal = "==",
    NotEqual = "!="
}
export declare enum ComparisonOperator {
    LessThan = "<",
    GreaterThan = ">",
    LessThanOrEqual = "<=",
    GreaterThanOrEqual = ">=",
    Contains = "contains"
}
export declare const LOGICAL_OPERATORS: Set<string>;
export declare const EQUALITY_OPERATORS: Set<string>;
export declare const COMPARISON_OPERATORS: Set<string>;
export type BinaryOperator = LogicalOperator | EqualityOperator | ComparisonOperator;
export interface ComparisonBinaryExpression {
    kind: 'comparison';
    left: LiquidExpression;
    op: EqualityOperator | ComparisonOperator;
    right: LiquidExpression;
    position: Position;
    source: string;
}
export interface LogicalBinaryExpression {
    kind: 'logical';
    left: BinaryExpr | LiquidExpression;
    op: LogicalOperator;
    right: BinaryExpr | LiquidExpression;
    /** Start offset of the operator keyword (e.g. `and`/`or`). Used by the
     *  adapter to set the right child LogicalExpression's position.start to
     *  include the preceding operator, matching the original parser. */
    opStart: number;
    position: Position;
    source: string;
}
export type BinaryExpr = ComparisonBinaryExpression | LogicalBinaryExpression;
/** Parser-internal alias for leaf types (strings, numbers, literals, lookups, ranges). */
export type ValueExpression = LiquidExpression;
/** Full parser-internal union: binary expressions or leaf values. */
export type Expression = BinaryExpr | ValueExpression;
export declare function isBinaryExpression(node: Expression): node is BinaryExpr;
export declare function adaptConditional(node: Expression): LiquidConditionalExpression;
export declare function adaptComplex(node: Expression): ComplexLiquidExpression;