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 { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { TBLKParserListener } from "./TBLKParserListener";
import { TBLKParserVisitor } from "./TBLKParserVisitor";
export declare class TBLKParser extends Parser {
    static readonly COMMENT = 1;
    static readonly OPEN = 2;
    static readonly LINE_FEED = 3;
    static readonly TEXT = 4;
    static readonly NOT_END = 5;
    static readonly CLOSE = 6;
    static readonly LOOP_END = 7;
    static readonly IF_END = 8;
    static readonly LET_END = 9;
    static readonly FUNCTION_END = 10;
    static readonly HASH = 11;
    static readonly FILTER = 12;
    static readonly OpenBracket = 13;
    static readonly CloseBracket = 14;
    static readonly OpenParen = 15;
    static readonly CloseParen = 16;
    static readonly Comma = 17;
    static readonly QuestionMark = 18;
    static readonly Colon = 19;
    static readonly Dot = 20;
    static readonly Plus = 21;
    static readonly Minus = 22;
    static readonly BitNot = 23;
    static readonly Not = 24;
    static readonly Multiply = 25;
    static readonly Divide = 26;
    static readonly Modulus = 27;
    static readonly Coalesce = 28;
    static readonly Power = 29;
    static readonly RightShiftArithmetic = 30;
    static readonly LeftShiftArithmetic = 31;
    static readonly RightShiftLogical = 32;
    static readonly LessThan = 33;
    static readonly MoreThan = 34;
    static readonly LessThanEquals = 35;
    static readonly GreaterThanEquals = 36;
    static readonly Equals_ = 37;
    static readonly NotEquals = 38;
    static readonly IdentityEquals = 39;
    static readonly IdentityNotEquals = 40;
    static readonly BitAnd = 41;
    static readonly BitXOr = 42;
    static readonly BitOr = 43;
    static readonly And = 44;
    static readonly Or = 45;
    static readonly Assignment = 46;
    static readonly NullLiteral = 47;
    static readonly BooleanLiteral = 48;
    static readonly DecimalLiteral = 49;
    static readonly HexIntegerLiteral = 50;
    static readonly OctalIntegerLiteral2 = 51;
    static readonly BinaryIntegerLiteral = 52;
    static readonly BigHexIntegerLiteral = 53;
    static readonly BigOctalIntegerLiteral = 54;
    static readonly BigBinaryIntegerLiteral = 55;
    static readonly BigDecimalIntegerLiteral = 56;
    static readonly Break = 57;
    static readonly Do = 58;
    static readonly Instanceof = 59;
    static readonly Typeof = 60;
    static readonly Case = 61;
    static readonly Else = 62;
    static readonly New = 63;
    static readonly Var = 64;
    static readonly Catch = 65;
    static readonly Finally = 66;
    static readonly Return = 67;
    static readonly Void = 68;
    static readonly Continue = 69;
    static readonly For = 70;
    static readonly Switch = 71;
    static readonly While = 72;
    static readonly Debugger = 73;
    static readonly Function = 74;
    static readonly This = 75;
    static readonly With = 76;
    static readonly Default = 77;
    static readonly If = 78;
    static readonly Throw = 79;
    static readonly Delete = 80;
    static readonly In = 81;
    static readonly Try = 82;
    static readonly As = 83;
    static readonly From = 84;
    static readonly Class = 85;
    static readonly Enum = 86;
    static readonly Extends = 87;
    static readonly Super = 88;
    static readonly Const = 89;
    static readonly Export = 90;
    static readonly Import = 91;
    static readonly Async = 92;
    static readonly Await = 93;
    static readonly Implements = 94;
    static readonly Let = 95;
    static readonly Private = 96;
    static readonly Public = 97;
    static readonly Interface = 98;
    static readonly Package = 99;
    static readonly Protected = 100;
    static readonly Static = 101;
    static readonly Yield = 102;
    static readonly Identifier = 103;
    static readonly StringLiteral = 104;
    static readonly WhiteSpaces = 105;
    static readonly LineTerminator = 106;
    static readonly RULE_document = 0;
    static readonly RULE_partial = 1;
    static readonly RULE_row = 2;
    static readonly RULE_segment = 3;
    static readonly RULE_span = 4;
    static readonly RULE_print = 5;
    static readonly RULE_loopBegin = 6;
    static readonly RULE_loopEnd = 7;
    static readonly RULE_loopFilter = 8;
    static readonly RULE_ifBegin = 9;
    static readonly RULE_elseCmd = 10;
    static readonly RULE_elseIfCmd = 11;
    static readonly RULE_ifEnd = 12;
    static readonly RULE_partialBegin = 13;
    static readonly RULE_partialEnd = 14;
    static readonly RULE_partialUse = 15;
    static readonly RULE_assignment = 16;
    static readonly RULE_arguments = 17;
    static readonly RULE_argument = 18;
    static readonly RULE_expressionSequence = 19;
    static readonly RULE_singleExpression = 20;
    static readonly RULE_literal = 21;
    static readonly RULE_numericLiteral = 22;
    static readonly RULE_identifierName = 23;
    static readonly RULE_identifier = 24;
    static readonly RULE_reservedWord = 25;
    static readonly RULE_keyword = 26;
    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;
    constructor(input: TokenStream);
    document(): DocumentContext;
    partial(): PartialContext;
    row(): RowContext;
    segment(): SegmentContext;
    span(): SpanContext;
    print(): PrintContext;
    loopBegin(): LoopBeginContext;
    loopEnd(): LoopEndContext;
    loopFilter(): LoopFilterContext;
    ifBegin(): IfBeginContext;
    elseCmd(): ElseCmdContext;
    elseIfCmd(): ElseIfCmdContext;
    ifEnd(): IfEndContext;
    partialBegin(): PartialBeginContext;
    partialEnd(): PartialEndContext;
    partialUse(): PartialUseContext;
    assignment(): AssignmentContext;
    arguments(): ArgumentsContext;
    argument(): ArgumentContext;
    expressionSequence(): ExpressionSequenceContext;
    singleExpression(): SingleExpressionContext;
    singleExpression(_p: number): SingleExpressionContext;
    literal(): LiteralContext;
    numericLiteral(): NumericLiteralContext;
    identifierName(): IdentifierNameContext;
    identifier(): IdentifierContext;
    reservedWord(): ReservedWordContext;
    keyword(): KeywordContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private singleExpression_sempred;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class DocumentContext extends ParserRuleContext {
    row(): RowContext[];
    row(i: number): RowContext;
    partial(): PartialContext[];
    partial(i: number): PartialContext;
    LINE_FEED(): TerminalNode[];
    LINE_FEED(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class PartialContext extends ParserRuleContext {
    partialBegin(): PartialBeginContext;
    partialEnd(): PartialEndContext;
    LINE_FEED(): TerminalNode[];
    LINE_FEED(i: number): TerminalNode;
    row(): RowContext[];
    row(i: number): RowContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class RowContext extends ParserRuleContext {
    segment(): SegmentContext[];
    segment(i: number): SegmentContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class SegmentContext extends ParserRuleContext {
    span(): SpanContext | undefined;
    print(): PrintContext | undefined;
    loopBegin(): LoopBeginContext | undefined;
    loopEnd(): LoopEndContext | undefined;
    ifBegin(): IfBeginContext | undefined;
    elseCmd(): ElseCmdContext | undefined;
    elseIfCmd(): ElseIfCmdContext | undefined;
    ifEnd(): IfEndContext | undefined;
    partialUse(): PartialUseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class SpanContext extends ParserRuleContext {
    TEXT(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class PrintContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LoopBeginContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    For(): TerminalNode;
    identifier(): IdentifierContext;
    In(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CLOSE(): TerminalNode;
    loopFilter(): LoopFilterContext[];
    loopFilter(i: number): LoopFilterContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LoopEndContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    LOOP_END(): TerminalNode;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LoopFilterContext extends ParserRuleContext {
    FILTER(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class IfBeginContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    If(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ElseCmdContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    Else(): TerminalNode;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ElseIfCmdContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    Else(): TerminalNode;
    If(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class IfEndContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    IF_END(): TerminalNode;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class PartialBeginContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    Function(): TerminalNode;
    identifier(): IdentifierContext;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class PartialEndContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    FUNCTION_END(): TerminalNode;
    CLOSE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class PartialUseContext extends ParserRuleContext {
    OPEN(): TerminalNode;
    HASH(): TerminalNode;
    identifier(): IdentifierContext;
    CLOSE(): TerminalNode;
    assignment(): AssignmentContext[];
    assignment(i: number): AssignmentContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class AssignmentContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    Assignment(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ArgumentsContext extends ParserRuleContext {
    OpenParen(): TerminalNode;
    CloseParen(): TerminalNode;
    argument(): ArgumentContext[];
    argument(i: number): ArgumentContext;
    Comma(): TerminalNode[];
    Comma(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ArgumentContext extends ParserRuleContext {
    singleExpression(): SingleExpressionContext | undefined;
    identifier(): IdentifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ExpressionSequenceContext extends ParserRuleContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Comma(): TerminalNode[];
    Comma(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class SingleExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: SingleExpressionContext): void;
}
export declare class MemberIndexExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext;
    OpenBracket(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CloseBracket(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class MemberDotExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext;
    Dot(): TerminalNode;
    identifierName(): IdentifierNameContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ArgumentsExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext;
    arguments(): ArgumentsContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class TypeofExpressionContext extends SingleExpressionContext {
    Typeof(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class UnaryPlusExpressionContext extends SingleExpressionContext {
    Plus(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class UnaryMinusExpressionContext extends SingleExpressionContext {
    Minus(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class BitNotExpressionContext extends SingleExpressionContext {
    BitNot(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class NotExpressionContext extends SingleExpressionContext {
    Not(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class PowerExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Power(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class MultiplicativeExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Multiply(): TerminalNode | undefined;
    Divide(): TerminalNode | undefined;
    Modulus(): TerminalNode | undefined;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class AdditiveExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Plus(): TerminalNode | undefined;
    Minus(): TerminalNode | undefined;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class CoalesceExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Coalesce(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class BitShiftExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    LeftShiftArithmetic(): TerminalNode | undefined;
    RightShiftArithmetic(): TerminalNode | undefined;
    RightShiftLogical(): TerminalNode | undefined;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class RelationalExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    LessThan(): TerminalNode | undefined;
    MoreThan(): TerminalNode | undefined;
    LessThanEquals(): TerminalNode | undefined;
    GreaterThanEquals(): TerminalNode | undefined;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class InstanceofExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Instanceof(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class InExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    In(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class EqualityExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Equals_(): TerminalNode | undefined;
    NotEquals(): TerminalNode | undefined;
    IdentityEquals(): TerminalNode | undefined;
    IdentityNotEquals(): TerminalNode | undefined;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class BitAndExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    BitAnd(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class BitXOrExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    BitXOr(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class BitOrExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    BitOr(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LogicalAndExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    And(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LogicalOrExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Or(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class TernaryExpressionContext extends SingleExpressionContext {
    singleExpression(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    QuestionMark(): TerminalNode;
    Colon(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class IdentifierExpressionContext extends SingleExpressionContext {
    identifier(): IdentifierContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LiteralExpressionContext extends SingleExpressionContext {
    literal(): LiteralContext;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ParenthesizedExpressionContext extends SingleExpressionContext {
    OpenParen(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CloseParen(): TerminalNode;
    constructor(ctx: SingleExpressionContext);
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    NullLiteral(): TerminalNode | undefined;
    BooleanLiteral(): TerminalNode | undefined;
    StringLiteral(): TerminalNode | undefined;
    numericLiteral(): NumericLiteralContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class NumericLiteralContext extends ParserRuleContext {
    DecimalLiteral(): TerminalNode | undefined;
    HexIntegerLiteral(): TerminalNode | undefined;
    OctalIntegerLiteral2(): TerminalNode | undefined;
    BinaryIntegerLiteral(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class IdentifierNameContext extends ParserRuleContext {
    identifier(): IdentifierContext | undefined;
    reservedWord(): ReservedWordContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    Identifier(): TerminalNode | undefined;
    Let(): TerminalNode | undefined;
    Async(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class ReservedWordContext extends ParserRuleContext {
    keyword(): KeywordContext | undefined;
    NullLiteral(): TerminalNode | undefined;
    BooleanLiteral(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}
export declare class KeywordContext extends ParserRuleContext {
    Break(): TerminalNode | undefined;
    Do(): TerminalNode | undefined;
    Instanceof(): TerminalNode | undefined;
    Typeof(): TerminalNode | undefined;
    Case(): TerminalNode | undefined;
    Else(): TerminalNode | undefined;
    New(): TerminalNode | undefined;
    Var(): TerminalNode | undefined;
    Catch(): TerminalNode | undefined;
    Finally(): TerminalNode | undefined;
    Return(): TerminalNode | undefined;
    Void(): TerminalNode | undefined;
    Continue(): TerminalNode | undefined;
    For(): TerminalNode | undefined;
    Switch(): TerminalNode | undefined;
    While(): TerminalNode | undefined;
    Debugger(): TerminalNode | undefined;
    Function(): TerminalNode | undefined;
    This(): TerminalNode | undefined;
    With(): TerminalNode | undefined;
    Default(): TerminalNode | undefined;
    If(): TerminalNode | undefined;
    Throw(): TerminalNode | undefined;
    Delete(): TerminalNode | undefined;
    In(): TerminalNode | undefined;
    Try(): TerminalNode | undefined;
    Class(): TerminalNode | undefined;
    Enum(): TerminalNode | undefined;
    Extends(): TerminalNode | undefined;
    Super(): TerminalNode | undefined;
    Const(): TerminalNode | undefined;
    Export(): TerminalNode | undefined;
    Import(): TerminalNode | undefined;
    Implements(): TerminalNode | undefined;
    Let(): TerminalNode | undefined;
    Private(): TerminalNode | undefined;
    Public(): TerminalNode | undefined;
    Interface(): TerminalNode | undefined;
    Package(): TerminalNode | undefined;
    Protected(): TerminalNode | undefined;
    Static(): TerminalNode | undefined;
    Yield(): TerminalNode | undefined;
    Async(): TerminalNode | undefined;
    Await(): TerminalNode | undefined;
    From(): TerminalNode | undefined;
    As(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: TBLKParserListener): void;
    exitRule(listener: TBLKParserListener): void;
    accept<Result>(visitor: TBLKParserVisitor<Result>): Result;
}