import { ATN } from "antlr4ts/atn/ATN";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
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 { BattleScriptListener } from "./BattleScriptListener";
import { BattleScriptVisitor } from "./BattleScriptVisitor";
export declare class BattleScriptParser extends Parser {
    static readonly DEBUGGER = 1;
    static readonly EXTERNAL = 2;
    static readonly NATIVE = 3;
    static readonly PURE = 4;
    static readonly DECLARE = 5;
    static readonly IMPORT = 6;
    static readonly INCLUDE = 7;
    static readonly EXPORT = 8;
    static readonly USE = 9;
    static readonly FROM = 10;
    static readonly NAMESPACE = 11;
    static readonly PROGRAM = 12;
    static readonly EXPOSE = 13;
    static readonly GROUP = 14;
    static readonly DEFAULT = 15;
    static readonly SWITCH = 16;
    static readonly FUNCTION = 17;
    static readonly INTERFACE = 18;
    static readonly EXTENDS = 19;
    static readonly STATE = 20;
    static readonly MODULE = 21;
    static readonly EVENT = 22;
    static readonly IF = 23;
    static readonly ELSE = 24;
    static readonly RETURN = 25;
    static readonly EVERY = 26;
    static readonly LIMIT = 27;
    static readonly AFTER = 28;
    static readonly CANCEL = 29;
    static readonly FOR = 30;
    static readonly EVALUATE = 31;
    static readonly CASE = 32;
    static readonly BREAK = 33;
    static readonly CONTINUE = 34;
    static readonly FALLBACK = 35;
    static readonly CATCH = 36;
    static readonly AS = 37;
    static readonly ENUM = 38;
    static readonly ANY = 39;
    static readonly PROTOCOL = 40;
    static readonly DEFINE = 41;
    static readonly REQUIRE = 42;
    static readonly TERMINATE = 43;
    static readonly STEP = 44;
    static readonly DECODE = 45;
    static readonly ENCODE = 46;
    static readonly END = 47;
    static readonly FORWARD = 48;
    static readonly REWIND = 49;
    static readonly OFFSET = 50;
    static readonly XOR = 51;
    static readonly XNOR = 52;
    static readonly BITS = 53;
    static readonly BYTES = 54;
    static readonly RULE = 55;
    static readonly PARITY = 56;
    static readonly CONST = 57;
    static readonly TYPE_OBJECT = 58;
    static readonly TYPE_ARRAY = 59;
    static readonly TYPE_STRING = 60;
    static readonly TYPE_INT = 61;
    static readonly TYPE_UINT = 62;
    static readonly TYPE_FLOAT = 63;
    static readonly TYPE_DOUBLE = 64;
    static readonly TYPE_BOOLEAN = 65;
    static readonly TYPE_NULL = 66;
    static readonly TYPE_VOID = 67;
    static readonly TYPE_UNDEFINED = 68;
    static readonly NUMBER = 69;
    static readonly BOOLEAN = 70;
    static readonly STRING = 71;
    static readonly COMMENT = 72;
    static readonly ARROW_OPERATOR = 73;
    static readonly INCREMENT = 74;
    static readonly DECREMENT = 75;
    static readonly PLUS = 76;
    static readonly MINUS = 77;
    static readonly DIVIDE = 78;
    static readonly MULTIPLY = 79;
    static readonly REMAINDER = 80;
    static readonly QUESTION_MARK = 81;
    static readonly ASSIGN = 82;
    static readonly PLUS_ASSIGN = 83;
    static readonly MINUS_ASSIGN = 84;
    static readonly AND = 85;
    static readonly OR = 86;
    static readonly NOT = 87;
    static readonly EQUALS = 88;
    static readonly NOT_EQUALS = 89;
    static readonly GT = 90;
    static readonly LT = 91;
    static readonly GTE = 92;
    static readonly LTE = 93;
    static readonly REST = 94;
    static readonly PERIOD = 95;
    static readonly COMMA = 96;
    static readonly WILDCARD = 97;
    static readonly PARENS_START = 98;
    static readonly PARENS_END = 99;
    static readonly BRACES_START = 100;
    static readonly BRACES_END = 101;
    static readonly BRACKETS_START = 102;
    static readonly BRACKETS_END = 103;
    static readonly DOUBLE_COLON = 104;
    static readonly SEMI_COLON = 105;
    static readonly COLON = 106;
    static readonly IDENTIFIER = 107;
    static readonly WS = 108;
    static readonly RULE_root = 0;
    static readonly RULE_importDeclaration = 1;
    static readonly RULE_includeStatement = 2;
    static readonly RULE_importNative = 3;
    static readonly RULE_importExternal = 4;
    static readonly RULE_importSpecifier = 5;
    static readonly RULE_programDeclaration = 6;
    static readonly RULE_programProperty = 7;
    static readonly RULE_exposeDeclaration = 8;
    static readonly RULE_groupDeclaration = 9;
    static readonly RULE_configProperty = 10;
    static readonly RULE_configPropertyBody = 11;
    static readonly RULE_rootBody = 12;
    static readonly RULE_interfaceDeclaration = 13;
    static readonly RULE_interfaceProperty = 14;
    static readonly RULE_statement = 15;
    static readonly RULE_exportStatement = 16;
    static readonly RULE_exportNamed = 17;
    static readonly RULE_exportSpecifier = 18;
    static readonly RULE_exportInline = 19;
    static readonly RULE_exportReexport = 20;
    static readonly RULE_expressionStatement = 21;
    static readonly RULE_namespacedIdentifier = 22;
    static readonly RULE_expression = 23;
    static readonly RULE_primaryExpression = 24;
    static readonly RULE_stateDeclaration = 25;
    static readonly RULE_stateBody = 26;
    static readonly RULE_stateModuleDeclaration = 27;
    static readonly RULE_stateModuleBody = 28;
    static readonly RULE_stateModuleEventDeclaration = 29;
    static readonly RULE_afterDeclaration = 30;
    static readonly RULE_everyDeclaration = 31;
    static readonly RULE_limitClause = 32;
    static readonly RULE_cancelStatement = 33;
    static readonly RULE_breakStatement = 34;
    static readonly RULE_continueStatement = 35;
    static readonly RULE_functionNameIdentifier = 36;
    static readonly RULE_functionDeclaration = 37;
    static readonly RULE_functionDefinition = 38;
    static readonly RULE_functionParameters = 39;
    static readonly RULE_functionParameter = 40;
    static readonly RULE_assignmentPattern = 41;
    static readonly RULE_restElement = 42;
    static readonly RULE_ifStatement = 43;
    static readonly RULE_elseStatement = 44;
    static readonly RULE_elseIfStatement = 45;
    static readonly RULE_variableDeclaration = 46;
    static readonly RULE_variableDeclarator = 47;
    static readonly RULE_variableDeclaratorWithInit = 48;
    static readonly RULE_catchStatement = 49;
    static readonly RULE_catchAsStatement = 50;
    static readonly RULE_comment = 51;
    static readonly RULE_returnStatement = 52;
    static readonly RULE_forStatement = 53;
    static readonly RULE_evaluateCase = 54;
    static readonly RULE_evaluateCaseTest = 55;
    static readonly RULE_wildcard = 56;
    static readonly RULE_evaluateFallback = 57;
    static readonly RULE_evaluateBranch = 58;
    static readonly RULE_evaluateArguments = 59;
    static readonly RULE_evaluateStatement = 60;
    static readonly RULE_callArguments = 61;
    static readonly RULE_protocolDeclaration = 62;
    static readonly RULE_protocolComparator = 63;
    static readonly RULE_defineStatement = 64;
    static readonly RULE_requireStatement = 65;
    static readonly RULE_terminateFlag = 66;
    static readonly RULE_protocolOpStatement = 67;
    static readonly RULE_booleanOp = 68;
    static readonly RULE_forwardStatement = 69;
    static readonly RULE_offsetStatement = 70;
    static readonly RULE_rewindStatement = 71;
    static readonly RULE_stepDeclaration = 72;
    static readonly RULE_protocolPhase = 73;
    static readonly RULE_parityDeclaration = 74;
    static readonly RULE_ruleStatement = 75;
    static readonly RULE_protocolBody = 76;
    static readonly RULE_stepBody = 77;
    static readonly RULE_endStatement = 78;
    static readonly RULE_enumDeclaration = 79;
    static readonly RULE_enumBody = 80;
    static readonly RULE_enumAssignment = 81;
    static readonly RULE_token = 82;
    static readonly RULE_debuggerStatement = 83;
    static readonly RULE_blockStatement = 84;
    static readonly RULE_literal = 85;
    static readonly RULE_valueInternal = 86;
    static readonly RULE_lineEnd = 87;
    static readonly RULE_customType = 88;
    static readonly RULE_dataType = 89;
    static readonly RULE_type = 90;
    static readonly RULE_protocolType = 91;
    static readonly RULE_protocolReadType = 92;
    static readonly RULE_arrayExpressionInternal = 93;
    static readonly RULE_objectExpressionInternal = 94;
    static readonly RULE_objectProperty = 95;
    static readonly RULE_stringLiteral = 96;
    static readonly RULE_numberLiteral = 97;
    static readonly RULE_booleanLiteral = 98;
    static readonly RULE_nullLiteral = 99;
    static readonly RULE_undefinedLiteral = 100;
    static readonly RULE_identifier = 101;
    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);
    root(): RootContext;
    importDeclaration(): ImportDeclarationContext;
    includeStatement(): IncludeStatementContext;
    importNative(): ImportNativeContext;
    importExternal(): ImportExternalContext;
    importSpecifier(): ImportSpecifierContext;
    programDeclaration(): ProgramDeclarationContext;
    programProperty(): ProgramPropertyContext;
    exposeDeclaration(): ExposeDeclarationContext;
    groupDeclaration(): GroupDeclarationContext;
    configProperty(): ConfigPropertyContext;
    configPropertyBody(): ConfigPropertyBodyContext;
    rootBody(): RootBodyContext;
    interfaceDeclaration(): InterfaceDeclarationContext;
    interfaceProperty(): InterfacePropertyContext;
    statement(): StatementContext;
    exportStatement(): ExportStatementContext;
    exportNamed(): ExportNamedContext;
    exportSpecifier(): ExportSpecifierContext;
    exportInline(): ExportInlineContext;
    exportReexport(): ExportReexportContext;
    expressionStatement(): ExpressionStatementContext;
    namespacedIdentifier(): NamespacedIdentifierContext;
    expression(): ExpressionContext;
    expression(_p: number): ExpressionContext;
    primaryExpression(): PrimaryExpressionContext;
    stateDeclaration(): StateDeclarationContext;
    stateBody(): StateBodyContext;
    stateModuleDeclaration(): StateModuleDeclarationContext;
    stateModuleBody(): StateModuleBodyContext;
    stateModuleEventDeclaration(): StateModuleEventDeclarationContext;
    afterDeclaration(): AfterDeclarationContext;
    everyDeclaration(): EveryDeclarationContext;
    limitClause(): LimitClauseContext;
    cancelStatement(): CancelStatementContext;
    breakStatement(): BreakStatementContext;
    continueStatement(): ContinueStatementContext;
    functionNameIdentifier(): FunctionNameIdentifierContext;
    functionDeclaration(): FunctionDeclarationContext;
    functionDefinition(): FunctionDefinitionContext;
    functionParameters(): FunctionParametersContext;
    functionParameter(): FunctionParameterContext;
    assignmentPattern(): AssignmentPatternContext;
    restElement(): RestElementContext;
    ifStatement(): IfStatementContext;
    elseStatement(): ElseStatementContext;
    elseIfStatement(): ElseIfStatementContext;
    variableDeclaration(): VariableDeclarationContext;
    variableDeclarator(): VariableDeclaratorContext;
    variableDeclaratorWithInit(): VariableDeclaratorWithInitContext;
    catchStatement(): CatchStatementContext;
    catchAsStatement(): CatchAsStatementContext;
    comment(): CommentContext;
    returnStatement(): ReturnStatementContext;
    forStatement(): ForStatementContext;
    evaluateCase(): EvaluateCaseContext;
    evaluateCaseTest(): EvaluateCaseTestContext;
    wildcard(): WildcardContext;
    evaluateFallback(): EvaluateFallbackContext;
    evaluateBranch(): EvaluateBranchContext;
    evaluateArguments(): EvaluateArgumentsContext;
    evaluateStatement(): EvaluateStatementContext;
    callArguments(): CallArgumentsContext;
    protocolDeclaration(): ProtocolDeclarationContext;
    protocolComparator(): ProtocolComparatorContext;
    defineStatement(): DefineStatementContext;
    requireStatement(): RequireStatementContext;
    terminateFlag(): TerminateFlagContext;
    protocolOpStatement(): ProtocolOpStatementContext;
    booleanOp(): BooleanOpContext;
    forwardStatement(): ForwardStatementContext;
    offsetStatement(): OffsetStatementContext;
    rewindStatement(): RewindStatementContext;
    stepDeclaration(): StepDeclarationContext;
    protocolPhase(): ProtocolPhaseContext;
    parityDeclaration(): ParityDeclarationContext;
    ruleStatement(): RuleStatementContext;
    protocolBody(): ProtocolBodyContext;
    stepBody(): StepBodyContext;
    endStatement(): EndStatementContext;
    enumDeclaration(): EnumDeclarationContext;
    enumBody(): EnumBodyContext;
    enumAssignment(): EnumAssignmentContext;
    token(): TokenContext;
    debuggerStatement(): DebuggerStatementContext;
    blockStatement(): BlockStatementContext;
    literal(): LiteralContext;
    valueInternal(): ValueInternalContext;
    lineEnd(): LineEndContext;
    customType(): CustomTypeContext;
    customType(_p: number): CustomTypeContext;
    dataType(): DataTypeContext;
    dataType(_p: number): DataTypeContext;
    type(): TypeContext;
    protocolType(): ProtocolTypeContext;
    protocolReadType(): ProtocolReadTypeContext;
    arrayExpressionInternal(): ArrayExpressionInternalContext;
    objectExpressionInternal(): ObjectExpressionInternalContext;
    objectProperty(): ObjectPropertyContext;
    stringLiteral(): StringLiteralContext;
    numberLiteral(): NumberLiteralContext;
    booleanLiteral(): BooleanLiteralContext;
    nullLiteral(): NullLiteralContext;
    undefinedLiteral(): UndefinedLiteralContext;
    identifier(): IdentifierContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expression_sempred;
    private customType_sempred;
    private dataType_sempred;
    private static readonly _serializedATNSegments;
    private static readonly _serializedATNSegment0;
    private static readonly _serializedATNSegment1;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class RootContext extends ParserRuleContext {
    EOF(): TerminalNode;
    rootBody(): RootBodyContext[];
    rootBody(i: number): RootBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ImportDeclarationContext extends ParserRuleContext {
    importNative(): ImportNativeContext | undefined;
    importExternal(): ImportExternalContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class IncludeStatementContext extends ParserRuleContext {
    INCLUDE(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ImportNativeContext extends ParserRuleContext {
    IMPORT(): TerminalNode;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    DOUBLE_COLON(): TerminalNode;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ImportExternalContext extends ParserRuleContext {
    IMPORT(): TerminalNode;
    NAMESPACE(): TerminalNode | undefined;
    stringLiteral(): StringLiteralContext;
    lineEnd(): LineEndContext;
    identifier(): IdentifierContext | undefined;
    FROM(): TerminalNode | undefined;
    BRACES_START(): TerminalNode | undefined;
    importSpecifier(): ImportSpecifierContext[];
    importSpecifier(i: number): ImportSpecifierContext;
    BRACES_END(): TerminalNode | undefined;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ImportSpecifierContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProgramDeclarationContext extends ParserRuleContext {
    PROGRAM(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    programProperty(): ProgramPropertyContext[];
    programProperty(i: number): ProgramPropertyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProgramPropertyContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    valueInternal(): ValueInternalContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExposeDeclarationContext extends ParserRuleContext {
    EXPOSE(): TerminalNode;
    identifier(): IdentifierContext;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    groupDeclaration(): GroupDeclarationContext[];
    groupDeclaration(i: number): GroupDeclarationContext;
    configProperty(): ConfigPropertyContext[];
    configProperty(i: number): ConfigPropertyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class GroupDeclarationContext extends ParserRuleContext {
    GROUP(): TerminalNode;
    identifier(): IdentifierContext;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    configPropertyBody(): ConfigPropertyBodyContext[];
    configPropertyBody(i: number): ConfigPropertyBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ConfigPropertyContext extends ParserRuleContext {
    type(): TypeContext;
    identifier(): IdentifierContext;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    lineEnd(): LineEndContext;
    configPropertyBody(): ConfigPropertyBodyContext[];
    configPropertyBody(i: number): ConfigPropertyBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ConfigPropertyBodyContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    COLON(): TerminalNode;
    expression(): ExpressionContext;
    lineEnd(): LineEndContext;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class RootBodyContext extends ParserRuleContext {
    importDeclaration(): ImportDeclarationContext | undefined;
    includeStatement(): IncludeStatementContext | undefined;
    exportStatement(): ExportStatementContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    exposeDeclaration(): ExposeDeclarationContext | undefined;
    programDeclaration(): ProgramDeclarationContext | undefined;
    protocolDeclaration(): ProtocolDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    statement(): StatementContext | undefined;
    stateDeclaration(): StateDeclarationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class InterfaceDeclarationContext extends ParserRuleContext {
    INTERFACE(): TerminalNode;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    EXTENDS(): TerminalNode | undefined;
    interfaceProperty(): InterfacePropertyContext[];
    interfaceProperty(i: number): InterfacePropertyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class InterfacePropertyContext extends ParserRuleContext {
    type(): TypeContext;
    identifier(): IdentifierContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StatementContext extends ParserRuleContext {
    ifStatement(): IfStatementContext | undefined;
    variableDeclaration(): VariableDeclarationContext | undefined;
    functionDeclaration(): FunctionDeclarationContext | undefined;
    functionDefinition(): FunctionDefinitionContext | undefined;
    afterDeclaration(): AfterDeclarationContext | undefined;
    everyDeclaration(): EveryDeclarationContext | undefined;
    cancelStatement(): CancelStatementContext | undefined;
    breakStatement(): BreakStatementContext | undefined;
    continueStatement(): ContinueStatementContext | undefined;
    expressionStatement(): ExpressionStatementContext | undefined;
    returnStatement(): ReturnStatementContext | undefined;
    catchAsStatement(): CatchAsStatementContext | undefined;
    catchStatement(): CatchStatementContext | undefined;
    forStatement(): ForStatementContext | undefined;
    evaluateStatement(): EvaluateStatementContext | undefined;
    debuggerStatement(): DebuggerStatementContext | undefined;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExportStatementContext extends ParserRuleContext {
    exportNamed(): ExportNamedContext | undefined;
    exportInline(): ExportInlineContext | undefined;
    exportReexport(): ExportReexportContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExportNamedContext extends ParserRuleContext {
    EXPORT(): TerminalNode;
    BRACES_START(): TerminalNode;
    exportSpecifier(): ExportSpecifierContext[];
    exportSpecifier(i: number): ExportSpecifierContext;
    BRACES_END(): TerminalNode;
    lineEnd(): LineEndContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExportSpecifierContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    AS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExportInlineContext extends ParserRuleContext {
    EXPORT(): TerminalNode;
    variableDeclaration(): VariableDeclarationContext | undefined;
    functionDefinition(): FunctionDefinitionContext | undefined;
    functionDeclaration(): FunctionDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    stateDeclaration(): StateDeclarationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExportReexportContext extends ParserRuleContext {
    EXPORT(): TerminalNode;
    BRACES_START(): TerminalNode;
    exportSpecifier(): ExportSpecifierContext[];
    exportSpecifier(i: number): ExportSpecifierContext;
    BRACES_END(): TerminalNode;
    FROM(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    lineEnd(): LineEndContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExpressionStatementContext extends ParserRuleContext {
    expression(): ExpressionContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class NamespacedIdentifierContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    DOUBLE_COLON(): TerminalNode;
    PERIOD(): TerminalNode[];
    PERIOD(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ExpressionContext): void;
}
export declare class ValueContext extends ExpressionContext {
    valueInternal(): ValueInternalContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class NonComputedMemberExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    PERIOD(): TerminalNode;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class NamespacedMemberExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    DOUBLE_COLON(): TerminalNode;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ComputedMemberExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    BRACKETS_START(): TerminalNode;
    BRACKETS_END(): TerminalNode;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CallExpressionContext extends ExpressionContext {
    expression(): ExpressionContext;
    callArguments(): CallArgumentsContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class UpdateExpressionContext extends ExpressionContext {
    expression(): ExpressionContext;
    INCREMENT(): TerminalNode | undefined;
    DECREMENT(): TerminalNode | undefined;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class BinaryExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    MULTIPLY(): TerminalNode | undefined;
    DIVIDE(): TerminalNode | undefined;
    REMAINDER(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    GT(): TerminalNode | undefined;
    GTE(): TerminalNode | undefined;
    LT(): TerminalNode | undefined;
    LTE(): TerminalNode | undefined;
    EQUALS(): TerminalNode | undefined;
    NOT_EQUALS(): TerminalNode | undefined;
    OR(): TerminalNode | undefined;
    AND(): TerminalNode | undefined;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class UnaryExpressionContext extends ExpressionContext {
    expression(): ExpressionContext;
    NOT(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class AssignmentExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    ASSIGN(): TerminalNode | undefined;
    PLUS_ASSIGN(): TerminalNode | undefined;
    MINUS_ASSIGN(): TerminalNode | undefined;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ObjectExpressionContext extends ExpressionContext {
    objectExpressionInternal(): ObjectExpressionInternalContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ArrayExpressionContext extends ExpressionContext {
    arrayExpressionInternal(): ArrayExpressionInternalContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class AfterExpressionContext extends ExpressionContext {
    AFTER(): TerminalNode;
    expression(): ExpressionContext;
    blockStatement(): BlockStatementContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EveryExpressionContext extends ExpressionContext {
    EVERY(): TerminalNode;
    expression(): ExpressionContext;
    blockStatement(): BlockStatementContext;
    limitClause(): LimitClauseContext | undefined;
    constructor(ctx: ExpressionContext);
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class PrimaryExpressionContext extends ParserRuleContext {
    identifier(): IdentifierContext | undefined;
    PARENS_START(): TerminalNode | undefined;
    expression(): ExpressionContext | undefined;
    PARENS_END(): TerminalNode | undefined;
    objectExpressionInternal(): ObjectExpressionInternalContext | undefined;
    arrayExpressionInternal(): ArrayExpressionInternalContext | undefined;
    literal(): LiteralContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StateDeclarationContext extends ParserRuleContext {
    STATE(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    expression(): ExpressionContext | undefined;
    wildcard(): WildcardContext | undefined;
    stateBody(): StateBodyContext[];
    stateBody(i: number): StateBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StateBodyContext extends ParserRuleContext {
    statement(): StatementContext | undefined;
    stateModuleDeclaration(): StateModuleDeclarationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StateModuleDeclarationContext extends ParserRuleContext {
    MODULE(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    expression(): ExpressionContext | undefined;
    wildcard(): WildcardContext | undefined;
    stateModuleBody(): StateModuleBodyContext[];
    stateModuleBody(i: number): StateModuleBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StateModuleBodyContext extends ParserRuleContext {
    statement(): StatementContext | undefined;
    stateModuleEventDeclaration(): StateModuleEventDeclarationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StateModuleEventDeclarationContext extends ParserRuleContext {
    EVENT(): TerminalNode;
    functionParameters(): FunctionParametersContext;
    ARROW_OPERATOR(): TerminalNode;
    blockStatement(): BlockStatementContext;
    expression(): ExpressionContext | undefined;
    wildcard(): WildcardContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class AfterDeclarationContext extends ParserRuleContext {
    AFTER(): TerminalNode;
    expression(): ExpressionContext;
    blockStatement(): BlockStatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EveryDeclarationContext extends ParserRuleContext {
    EVERY(): TerminalNode;
    expression(): ExpressionContext;
    blockStatement(): BlockStatementContext;
    limitClause(): LimitClauseContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class LimitClauseContext extends ParserRuleContext {
    LIMIT(): TerminalNode;
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CancelStatementContext extends ParserRuleContext {
    CANCEL(): TerminalNode;
    lineEnd(): LineEndContext;
    token(): TokenContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class BreakStatementContext extends ParserRuleContext {
    BREAK(): TerminalNode;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ContinueStatementContext extends ParserRuleContext {
    CONTINUE(): TerminalNode;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class FunctionNameIdentifierContext extends ParserRuleContext {
    namespacedIdentifier(): NamespacedIdentifierContext | undefined;
    identifier(): IdentifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class FunctionDeclarationContext extends ParserRuleContext {
    type(): TypeContext;
    functionNameIdentifier(): FunctionNameIdentifierContext;
    functionParameters(): FunctionParametersContext;
    lineEnd(): LineEndContext;
    PURE(): TerminalNode | undefined;
    NATIVE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class FunctionDefinitionContext extends ParserRuleContext {
    type(): TypeContext;
    functionNameIdentifier(): FunctionNameIdentifierContext;
    functionParameters(): FunctionParametersContext;
    ARROW_OPERATOR(): TerminalNode;
    blockStatement(): BlockStatementContext;
    PURE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class FunctionParametersContext extends ParserRuleContext {
    PARENS_START(): TerminalNode;
    PARENS_END(): TerminalNode;
    functionParameter(): FunctionParameterContext[];
    functionParameter(i: number): FunctionParameterContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class FunctionParameterContext extends ParserRuleContext {
    assignmentPattern(): AssignmentPatternContext | undefined;
    type(): TypeContext | undefined;
    identifier(): IdentifierContext | undefined;
    restElement(): RestElementContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class AssignmentPatternContext extends ParserRuleContext {
    type(): TypeContext;
    ASSIGN(): TerminalNode;
    expression(): ExpressionContext;
    identifier(): IdentifierContext | undefined;
    restElement(): RestElementContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class RestElementContext extends ParserRuleContext {
    REST(): TerminalNode;
    identifier(): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class IfStatementContext extends ParserRuleContext {
    IF(): TerminalNode;
    PARENS_START(): TerminalNode;
    expression(): ExpressionContext;
    PARENS_END(): TerminalNode;
    blockStatement(): BlockStatementContext;
    elseStatement(): ElseStatementContext | undefined;
    elseIfStatement(): ElseIfStatementContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ElseStatementContext extends ParserRuleContext {
    ELSE(): TerminalNode;
    blockStatement(): BlockStatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ElseIfStatementContext extends ParserRuleContext {
    ELSE(): TerminalNode;
    ifStatement(): IfStatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class VariableDeclarationContext extends ParserRuleContext {
    variableDeclarator(): VariableDeclaratorContext[];
    variableDeclarator(i: number): VariableDeclaratorContext;
    lineEnd(): LineEndContext;
    CONST(): TerminalNode | undefined;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class VariableDeclaratorContext extends ParserRuleContext {
    type(): TypeContext;
    identifier(): IdentifierContext;
    ASSIGN(): TerminalNode | undefined;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class VariableDeclaratorWithInitContext extends ParserRuleContext {
    type(): TypeContext;
    identifier(): IdentifierContext;
    ASSIGN(): TerminalNode;
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CatchStatementContext extends ParserRuleContext {
    CATCH(): TerminalNode;
    identifier(): IdentifierContext;
    blockStatement(): BlockStatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CatchAsStatementContext extends ParserRuleContext {
    CATCH(): TerminalNode;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    AS(): TerminalNode;
    blockStatement(): BlockStatementContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CommentContext extends ParserRuleContext {
    COMMENT(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ReturnStatementContext extends ParserRuleContext {
    RETURN(): TerminalNode;
    lineEnd(): LineEndContext;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ForStatementContext extends ParserRuleContext {
    FOR(): TerminalNode;
    PARENS_START(): TerminalNode;
    variableDeclaratorWithInit(): VariableDeclaratorWithInitContext;
    SEMI_COLON(): TerminalNode[];
    SEMI_COLON(i: number): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    PARENS_END(): TerminalNode;
    blockStatement(): BlockStatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EvaluateCaseContext extends ParserRuleContext {
    CASE(): TerminalNode;
    PARENS_START(): TerminalNode;
    PARENS_END(): TerminalNode;
    ARROW_OPERATOR(): TerminalNode;
    blockStatement(): BlockStatementContext;
    lineEnd(): LineEndContext;
    evaluateCaseTest(): EvaluateCaseTestContext[];
    evaluateCaseTest(i: number): EvaluateCaseTestContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EvaluateCaseTestContext extends ParserRuleContext {
    wildcard(): WildcardContext | undefined;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class WildcardContext extends ParserRuleContext {
    WILDCARD(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EvaluateFallbackContext extends ParserRuleContext {
    FALLBACK(): TerminalNode;
    blockStatement(): BlockStatementContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EvaluateBranchContext extends ParserRuleContext {
    evaluateCase(): EvaluateCaseContext | undefined;
    evaluateFallback(): EvaluateFallbackContext | undefined;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EvaluateArgumentsContext extends ParserRuleContext {
    PARENS_START(): TerminalNode;
    PARENS_END(): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EvaluateStatementContext extends ParserRuleContext {
    EVALUATE(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    lineEnd(): LineEndContext;
    evaluateArguments(): EvaluateArgumentsContext | undefined;
    evaluateBranch(): EvaluateBranchContext[];
    evaluateBranch(i: number): EvaluateBranchContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CallArgumentsContext extends ParserRuleContext {
    PARENS_START(): TerminalNode;
    PARENS_END(): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolDeclarationContext extends ParserRuleContext {
    PROTOCOL(): TerminalNode;
    stringLiteral(): StringLiteralContext[];
    stringLiteral(i: number): StringLiteralContext;
    FOR(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    protocolBody(): ProtocolBodyContext[];
    protocolBody(i: number): ProtocolBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolComparatorContext extends ParserRuleContext {
    EQUALS(): TerminalNode | undefined;
    NOT_EQUALS(): TerminalNode | undefined;
    identifier(): IdentifierContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class DefineStatementContext extends ParserRuleContext {
    DEFINE(): TerminalNode;
    protocolType(): ProtocolTypeContext;
    stringLiteral(): StringLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class RequireStatementContext extends ParserRuleContext {
    REQUIRE(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    protocolComparator(): ProtocolComparatorContext;
    expression(): ExpressionContext;
    lineEnd(): LineEndContext;
    terminateFlag(): TerminateFlagContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class TerminateFlagContext extends ParserRuleContext {
    TERMINATE(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolOpStatementContext extends ParserRuleContext {
    booleanOp(): BooleanOpContext;
    protocolReadType(): ProtocolReadTypeContext;
    stringLiteral(): StringLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class BooleanOpContext extends ParserRuleContext {
    XOR(): TerminalNode | undefined;
    XNOR(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ForwardStatementContext extends ParserRuleContext {
    FORWARD(): TerminalNode;
    numberLiteral(): NumberLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class OffsetStatementContext extends ParserRuleContext {
    OFFSET(): TerminalNode;
    numberLiteral(): NumberLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class RewindStatementContext extends ParserRuleContext {
    REWIND(): TerminalNode;
    numberLiteral(): NumberLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StepDeclarationContext extends ParserRuleContext {
    STEP(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    protocolPhase(): ProtocolPhaseContext | undefined;
    stepBody(): StepBodyContext[];
    stepBody(i: number): StepBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolPhaseContext extends ParserRuleContext {
    DECODE(): TerminalNode | undefined;
    ENCODE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ParityDeclarationContext extends ParserRuleContext {
    PARITY(): TerminalNode;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    protocolPhase(): ProtocolPhaseContext | undefined;
    stepBody(): StepBodyContext[];
    stepBody(i: number): StepBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class RuleStatementContext extends ParserRuleContext {
    RULE(): TerminalNode;
    protocolType(): ProtocolTypeContext;
    stringLiteral(): StringLiteralContext[];
    stringLiteral(i: number): StringLiteralContext;
    ASSIGN(): TerminalNode;
    protocolComparator(): ProtocolComparatorContext;
    numberLiteral(): NumberLiteralContext[];
    numberLiteral(i: number): NumberLiteralContext;
    QUESTION_MARK(): TerminalNode;
    COLON(): TerminalNode;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolBodyContext extends ParserRuleContext {
    enumDeclaration(): EnumDeclarationContext | undefined;
    defineStatement(): DefineStatementContext | undefined;
    requireStatement(): RequireStatementContext | undefined;
    protocolOpStatement(): ProtocolOpStatementContext | undefined;
    forwardStatement(): ForwardStatementContext | undefined;
    offsetStatement(): OffsetStatementContext | undefined;
    rewindStatement(): RewindStatementContext | undefined;
    parityDeclaration(): ParityDeclarationContext | undefined;
    stepDeclaration(): StepDeclarationContext | undefined;
    ruleStatement(): RuleStatementContext | undefined;
    endStatement(): EndStatementContext | undefined;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StepBodyContext extends ParserRuleContext {
    defineStatement(): DefineStatementContext | undefined;
    requireStatement(): RequireStatementContext | undefined;
    protocolOpStatement(): ProtocolOpStatementContext | undefined;
    forwardStatement(): ForwardStatementContext | undefined;
    offsetStatement(): OffsetStatementContext | undefined;
    rewindStatement(): RewindStatementContext | undefined;
    ruleStatement(): RuleStatementContext | undefined;
    endStatement(): EndStatementContext | undefined;
    statement(): StatementContext | undefined;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EndStatementContext extends ParserRuleContext {
    END(): TerminalNode;
    booleanLiteral(): BooleanLiteralContext;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EnumDeclarationContext extends ParserRuleContext {
    ENUM(): TerminalNode;
    identifier(): IdentifierContext;
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    enumBody(): EnumBodyContext[];
    enumBody(i: number): EnumBodyContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EnumBodyContext extends ParserRuleContext {
    identifier(): IdentifierContext | undefined;
    SEMI_COLON(): TerminalNode | undefined;
    COMMA(): TerminalNode | undefined;
    enumAssignment(): EnumAssignmentContext | undefined;
    comment(): CommentContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class EnumAssignmentContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    ASSIGN(): TerminalNode;
    literal(): LiteralContext;
    SEMI_COLON(): TerminalNode | undefined;
    COMMA(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class TokenContext extends ParserRuleContext {
    identifier(): IdentifierContext | undefined;
    primaryExpression(): PrimaryExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class DebuggerStatementContext extends ParserRuleContext {
    DEBUGGER(): TerminalNode;
    lineEnd(): LineEndContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class BlockStatementContext extends ParserRuleContext {
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    statement(): StatementContext[];
    statement(i: number): StatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    stringLiteral(): StringLiteralContext | undefined;
    numberLiteral(): NumberLiteralContext | undefined;
    booleanLiteral(): BooleanLiteralContext | undefined;
    nullLiteral(): NullLiteralContext | undefined;
    undefinedLiteral(): UndefinedLiteralContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ValueInternalContext extends ParserRuleContext {
    primaryExpression(): PrimaryExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class LineEndContext extends ParserRuleContext {
    SEMI_COLON(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class CustomTypeContext extends ParserRuleContext {
    identifier(): IdentifierContext | undefined;
    customType(): CustomTypeContext | undefined;
    BRACKETS_START(): TerminalNode | undefined;
    BRACKETS_END(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class DataTypeContext extends ParserRuleContext {
    TYPE_OBJECT(): TerminalNode | undefined;
    TYPE_ARRAY(): TerminalNode | undefined;
    TYPE_STRING(): TerminalNode | undefined;
    TYPE_INT(): TerminalNode | undefined;
    TYPE_UINT(): TerminalNode | undefined;
    TYPE_FLOAT(): TerminalNode | undefined;
    TYPE_DOUBLE(): TerminalNode | undefined;
    TYPE_BOOLEAN(): TerminalNode | undefined;
    TYPE_NULL(): TerminalNode | undefined;
    TYPE_UNDEFINED(): TerminalNode | undefined;
    TYPE_VOID(): TerminalNode | undefined;
    ANY(): TerminalNode | undefined;
    dataType(): DataTypeContext | undefined;
    BRACKETS_START(): TerminalNode | undefined;
    BRACKETS_END(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class TypeContext extends ParserRuleContext {
    dataType(): DataTypeContext | undefined;
    customType(): CustomTypeContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolTypeContext extends ParserRuleContext {
    TYPE_UINT(): TerminalNode | undefined;
    LT(): TerminalNode | undefined;
    numberLiteral(): NumberLiteralContext | undefined;
    GT(): TerminalNode | undefined;
    TYPE_INT(): TerminalNode | undefined;
    TYPE_STRING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ProtocolReadTypeContext extends ParserRuleContext {
    BITS(): TerminalNode | undefined;
    LT(): TerminalNode;
    numberLiteral(): NumberLiteralContext;
    GT(): TerminalNode;
    BYTES(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ArrayExpressionInternalContext extends ParserRuleContext {
    BRACKETS_START(): TerminalNode;
    BRACKETS_END(): TerminalNode;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ObjectExpressionInternalContext extends ParserRuleContext {
    BRACES_START(): TerminalNode;
    BRACES_END(): TerminalNode;
    objectProperty(): ObjectPropertyContext[];
    objectProperty(i: number): ObjectPropertyContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class ObjectPropertyContext extends ParserRuleContext {
    COLON(): TerminalNode;
    expression(): ExpressionContext;
    identifier(): IdentifierContext | undefined;
    stringLiteral(): StringLiteralContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class StringLiteralContext extends ParserRuleContext {
    STRING(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class NumberLiteralContext extends ParserRuleContext {
    NUMBER(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class BooleanLiteralContext extends ParserRuleContext {
    BOOLEAN(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class NullLiteralContext extends ParserRuleContext {
    TYPE_NULL(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class UndefinedLiteralContext extends ParserRuleContext {
    TYPE_UNDEFINED(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    PROTOCOL(): TerminalNode | undefined;
    DEFINE(): TerminalNode | undefined;
    REQUIRE(): TerminalNode | undefined;
    TERMINATE(): TerminalNode | undefined;
    STEP(): TerminalNode | undefined;
    DECODE(): TerminalNode | undefined;
    ENCODE(): TerminalNode | undefined;
    END(): TerminalNode | undefined;
    FORWARD(): TerminalNode | undefined;
    REWIND(): TerminalNode | undefined;
    OFFSET(): TerminalNode | undefined;
    XOR(): TerminalNode | undefined;
    XNOR(): TerminalNode | undefined;
    BITS(): TerminalNode | undefined;
    BYTES(): TerminalNode | undefined;
    RULE(): TerminalNode | undefined;
    PARITY(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: BattleScriptListener): void;
    exitRule(listener: BattleScriptListener): void;
    accept<Result>(visitor: BattleScriptVisitor<Result>): Result;
}
//# sourceMappingURL=BattleScriptParser.d.ts.map