@judo/idem/dist/generated/IdemParser.d.ts

A powerful and expressive query language designed for filtering and manipulating data

import { Token } from 'antlr4ng';
import { IdemListener } from './IdemListener.js';
import { IdemVisitor } from './IdemVisitor.js';
import * as antlr from "antlr4ng";
export declare class IdemParser extends antlr.Parser {
    static readonly T__0 = 1;
    static readonly T__1 = 2;
    static readonly T__2 = 3;
    static readonly T__3 = 4;
    static readonly T__4 = 5;
    static readonly T__5 = 6;
    static readonly T__6 = 7;
    static readonly T__7 = 8;
    static readonly T__8 = 9;
    static readonly T__9 = 10;
    static readonly T__10 = 11;
    static readonly T__11 = 12;
    static readonly T__12 = 13;
    static readonly T__13 = 14;
    static readonly T__14 = 15;
    static readonly T__15 = 16;
    static readonly T__16 = 17;
    static readonly T__17 = 18;
    static readonly T__18 = 19;
    static readonly T__19 = 20;
    static readonly T__20 = 21;
    static readonly T__21 = 22;
    static readonly T__22 = 23;
    static readonly T__23 = 24;
    static readonly T__24 = 25;
    static readonly T__25 = 26;
    static readonly T__26 = 27;
    static readonly T__27 = 28;
    static readonly T__28 = 29;
    static readonly T__29 = 30;
    static readonly T__30 = 31;
    static readonly T__31 = 32;
    static readonly T__32 = 33;
    static readonly T__33 = 34;
    static readonly T__34 = 35;
    static readonly Self = 36;
    static readonly In = 37;
    static readonly Cases = 38;
    static readonly Or = 39;
    static readonly Xor = 40;
    static readonly And = 41;
    static readonly Not = 42;
    static readonly Implies = 43;
    static readonly Identifier = 44;
    static readonly Number = 45;
    static readonly StringLiteral = 46;
    static readonly DATE = 47;
    static readonly TIMESTAMP = 48;
    static readonly TIME = 49;
    static readonly WS = 50;
    static readonly RULE_parse = 0;
    static readonly RULE_expression = 1;
    static readonly RULE_literal = 2;
    static readonly RULE_enumLiteral = 3;
    static readonly RULE_qualifiedName = 4;
    static readonly RULE_temporalLiteral = 5;
    static readonly RULE_argumentList = 6;
    static readonly RULE_argument = 7;
    static readonly RULE_iteratorArgument = 8;
    static readonly literalNames: (string | null)[];
    static readonly symbolicNames: (string | null)[];
    static readonly ruleNames: string[];
    get grammarFileName(): string;
    get literalNames(): (string | null)[];
    get symbolicNames(): (string | null)[];
    get ruleNames(): string[];
    get serializedATN(): number[];
    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException;
    constructor(input: antlr.TokenStream);
    parse(): ParseContext;
    expression(): ExpressionContext;
    expression(_p: number): ExpressionContext;
    literal(): LiteralContext;
    enumLiteral(): EnumLiteralContext;
    qualifiedName(): QualifiedNameContext;
    temporalLiteral(): TemporalLiteralContext;
    argumentList(): ArgumentListContext;
    argument(): ArgumentContext;
    iteratorArgument(): IteratorArgumentContext;
    sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
    private expression_sempred;
    private argument_sempred;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): antlr.ATN;
    private static readonly vocabulary;
    get vocabulary(): antlr.Vocabulary;
    private static readonly decisionsToDFA;
}
export declare class ParseContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class ExpressionContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ExpressionContext): void;
}
export declare class SelfExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    Self(): antlr.TerminalNode;
    Identifier(): antlr.TerminalNode[];
    Identifier(i: number): antlr.TerminalNode | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class UnaryMinusExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class NotExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    Not(): antlr.TerminalNode;
    expression(): ExpressionContext;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class LiteralExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    literal(): LiteralContext;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class IdentifierExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    Identifier(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class ParenthesesExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class PowerExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class MultiplyDivideModExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class AddSubtractExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class ComparisonExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class InExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    In(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class EqualityExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class AndExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    And(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class XorExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    Xor(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class OrExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    Or(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class ImpliesExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    Implies(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TernaryExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class FunctionCallExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext;
    Identifier(): antlr.TerminalNode;
    argumentList(): ArgumentListContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class NavigationExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext;
    Identifier(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class IndexAccessExpressionContext extends ExpressionContext {
    constructor(ctx: ExpressionContext);
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext | null;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class LiteralContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: LiteralContext): void;
}
export declare class NumericLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    Number(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class StringLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    StringLiteral(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class BooleanTrueLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class BooleanFalseLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TemporalLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    temporalLiteral(): TemporalLiteralContext;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class NullLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class EnumLiteralAltContext extends LiteralContext {
    constructor(ctx: LiteralContext);
    enumLiteral(): EnumLiteralContext;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class EnumLiteralContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    qualifiedName(): QualifiedNameContext;
    Identifier(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class QualifiedNameContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    Identifier(): antlr.TerminalNode[];
    Identifier(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TemporalLiteralContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: TemporalLiteralContext): void;
}
export declare class DateLiteralContext extends TemporalLiteralContext {
    constructor(ctx: TemporalLiteralContext);
    DATE(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TimestampLiteralContext extends TemporalLiteralContext {
    constructor(ctx: TemporalLiteralContext);
    TIMESTAMP(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TimeLiteralContext extends TemporalLiteralContext {
    constructor(ctx: TemporalLiteralContext);
    TIME(): antlr.TerminalNode;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TodayLiteralContext extends TemporalLiteralContext {
    constructor(ctx: TemporalLiteralContext);
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class YesterdayLiteralContext extends TemporalLiteralContext {
    constructor(ctx: TemporalLiteralContext);
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class TomorrowLiteralContext extends TemporalLiteralContext {
    constructor(ctx: TemporalLiteralContext);
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class ArgumentListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    argument(): ArgumentContext[];
    argument(i: number): ArgumentContext | null;
    get ruleIndex(): number;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class ArgumentContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    iteratorArgument(): IteratorArgumentContext | null;
    expression(): ExpressionContext | null;
    get ruleIndex(): number;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}
export declare class IteratorArgumentContext extends antlr.ParserRuleContext {
    _sortDirection?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    Identifier(): antlr.TerminalNode;
    expression(): ExpressionContext;
    Cases(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: IdemListener): void;
    exitRule(listener: IdemListener): void;
    accept<Result>(visitor: IdemVisitor<Result>): Result | null;
}