export declare class TokenType {
    name: string;
    options: {
        [key: string]: any;
    };
    static Eof: TokenType;
    static Command: TokenType;
    static Delimiter: TokenType;
    static SemiColon: TokenType;
    static WhiteSpace: TokenType;
    static LineBreak: TokenType;
    static LineComment: TokenType;
    static BlockComment: TokenType;
    static HintComment: TokenType;
    static LeftParen: TokenType;
    static RightParen: TokenType;
    static LeftBracket: TokenType;
    static RightBracket: TokenType;
    static Comma: TokenType;
    static Dot: TokenType;
    static Operator: TokenType;
    static Number: TokenType;
    static Size: TokenType;
    static String: TokenType;
    static BindVariable: TokenType;
    static SessionVariable: TokenType;
    static UserVariable: TokenType;
    static QuotedValue: TokenType;
    static QuotedIdentifier: TokenType;
    static Identifier: TokenType;
    static Error: TokenType;
    constructor(name: string, options?: {
        [key: string]: any;
    });
}
export declare class Token {
    text: string;
    pos: number;
    before: Token[];
    type: TokenType;
    subtype?: TokenType;
    constructor(type: TokenType | [TokenType, TokenType], text: string, pos?: number, before?: Token[]);
}
export declare class Node {
    name: string;
    value?: string | undefined;
    parent?: Node;
    children: (Node | Token)[];
    constructor(name: string, value?: string | undefined);
    add(...child: (Node | Token)[]): this;
    has(name: string): boolean;
}
export declare abstract class Lexer {
    type: string;
    private patterns;
    constructor(type: string, patterns: {
        type: TokenType;
        re: RegExp | (() => RegExp);
    }[]);
    lex(input: string): Token[];
    protected filter(input: string): string;
    protected process(token: Token): Token;
}
export declare type ParseFunction = (input: string, options?: Record<string, any>) => Node;
export declare abstract class Parser {
    protected tokens: Token[];
    protected options: Record<string, any>;
    protected pos: number;
    constructor(tokens: Token[], options?: Record<string, any>);
    abstract root(): Node;
    token(pos?: number): Token;
    peekIf(...types: TokenType[]): boolean;
    consumeIf(...types: TokenType[]): boolean;
    consume(...types: TokenType[]): boolean;
    createParseError(message?: string): ParseError;
}
export declare class AggregateParseError extends Error {
    errors: Error[];
    constructor(errors: Error[], message: string);
}
export declare class ParseError extends Error {
    message: string;
    fileName: string;
    lineNumber: number;
    columnNumber: number;
    node?: Node;
    constructor(message: string, fileName: string, lineNumber: number, columnNumber: number);
}
//# sourceMappingURL=parser.d.ts.map