import { Markup } from "./builtin/drops/markup";
import { RenderContext } from "./context";
import { Float, Integer } from "./number";
import { Range } from "./range";
export interface Expression {
    evaluate(context: RenderContext): Promise<unknown>;
    evaluateSync(context: RenderContext): unknown;
    equals(other: unknown): boolean;
    toString(): string;
    children?: () => Expression[];
}
export declare class Nil implements Expression {
    evaluate(): Promise<null>;
    evaluateSync(): null;
    equals(other: unknown): boolean;
    toString(): string;
    children(): Expression[];
}
export declare const NIL: Nil;
export declare class Empty implements Expression {
    evaluate(): Promise<Empty>;
    evaluateSync(): Empty;
    equals(other: unknown): boolean;
    toString(): string;
    children(): Expression[];
}
export declare const EMPTY: Empty;
export declare class Blank implements Expression {
    evaluate(): Promise<Blank>;
    evaluateSync(): Blank;
    equals(other: unknown): boolean;
    toString(): string;
    children(): Expression[];
}
export declare const BLANK: Blank;
export declare class Continue implements Expression {
    evaluate(): Promise<Continue>;
    evaluateSync(): Continue;
    equals(other: unknown): boolean;
    toString(): string;
    children(): Expression[];
}
export declare const CONTINUE: Continue;
export declare abstract class Literal<T> implements Expression {
    readonly value: T;
    constructor(value: T);
    evaluate(context: RenderContext): Promise<T>;
    evaluateSync(context: RenderContext): T;
    equals(other: unknown): boolean;
    toString(): string;
    children(): Expression[];
}
export declare class BooleanLiteral extends Literal<boolean> {
    equals(other: unknown): boolean;
}
export declare const TRUE: BooleanLiteral;
export declare const FALSE: BooleanLiteral;
export declare class StringLiteral extends Literal<string | Markup> {
    evaluate(context: RenderContext): Promise<string | Markup>;
    evaluateSync(context: RenderContext): string | Markup;
    equals(other: unknown): boolean;
}
export declare class IntegerLiteral extends Literal<Integer> {
    equals(other: unknown): boolean;
    toString(): string;
}
export declare class FloatLiteral extends Literal<Float> {
    equals(other: unknown): boolean;
    toString(): string;
}
export declare class RangeLiteral implements Expression {
    readonly start: Expression;
    readonly stop: Expression;
    constructor(start: Expression, stop: Expression);
    evaluate(context: RenderContext): Promise<Range>;
    evaluateSync(context: RenderContext): Range;
    equals(other: unknown): boolean;
    toString(): string;
    children(): Expression[];
}
export declare class IdentifierPathElement extends Literal<number | string> {
    equals(other: unknown): boolean;
}
export type IdentifierPath = Array<IdentifierPathElement | Identifier>;
export declare class Identifier implements Expression {
    readonly root: string | null;
    readonly path: IdentifierPath;
    constructor(root: string | null, path: IdentifierPath);
    equals(other: unknown): boolean;
    toString(): string;
    evaluate(context: RenderContext): Promise<unknown>;
    evaluateSync(context: RenderContext): unknown;
    children(): Expression[];
}
export declare class ExpressionFilter {
    readonly name: string;
    readonly args: Expression[];
    readonly kwargs: Map<string, Expression>;
    constructor(name: string, args?: Expression[], kwargs?: Map<string, Expression>);
    toString(): string;
    evalArgs(context: RenderContext): Promise<unknown[]>;
    evalKeywordArgs(context: RenderContext): Promise<{
        [index: string]: unknown;
    }>;
    evalArgsSync(context: RenderContext): unknown[];
    evalKeywordArgsSync(context: RenderContext): {
        [index: string]: unknown;
    };
}
export declare class FilteredExpression implements Expression {
    readonly expression: Expression;
    readonly filters: ExpressionFilter[];
    constructor(expression: Expression, filters?: ExpressionFilter[]);
    equals(other: unknown): boolean;
    toString(): string;
    protected applyFilters(left: unknown, filters: ExpressionFilter[], context: RenderContext): Promise<unknown>;
    protected applyFiltersSync(left: unknown, filters: ExpressionFilter[], context: RenderContext): unknown;
    evaluate(context: RenderContext): Promise<unknown>;
    evaluateSync(context: RenderContext): unknown;
    children(): Expression[];
}
export declare class ConditionalExpression extends FilteredExpression {
    readonly expression: Expression;
    readonly filters: ExpressionFilter[];
    readonly condition: Expression;
    readonly alternative: Expression;
    constructor(expression: Expression, filters?: ExpressionFilter[], condition?: Expression, alternative?: Expression);
    equals(other: unknown): boolean;
    toString(): string;
    evaluate(context: RenderContext): Promise<unknown>;
    evaluateSync(context: RenderContext): unknown;
    children(): Expression[];
}
export declare class PrefixExpression implements Expression {
    readonly operator: string;
    readonly right: Expression;
    constructor(operator: string, right: Expression);
    equals(other: unknown): boolean;
    toString(): string;
    evaluate(context: RenderContext): Promise<boolean>;
    evaluateSync(context: RenderContext): boolean;
    children(): Expression[];
}
export declare class InfixExpression implements Expression {
    readonly left: Expression;
    readonly operator: string;
    readonly right: Expression;
    constructor(left: Expression, operator: string, right: Expression);
    equals(other: unknown): boolean;
    toString(): string;
    evaluate(context: RenderContext): Promise<boolean>;
    evaluateSync(context: RenderContext): boolean;
    children(): Expression[];
}
export declare class BooleanExpression implements Expression {
    readonly expression: Expression;
    constructor(expression: Expression);
    equals(other: unknown): boolean;
    toString(): string;
    evaluate(context: RenderContext): Promise<boolean>;
    evaluateSync(context: RenderContext): boolean;
    children(): Expression[];
}
export type LoopArgument = IntegerLiteral | FloatLiteral | Identifier | Continue;
export declare const For: unique symbol;
export declare class LoopExpression implements Expression {
    readonly name: string;
    readonly iterable: RangeLiteral | Identifier | StringLiteral;
    readonly limit?: LoopArgument | undefined;
    readonly offset?: LoopArgument | undefined;
    readonly cols?: LoopArgument | undefined;
    readonly reversed: boolean;
    constructor(name: string, iterable: RangeLiteral | Identifier | StringLiteral, limit?: LoopArgument | undefined, offset?: LoopArgument | undefined, cols?: LoopArgument | undefined, reversed?: boolean);
    equals(other: unknown): boolean;
    toString(): string;
    protected toIter(obj: unknown): [Iterable<unknown>, number];
    protected drop(it: Iterator<unknown>, n: number): Generator<unknown>;
    protected take(it: Iterator<unknown>, n: number): Generator<unknown>;
    protected limitAndOffset(context: RenderContext, it: Iterable<unknown>, length: number, limit: unknown, offset: unknown): [Iterator<unknown>, number];
    evaluate(context: RenderContext): Promise<[Iterator<unknown>, number]>;
    evaluateSync(context: RenderContext): [Iterator<unknown>, number];
    children(): Expression[];
}
/**
 * Check a value for Liquid truthiness.
 * @param value - Any value
 * @returns `true` if the value is Liquid truthy, `false` otherwise.
 */
export declare function isLiquidTruthy(value: unknown): boolean;