import { ATN } from 'antlr4ts/atn/ATN';
import { Parser } from 'antlr4ts/Parser';
import { ParserRuleContext } from 'antlr4ts/ParserRuleContext';
import { RuleContext } from 'antlr4ts/RuleContext';
import { TerminalNode } from 'antlr4ts/tree/TerminalNode';
import { Token } from 'antlr4ts/Token';
import { TokenStream } from 'antlr4ts/TokenStream';
import { Vocabulary } from 'antlr4ts/Vocabulary';
import { DIELVisitor } from './DIELVisitor';
export declare class DIELParser extends 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 BOOLEANVAL = 13;
    static readonly EVENT = 14;
    static readonly CROSSFILTER = 15;
    static readonly LINK = 16;
    static readonly PREDICATE = 17;
    static readonly CONSTRAIN = 18;
    static readonly TEMPLATE = 19;
    static readonly FILTER = 20;
    static readonly FACTORS = 21;
    static readonly MEASURING = 22;
    static readonly SELECTION = 23;
    static readonly USE = 24;
    static readonly XCHART = 25;
    static readonly NAME = 26;
    static readonly PUBLIC = 27;
    static readonly SINGLE = 28;
    static readonly LINE = 29;
    static readonly DYNAMIC = 30;
    static readonly REGISTER = 31;
    static readonly TYPE = 32;
    static readonly UDF = 33;
    static readonly CREATE = 34;
    static readonly DEFAULT = 35;
    static readonly EXCEPT = 36;
    static readonly ALL = 37;
    static readonly DROP = 38;
    static readonly CHECK = 39;
    static readonly UNIQUE = 40;
    static readonly PRIMARY = 41;
    static readonly FOREIGN = 42;
    static readonly REFERENCES = 43;
    static readonly KEY = 44;
    static readonly TABLE = 45;
    static readonly VIEW = 46;
    static readonly BOOLEAN = 47;
    static readonly OUTPUT = 48;
    static readonly PROGRAM = 49;
    static readonly AFTER = 50;
    static readonly BEGIN = 51;
    static readonly END = 52;
    static readonly WITH = 53;
    static readonly INSERT = 54;
    static readonly INTO = 55;
    static readonly VALUES = 56;
    static readonly AS = 57;
    static readonly SELECT = 58;
    static readonly FROM = 59;
    static readonly NATURAL = 60;
    static readonly JOIN = 61;
    static readonly ON = 62;
    static readonly WHERE = 63;
    static readonly LIMIT = 64;
    static readonly EXIST = 65;
    static readonly GROUP = 66;
    static readonly BY = 67;
    static readonly HAVING = 68;
    static readonly AND = 69;
    static readonly OR = 70;
    static readonly IN = 71;
    static readonly INTERSECT = 72;
    static readonly UNION = 73;
    static readonly LEFT = 74;
    static readonly OUTER = 75;
    static readonly CASE = 76;
    static readonly WHEN = 77;
    static readonly THEN = 78;
    static readonly ELSE = 79;
    static readonly IS = 80;
    static readonly NULL = 81;
    static readonly NOT = 82;
    static readonly ORDER = 83;
    static readonly ASC = 84;
    static readonly DESC = 85;
    static readonly AUTOINCREMENT = 86;
    static readonly DATETIME = 87;
    static readonly DISTINCT = 88;
    static readonly TRUE = 89;
    static readonly FALSE = 90;
    static readonly CACHED = 91;
    static readonly DELETE = 92;
    static readonly INT = 93;
    static readonly TEXT = 94;
    static readonly LATEST = 95;
    static readonly MINUS = 96;
    static readonly DELIM = 97;
    static readonly STAR = 98;
    static readonly COMMA = 99;
    static readonly PIPE = 100;
    static readonly SIMPLE_COMMENT = 101;
    static readonly NUMBER = 102;
    static readonly STRING = 103;
    static readonly IDENTIFIER = 104;
    static readonly WS = 105;
    static readonly RULE_queries = 0;
    static readonly RULE_registerTypeUdf = 1;
    static readonly RULE_templateStmt = 2;
    static readonly RULE_dataType = 3;
    static readonly RULE_columnDefinition = 4;
    static readonly RULE_constraintDefinition = 5;
    static readonly RULE_originalTableStmt = 6;
    static readonly RULE_relationDefintion = 7;
    static readonly RULE_constraintClause = 8;
    static readonly RULE_columnConstraints = 9;
    static readonly RULE_viewStmt = 10;
    static readonly RULE_programStmt = 11;
    static readonly RULE_programBody = 12;
    static readonly RULE_aProgram = 13;
    static readonly RULE_selectQuery = 14;
    static readonly RULE_templateQuery = 15;
    static readonly RULE_dropQuery = 16;
    static readonly RULE_deleteStmt = 17;
    static readonly RULE_variableAssignment = 18;
    static readonly RULE_compositeSelect = 19;
    static readonly RULE_setOp = 20;
    static readonly RULE_selectUnitQuery = 21;
    static readonly RULE_whereClause = 22;
    static readonly RULE_groupByClause = 23;
    static readonly RULE_havingClause = 24;
    static readonly RULE_orderByClause = 25;
    static readonly RULE_orderSpec = 26;
    static readonly RULE_insertQuery = 27;
    static readonly RULE_insertBody = 28;
    static readonly RULE_joinClause = 29;
    static readonly RULE_limitClause = 30;
    static readonly RULE_relationReference = 31;
    static readonly RULE_expr = 32;
    static readonly RULE_unitExpr = 33;
    static readonly RULE_selectColumnClause = 34;
    static readonly RULE_value = 35;
    static readonly RULE_mathOp = 36;
    static readonly RULE_compareOp = 37;
    static readonly RULE_logicOp = 38;
    static readonly ruleNames: string[];
    private static readonly _LITERAL_NAMES;
    private static readonly _SYMBOLIC_NAMES;
    static readonly VOCABULARY: Vocabulary;
    readonly vocabulary: Vocabulary;
    readonly grammarFileName: string;
    readonly ruleNames: string[];
    readonly serializedATN: string;
    constructor(input: TokenStream);
    queries(): QueriesContext;
    registerTypeUdf(): RegisterTypeUdfContext;
    templateStmt(): TemplateStmtContext;
    dataType(): DataTypeContext;
    columnDefinition(): ColumnDefinitionContext;
    constraintDefinition(): ConstraintDefinitionContext;
    originalTableStmt(): OriginalTableStmtContext;
    relationDefintion(): RelationDefintionContext;
    constraintClause(): ConstraintClauseContext;
    columnConstraints(): ColumnConstraintsContext;
    viewStmt(): ViewStmtContext;
    programStmt(): ProgramStmtContext;
    programBody(): ProgramBodyContext;
    aProgram(): AProgramContext;
    selectQuery(): SelectQueryContext;
    templateQuery(): TemplateQueryContext;
    dropQuery(): DropQueryContext;
    deleteStmt(): DeleteStmtContext;
    variableAssignment(): VariableAssignmentContext;
    compositeSelect(): CompositeSelectContext;
    setOp(): SetOpContext;
    selectUnitQuery(): SelectUnitQueryContext;
    whereClause(): WhereClauseContext;
    groupByClause(): GroupByClauseContext;
    havingClause(): HavingClauseContext;
    orderByClause(): OrderByClauseContext;
    orderSpec(): OrderSpecContext;
    insertQuery(): InsertQueryContext;
    insertBody(): InsertBodyContext;
    joinClause(): JoinClauseContext;
    limitClause(): LimitClauseContext;
    relationReference(): RelationReferenceContext;
    expr(): ExprContext;
    expr(_p: number): ExprContext;
    unitExpr(): UnitExprContext;
    selectColumnClause(): SelectColumnClauseContext;
    value(): ValueContext;
    mathOp(): MathOpContext;
    compareOp(): CompareOpContext;
    logicOp(): LogicOpContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expr_sempred;
    private static readonly _serializedATNSegments;
    private static readonly _serializedATNSegment0;
    private static readonly _serializedATNSegment1;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static readonly _ATN: ATN;
}
export declare class QueriesContext extends ParserRuleContext {
    viewStmt(): ViewStmtContext[];
    viewStmt(i: number): ViewStmtContext;
    programStmt(): ProgramStmtContext[];
    programStmt(i: number): ProgramStmtContext;
    templateStmt(): TemplateStmtContext[];
    templateStmt(i: number): TemplateStmtContext;
    insertQuery(): InsertQueryContext[];
    insertQuery(i: number): InsertQueryContext;
    originalTableStmt(): OriginalTableStmtContext[];
    originalTableStmt(i: number): OriginalTableStmtContext;
    registerTypeUdf(): RegisterTypeUdfContext[];
    registerTypeUdf(i: number): RegisterTypeUdfContext;
    dropQuery(): DropQueryContext[];
    dropQuery(i: number): DropQueryContext;
    deleteStmt(): DeleteStmtContext[];
    deleteStmt(i: number): DeleteStmtContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class RegisterTypeUdfContext extends ParserRuleContext {
    REGISTER(): TerminalNode;
    UDF(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    TYPE(): TerminalNode;
    dataType(): DataTypeContext;
    DELIM(): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class TemplateStmtContext extends ParserRuleContext {
    _templateName: Token;
    CREATE(): TerminalNode;
    TEMPLATE(): TerminalNode;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    DELIM(): TerminalNode;
    selectQuery(): SelectQueryContext | undefined;
    joinClause(): JoinClauseContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class DataTypeContext extends ParserRuleContext {
    INT(): TerminalNode | undefined;
    TEXT(): TerminalNode | undefined;
    BOOLEAN(): TerminalNode | undefined;
    DATETIME(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ColumnDefinitionContext extends ParserRuleContext {
    _columnName: Token;
    _singleValue: ValueContext;
    _function: Token;
    dataType(): DataTypeContext;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    columnConstraints(): ColumnConstraintsContext[];
    columnConstraints(i: number): ColumnConstraintsContext;
    DEFAULT(): TerminalNode | undefined;
    value(): ValueContext[];
    value(i: number): ValueContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ConstraintDefinitionContext extends ParserRuleContext {
    _column: Token;
    _table: Token;
    _otherColumn: Token;
    PRIMARY(): TerminalNode | undefined;
    KEY(): TerminalNode | undefined;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    UNIQUE(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    FOREIGN(): TerminalNode | undefined;
    REFERENCES(): TerminalNode | undefined;
    SINGLE(): TerminalNode | undefined;
    LINE(): TerminalNode | undefined;
    CHECK(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class OriginalTableStmtContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode;
    relationDefintion(): RelationDefintionContext;
    DELIM(): TerminalNode;
    CREATE(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    REGISTER(): TerminalNode | undefined;
    EVENT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class RelationDefintionContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: RelationDefintionContext): void;
}
export declare class RelationDefintionCopyContext extends RelationDefintionContext {
    AS(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    constructor(ctx: RelationDefintionContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class RelationDefintionDirectContext extends RelationDefintionContext {
    columnDefinition(): ColumnDefinitionContext[];
    columnDefinition(i: number): ColumnDefinitionContext;
    constraintDefinition(): ConstraintDefinitionContext[];
    constraintDefinition(i: number): ConstraintDefinitionContext;
    constructor(ctx: RelationDefintionContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ConstraintClauseContext extends ParserRuleContext {
    CONSTRAIN(): TerminalNode;
    constraintDefinition(): ConstraintDefinitionContext[];
    constraintDefinition(i: number): ConstraintDefinitionContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ColumnConstraintsContext extends ParserRuleContext {
    UNIQUE(): TerminalNode | undefined;
    PRIMARY(): TerminalNode | undefined;
    KEY(): TerminalNode | undefined;
    NOT(): TerminalNode | undefined;
    NULL(): TerminalNode | undefined;
    AUTOINCREMENT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ViewStmtContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    AS(): TerminalNode;
    selectQuery(): SelectQueryContext;
    DELIM(): TerminalNode;
    OUTPUT(): TerminalNode | undefined;
    TABLE(): TerminalNode | undefined;
    constraintClause(): ConstraintClauseContext | undefined;
    VIEW(): TerminalNode | undefined;
    CACHED(): TerminalNode | undefined;
    EVENT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ProgramStmtContext extends ParserRuleContext {
    CREATE(): TerminalNode;
    PROGRAM(): TerminalNode;
    AFTER(): TerminalNode;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    programBody(): ProgramBodyContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ProgramBodyContext extends ParserRuleContext {
    BEGIN(): TerminalNode;
    END(): TerminalNode;
    aProgram(): AProgramContext[];
    aProgram(i: number): AProgramContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class AProgramContext extends ParserRuleContext {
    insertQuery(): InsertQueryContext | undefined;
    selectQuery(): SelectQueryContext | undefined;
    deleteStmt(): DeleteStmtContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class SelectQueryContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: SelectQueryContext): void;
}
export declare class SelectQueryDirectContext extends SelectQueryContext {
    selectUnitQuery(): SelectUnitQueryContext;
    compositeSelect(): CompositeSelectContext[];
    compositeSelect(i: number): CompositeSelectContext;
    constructor(ctx: SelectQueryContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class SelectQueryTemplateContext extends SelectQueryContext {
    templateQuery(): TemplateQueryContext;
    constructor(ctx: SelectQueryContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class TemplateQueryContext extends ParserRuleContext {
    _templateName: Token;
    USE(): TerminalNode;
    TEMPLATE(): TerminalNode;
    variableAssignment(): VariableAssignmentContext[];
    variableAssignment(i: number): VariableAssignmentContext;
    IDENTIFIER(): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class DropQueryContext extends ParserRuleContext {
    DROP(): TerminalNode;
    TABLE(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class DeleteStmtContext extends ParserRuleContext {
    DELETE(): TerminalNode;
    FROM(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    WHERE(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class VariableAssignmentContext extends ParserRuleContext {
    _variable: Token;
    _assignment: Token;
    IDENTIFIER(): TerminalNode;
    STRING(): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class CompositeSelectContext extends ParserRuleContext {
    setOp(): SetOpContext;
    selectUnitQuery(): SelectUnitQueryContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class SetOpContext extends ParserRuleContext {
    UNION(): TerminalNode | undefined;
    INTERSECT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class SelectUnitQueryContext extends ParserRuleContext {
    SELECT(): TerminalNode;
    selectColumnClause(): SelectColumnClauseContext[];
    selectColumnClause(i: number): SelectColumnClauseContext;
    DISTINCT(): TerminalNode | undefined;
    FROM(): TerminalNode | undefined;
    relationReference(): RelationReferenceContext | undefined;
    joinClause(): JoinClauseContext[];
    joinClause(i: number): JoinClauseContext;
    whereClause(): WhereClauseContext | undefined;
    groupByClause(): GroupByClauseContext | undefined;
    orderByClause(): OrderByClauseContext | undefined;
    limitClause(): LimitClauseContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class WhereClauseContext extends ParserRuleContext {
    WHERE(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class GroupByClauseContext extends ParserRuleContext {
    GROUP(): TerminalNode;
    BY(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    havingClause(): HavingClauseContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class HavingClauseContext extends ParserRuleContext {
    HAVING(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class OrderByClauseContext extends ParserRuleContext {
    ORDER(): TerminalNode;
    BY(): TerminalNode;
    orderSpec(): OrderSpecContext[];
    orderSpec(i: number): OrderSpecContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class OrderSpecContext extends ParserRuleContext {
    expr(): ExprContext;
    ASC(): TerminalNode | undefined;
    DESC(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class InsertQueryContext extends ParserRuleContext {
    _relation: Token;
    _column: Token;
    INSERT(): TerminalNode;
    INTO(): TerminalNode;
    insertBody(): InsertBodyContext;
    DELIM(): TerminalNode;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class InsertBodyContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: InsertBodyContext): void;
}
export declare class InsertBodyDirectContext extends InsertBodyContext {
    VALUES(): TerminalNode;
    value(): ValueContext[];
    value(i: number): ValueContext;
    constructor(ctx: InsertBodyContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class InsertBodySelectContext extends InsertBodyContext {
    selectQuery(): SelectQueryContext;
    constructor(ctx: InsertBodyContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class JoinClauseContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: JoinClauseContext): void;
}
export declare class JoinClauseTemplateContext extends JoinClauseContext {
    templateQuery(): TemplateQueryContext;
    constructor(ctx: JoinClauseContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class JoinClauseBasicContext extends JoinClauseContext {
    relationReference(): RelationReferenceContext;
    ON(): TerminalNode | undefined;
    expr(): ExprContext | undefined;
    JOIN(): TerminalNode | undefined;
    NATURAL(): TerminalNode | undefined;
    LEFT(): TerminalNode | undefined;
    OUTER(): TerminalNode | undefined;
    constructor(ctx: JoinClauseContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class LimitClauseContext extends ParserRuleContext {
    LIMIT(): TerminalNode;
    expr(): ExprContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class RelationReferenceContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: RelationReferenceContext): void;
}
export declare class RelationReferenceSubQueryContext extends RelationReferenceContext {
    _alias: Token;
    selectQuery(): SelectQueryContext;
    IDENTIFIER(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    constructor(ctx: RelationReferenceContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class RelationReferenceSimpleContext extends RelationReferenceContext {
    _relation: Token;
    _alias: Token;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    LATEST(): TerminalNode | undefined;
    AS(): TerminalNode | undefined;
    constructor(ctx: RelationReferenceContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: ExprContext): void;
}
export declare class ExprNullContext extends ExprContext {
    expr(): ExprContext;
    IS(): TerminalNode;
    NULL(): TerminalNode;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprNotNullContext extends ExprContext {
    expr(): ExprContext;
    NOT(): TerminalNode;
    NULL(): TerminalNode;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprBinOpContext extends ExprContext {
    _lhs: ExprContext;
    _rhs: ExprContext;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    mathOp(): MathOpContext | undefined;
    compareOp(): CompareOpContext | undefined;
    logicOp(): LogicOpContext | undefined;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprExistContext extends ExprContext {
    EXIST(): TerminalNode;
    expr(): ExprContext;
    NOT(): TerminalNode | undefined;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprSimpleContext extends ExprContext {
    unitExpr(): UnitExprContext;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprFunctionContext extends ExprContext {
    _function: Token;
    DATETIME(): TerminalNode | undefined;
    IDENTIFIER(): TerminalNode | undefined;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprInContext extends ExprContext {
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    IN(): TerminalNode;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprConcatContext extends ExprContext {
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    PIPE(): TerminalNode[];
    PIPE(i: number): TerminalNode;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprNegateContext extends ExprContext {
    NOT(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprParenthesisContext extends ExprContext {
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ExprWhenContext extends ExprContext {
    _cond: ExprContext;
    _thenValue: ExprContext;
    _elseValue: ExprContext;
    CASE(): TerminalNode;
    WHEN(): TerminalNode;
    THEN(): TerminalNode;
    ELSE(): TerminalNode;
    END(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    constructor(ctx: ExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class UnitExprContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: UnitExprContext): void;
}
export declare class UnitExprColumnContext extends UnitExprContext {
    _relation: Token;
    _column: Token;
    STAR(): TerminalNode | undefined;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    constructor(ctx: UnitExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class UnitExprSubQueryContext extends UnitExprContext {
    selectQuery(): SelectQueryContext;
    constructor(ctx: UnitExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class UnitExprValueContext extends UnitExprContext {
    value(): ValueContext;
    constructor(ctx: UnitExprContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class SelectColumnClauseContext extends ParserRuleContext {
    expr(): ExprContext;
    AS(): TerminalNode | undefined;
    IDENTIFIER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ValueContext extends ParserRuleContext {
    constructor();
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    copyFrom(ctx: ValueContext): void;
}
export declare class ValueBooleanContext extends ValueContext {
    BOOLEANVAL(): TerminalNode;
    constructor(ctx: ValueContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ValueNumberContext extends ValueContext {
    NUMBER(): TerminalNode;
    constructor(ctx: ValueContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class ValueStringContext extends ValueContext {
    STRING(): TerminalNode;
    constructor(ctx: ValueContext);
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class MathOpContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class CompareOpContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
export declare class LogicOpContext extends ParserRuleContext {
    AND(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    accept<Result>(visitor: DIELVisitor<Result>): Result;
}
//# sourceMappingURL=DIELParser.d.ts.map