@webda/core/lib/stores/webdaql/WebdaQLParserParser.d.ts

Expose API with Lambda

import { ATN } from "antlr4ts/atn/ATN.js";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException.js";
import { Parser } from "antlr4ts/Parser.js";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext.js";
import { RuleContext } from "antlr4ts/RuleContext.js";
import { TokenStream } from "antlr4ts/TokenStream.js";
import { TerminalNode } from "antlr4ts/tree/TerminalNode.js";
import { Vocabulary } from "antlr4ts/Vocabulary.js";
import { WebdaQLParserListener } from "./WebdaQLParserListener.js";
import { WebdaQLParserVisitor } from "./WebdaQLParserVisitor.js";
export declare class WebdaQLParserParser extends Parser {
    static readonly SPACE = 1;
    static readonly LR_BRACKET = 2;
    static readonly RR_BRACKET = 3;
    static readonly COMMA = 4;
    static readonly SINGLE_QUOTE_SYMB = 5;
    static readonly DOUBLE_QUOTE_SYMB = 6;
    static readonly LR_SQ_BRACKET = 7;
    static readonly RR_SQ_BRACKET = 8;
    static readonly AND = 9;
    static readonly OR = 10;
    static readonly EQUAL = 11;
    static readonly NOT_EQUAL = 12;
    static readonly GREATER = 13;
    static readonly GREATER_OR_EQUAL = 14;
    static readonly LESS = 15;
    static readonly LESS_OR_EQUAL = 16;
    static readonly LIKE = 17;
    static readonly IN = 18;
    static readonly CONTAINS = 19;
    static readonly TRUE = 20;
    static readonly FALSE = 21;
    static readonly LIMIT = 22;
    static readonly OFFSET = 23;
    static readonly ORDER_BY = 24;
    static readonly ASC = 25;
    static readonly DESC = 26;
    static readonly DQUOTED_STRING_LITERAL = 27;
    static readonly SQUOTED_STRING_LITERAL = 28;
    static readonly INTEGER_LITERAL = 29;
    static readonly IDENTIFIER = 30;
    static readonly IDENTIFIER_WITH_NUMBER = 31;
    static readonly FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 32;
    static readonly RULE_webdaql = 0;
    static readonly RULE_limitExpression = 1;
    static readonly RULE_offsetExpression = 2;
    static readonly RULE_orderFieldExpression = 3;
    static readonly RULE_orderExpression = 4;
    static readonly RULE_expression = 5;
    static readonly RULE_values = 6;
    static readonly RULE_atom = 7;
    static readonly RULE_identifier = 8;
    static readonly RULE_booleanLiteral = 9;
    static readonly RULE_stringLiteral = 10;
    static readonly RULE_integerLiteral = 11;
    static readonly RULE_setExpression = 12;
    static readonly ruleNames: string[];
    private static readonly _LITERAL_NAMES;
    private static readonly _SYMBOLIC_NAMES;
    static readonly VOCABULARY: Vocabulary;
    get vocabulary(): Vocabulary;
    get grammarFileName(): string;
    get ruleNames(): string[];
    get serializedATN(): string;
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    webdaql(): WebdaqlContext;
    limitExpression(): LimitExpressionContext;
    offsetExpression(): OffsetExpressionContext;
    orderFieldExpression(): OrderFieldExpressionContext;
    orderExpression(): OrderExpressionContext;
    expression(): ExpressionContext;
    expression(_p: number): ExpressionContext;
    values(): ValuesContext;
    atom(): AtomContext;
    identifier(): IdentifierContext;
    booleanLiteral(): BooleanLiteralContext;
    stringLiteral(): StringLiteralContext;
    integerLiteral(): IntegerLiteralContext;
    setExpression(): SetExpressionContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expression_sempred;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class WebdaqlContext extends ParserRuleContext {
    EOF(): TerminalNode;
    expression(): ExpressionContext | undefined;
    orderExpression(): OrderExpressionContext | undefined;
    limitExpression(): LimitExpressionContext | undefined;
    offsetExpression(): OffsetExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class LimitExpressionContext extends ParserRuleContext {
    LIMIT(): TerminalNode;
    integerLiteral(): IntegerLiteralContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class OffsetExpressionContext extends ParserRuleContext {
    OFFSET(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class OrderFieldExpressionContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    ASC(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class OrderExpressionContext extends ParserRuleContext {
    ORDER_BY(): TerminalNode;
    orderFieldExpression(): OrderFieldExpressionContext[];
    orderFieldExpression(i: number): OrderFieldExpressionContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class ExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ExpressionContext): void;
}
export declare class LikeExpressionContext extends ExpressionContext {
    identifier(): IdentifierContext;
    LIKE(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class InExpressionContext extends ExpressionContext {
    identifier(): IdentifierContext;
    IN(): TerminalNode;
    setExpression(): SetExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class ContainsExpressionContext extends ExpressionContext {
    identifier(): IdentifierContext;
    CONTAINS(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class BinaryComparisonExpressionContext extends ExpressionContext {
    identifier(): IdentifierContext;
    values(): ValuesContext;
    EQUAL(): TerminalNode | undefined;
    NOT_EQUAL(): TerminalNode | undefined;
    GREATER_OR_EQUAL(): TerminalNode | undefined;
    LESS_OR_EQUAL(): TerminalNode | undefined;
    LESS(): TerminalNode | undefined;
    GREATER(): TerminalNode | undefined;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class AndLogicExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    AND(): TerminalNode;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class OrLogicExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    OR(): TerminalNode;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class SubExpressionContext extends ExpressionContext {
    LR_BRACKET(): TerminalNode;
    expression(): ExpressionContext;
    RR_BRACKET(): TerminalNode;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class AtomExpressionContext extends ExpressionContext {
    atom(): AtomContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class ValuesContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ValuesContext): void;
}
export declare class BooleanAtomContext extends ValuesContext {
    booleanLiteral(): BooleanLiteralContext;
    constructor(ctx: ValuesContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class IntegerAtomContext extends ValuesContext {
    integerLiteral(): IntegerLiteralContext;
    constructor(ctx: ValuesContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class StringAtomContext extends ValuesContext {
    stringLiteral(): StringLiteralContext;
    constructor(ctx: ValuesContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class AtomContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: AtomContext): void;
}
export declare class ValuesAtomContext extends AtomContext {
    values(): ValuesContext;
    constructor(ctx: AtomContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class IdentifierAtomContext extends AtomContext {
    identifier(): IdentifierContext;
    constructor(ctx: AtomContext);
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    IDENTIFIER_WITH_NUMBER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class BooleanLiteralContext extends ParserRuleContext {
    TRUE(): TerminalNode | undefined;
    FALSE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class StringLiteralContext extends ParserRuleContext {
    DQUOTED_STRING_LITERAL(): TerminalNode | undefined;
    SQUOTED_STRING_LITERAL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class IntegerLiteralContext extends ParserRuleContext {
    INTEGER_LITERAL(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}
export declare class SetExpressionContext extends ParserRuleContext {
    LR_SQ_BRACKET(): TerminalNode;
    values(): ValuesContext[];
    values(i: number): ValuesContext;
    RR_SQ_BRACKET(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: WebdaQLParserListener): void;
    exitRule(listener: WebdaQLParserListener): void;
    accept<Result>(visitor: WebdaQLParserVisitor<Result>): Result;
}