export declare type BooleanOperatorToken = {
    location: TokenLocation;
    operator: 'AND' | 'OR';
    type: 'BooleanOperator';
};

declare type ComparisonOperator = ':' | ':<' | ':<=' | ':=' | ':>' | ':>=';

export declare type ComparisonOperatorToken = {
    location: TokenLocation;
    operator: ComparisonOperator;
    type: 'ComparisonOperator';
};

export declare type EmptyExpression = {
    location: TokenLocation;
    type: 'EmptyExpression';
};

export declare type ExpressionToken = EmptyExpression | LiteralExpressionToken | RangeExpressionToken | RegexExpressionToken;

declare class ExtendableError extends Error {
    public name: string;
    public message: string;
    public stack?: string;
}

export declare type FieldToken = {
    location: TokenLocation;
    name: string;
    path?: readonly string[];
    type: 'Field';
} & ({
    quoted: false;
} | {
    quoted: true;
    quotes: 'double' | 'single';
});

export declare const filter: <T extends Object>(ast: LiqeQuery, data: readonly T[]) => readonly T[];

export declare const highlight: <T extends Object>(ast: LiqeQuery, data: T) => Highlight_2[];

declare type Highlight_2 = {
    path: string;
    query?: RegExp;
};
export { Highlight_2 as Highlight }

export declare type ImplicitBooleanOperatorToken = {
    operator: 'AND';
    type: 'ImplicitBooleanOperator';
};

export declare type ImplicitFieldToken = {
    type: 'ImplicitField';
};

declare type InternalTest = (value: unknown) => boolean | string;

export declare const isSafeUnquotedExpression: (expression: string) => boolean;

export declare class LiqeError extends ExtendableError {
}

export declare type LiqeQuery = ParserAst & {
    getValue?: (subject: unknown) => unknown;
    left?: LiqeQuery;
    operand?: LiqeQuery;
    right?: LiqeQuery;
};

export declare type LiteralExpressionToken = {
    location: TokenLocation;
    type: 'LiteralExpression';
} & ({
    quoted: false;
    value: boolean | null | string;
} | {
    quoted: true;
    quotes: 'double' | 'single';
    value: string;
});

export declare type LogicalExpressionToken = {
    left: ParserAst;
    location: TokenLocation;
    operator: BooleanOperatorToken | ImplicitBooleanOperatorToken;
    right: ParserAst;
    type: 'LogicalExpression';
};

export declare type ParenthesizedExpressionToken = {
    expression: ParserAst;
    location: TokenLocation;
    type: 'ParenthesizedExpression';
};

export declare const parse: (query: string) => LiqeQuery;

export declare type ParserAst = EmptyExpression | LogicalExpressionToken | ParenthesizedExpressionToken | TagToken | UnaryOperatorToken;

declare type Range_2 = {
    max: number;
    maxInclusive: boolean;
    min: number;
    minInclusive: boolean;
};

export declare type RangeExpressionToken = {
    location: TokenLocation;
    range: Range_2;
    type: 'RangeExpression';
};

export declare type RegexExpressionToken = {
    location: TokenLocation;
    type: 'RegexExpression';
    value: string;
};

export declare const serialize: (ast: LiqeQuery) => string;

declare class SyntaxError_2 extends LiqeError {
    message: string;
    offset: number;
    line: number;
    column: number;
    constructor(message: string, offset: number, line: number, column: number);
}
export { SyntaxError_2 as SyntaxError }

export declare type TagToken = {
    expression: ExpressionToken;
    field: FieldToken | ImplicitFieldToken;
    location: TokenLocation;
    operator: ComparisonOperatorToken;
    test?: InternalTest;
    type: 'Tag';
};

export declare const test: <T extends Object>(ast: LiqeQuery, subject: T) => boolean;

declare type TokenLocation = {
    end: number;
    start: number;
};

export declare type UnaryOperatorToken = {
    location: TokenLocation;
    operand: ParserAst;
    operator: '-' | 'NOT';
    type: 'UnaryOperator';
};

export { }