@webda/cloudevents 3.0.0

package/lib/filters/sql/CESQLParserParser.d.ts

@@ -0,0 +1,313 @@
+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 { TerminalNode } from "antlr4ts/tree/TerminalNode.js";
+import { TokenStream } from "antlr4ts/TokenStream.js";
+import { Vocabulary } from "antlr4ts/Vocabulary.js";
+import { CESQLParserListener } from "./CESQLParserListener.js";
+import { CESQLParserVisitor } from "./CESQLParserVisitor.js";
+export declare class CESQLParserParser 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 AND = 7;
+    static readonly OR = 8;
+    static readonly XOR = 9;
+    static readonly NOT = 10;
+    static readonly STAR = 11;
+    static readonly DIVIDE = 12;
+    static readonly MODULE = 13;
+    static readonly PLUS = 14;
+    static readonly MINUS = 15;
+    static readonly EQUAL = 16;
+    static readonly NOT_EQUAL = 17;
+    static readonly GREATER = 18;
+    static readonly GREATER_OR_EQUAL = 19;
+    static readonly LESS = 20;
+    static readonly LESS_GREATER = 21;
+    static readonly LESS_OR_EQUAL = 22;
+    static readonly LIKE = 23;
+    static readonly EXISTS = 24;
+    static readonly IN = 25;
+    static readonly TRUE = 26;
+    static readonly FALSE = 27;
+    static readonly DQUOTED_STRING_LITERAL = 28;
+    static readonly SQUOTED_STRING_LITERAL = 29;
+    static readonly INTEGER_LITERAL = 30;
+    static readonly IDENTIFIER = 31;
+    static readonly IDENTIFIER_WITH_NUMBER = 32;
+    static readonly FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 33;
+    static readonly RULE_cesql = 0;
+    static readonly RULE_expression = 1;
+    static readonly RULE_atom = 2;
+    static readonly RULE_identifier = 3;
+    static readonly RULE_functionIdentifier = 4;
+    static readonly RULE_booleanLiteral = 5;
+    static readonly RULE_stringLiteral = 6;
+    static readonly RULE_integerLiteral = 7;
+    static readonly RULE_functionParameterList = 8;
+    static readonly RULE_setExpression = 9;
+    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);
+    cesql(): CesqlContext;
+    expression(): ExpressionContext;
+    expression(_p: number): ExpressionContext;
+    atom(): AtomContext;
+    identifier(): IdentifierContext;
+    functionIdentifier(): FunctionIdentifierContext;
+    booleanLiteral(): BooleanLiteralContext;
+    stringLiteral(): StringLiteralContext;
+    integerLiteral(): IntegerLiteralContext;
+    functionParameterList(): FunctionParameterListContext;
+    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 CesqlContext extends ParserRuleContext {
+    expression(): ExpressionContext;
+    EOF(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class ExpressionContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ExpressionContext): void;
+}
+export declare class FunctionInvocationExpressionContext extends ExpressionContext {
+    functionIdentifier(): FunctionIdentifierContext;
+    functionParameterList(): FunctionParameterListContext;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class UnaryLogicExpressionContext extends ExpressionContext {
+    NOT(): TerminalNode;
+    expression(): ExpressionContext;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class UnaryNumericExpressionContext extends ExpressionContext {
+    MINUS(): TerminalNode;
+    expression(): ExpressionContext;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class LikeExpressionContext extends ExpressionContext {
+    expression(): ExpressionContext;
+    LIKE(): TerminalNode;
+    stringLiteral(): StringLiteralContext;
+    NOT(): TerminalNode | undefined;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class ExistsExpressionContext extends ExpressionContext {
+    EXISTS(): TerminalNode;
+    identifier(): IdentifierContext;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class InExpressionContext extends ExpressionContext {
+    expression(): ExpressionContext;
+    IN(): TerminalNode;
+    setExpression(): SetExpressionContext;
+    NOT(): TerminalNode | undefined;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class BinaryMultiplicativeExpressionContext extends ExpressionContext {
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext;
+    STAR(): TerminalNode | undefined;
+    DIVIDE(): TerminalNode | undefined;
+    MODULE(): TerminalNode | undefined;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class BinaryAdditiveExpressionContext extends ExpressionContext {
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext;
+    PLUS(): TerminalNode | undefined;
+    MINUS(): TerminalNode | undefined;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class BinaryComparisonExpressionContext extends ExpressionContext {
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext;
+    EQUAL(): TerminalNode | undefined;
+    NOT_EQUAL(): TerminalNode | undefined;
+    LESS_GREATER(): TerminalNode | undefined;
+    GREATER_OR_EQUAL(): TerminalNode | undefined;
+    LESS_OR_EQUAL(): TerminalNode | undefined;
+    LESS(): TerminalNode | undefined;
+    GREATER(): TerminalNode | undefined;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class BinaryLogicExpressionContext extends ExpressionContext {
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext;
+    AND(): TerminalNode | undefined;
+    OR(): TerminalNode | undefined;
+    XOR(): TerminalNode | undefined;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class SubExpressionContext extends ExpressionContext {
+    LR_BRACKET(): TerminalNode;
+    expression(): ExpressionContext;
+    RR_BRACKET(): TerminalNode;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class AtomExpressionContext extends ExpressionContext {
+    atom(): AtomContext;
+    constructor(ctx: ExpressionContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class AtomContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: AtomContext): void;
+}
+export declare class BooleanAtomContext extends AtomContext {
+    booleanLiteral(): BooleanLiteralContext;
+    constructor(ctx: AtomContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class IntegerAtomContext extends AtomContext {
+    integerLiteral(): IntegerLiteralContext;
+    constructor(ctx: AtomContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class StringAtomContext extends AtomContext {
+    stringLiteral(): StringLiteralContext;
+    constructor(ctx: AtomContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class IdentifierAtomContext extends AtomContext {
+    identifier(): IdentifierContext;
+    constructor(ctx: AtomContext);
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<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: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class FunctionIdentifierContext extends ParserRuleContext {
+    IDENTIFIER(): TerminalNode | undefined;
+    FUNCTION_IDENTIFIER_WITH_UNDERSCORE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<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: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<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: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class IntegerLiteralContext extends ParserRuleContext {
+    INTEGER_LITERAL(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class FunctionParameterListContext extends ParserRuleContext {
+    LR_BRACKET(): TerminalNode;
+    RR_BRACKET(): TerminalNode;
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}
+export declare class SetExpressionContext extends ParserRuleContext {
+    LR_BRACKET(): TerminalNode;
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext;
+    RR_BRACKET(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: CESQLParserListener): void;
+    exitRule(listener: CESQLParserListener): void;
+    accept<Result>(visitor: CESQLParserVisitor<Result>): Result;
+}