@irrelon/battlescript 3.1.4

package/dist/services/grammar/ts/language/BattleScriptParser.d.ts

@@ -0,0 +1,1220 @@
+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 EXTERNAL = 1;
+    static readonly NATIVE = 2;
+    static readonly PURE = 3;
+    static readonly DECLARE = 4;
+    static readonly IMPORT = 5;
+    static readonly EXPORT = 6;
+    static readonly USE = 7;
+    static readonly FROM = 8;
+    static readonly NAMESPACE = 9;
+    static readonly DEFINE = 10;
+    static readonly PROGRAM = 11;
+    static readonly EXPOSE = 12;
+    static readonly GROUP = 13;
+    static readonly DEFAULT = 14;
+    static readonly SWITCH = 15;
+    static readonly FUNCTION = 16;
+    static readonly INTERFACE = 17;
+    static readonly EXTENDS = 18;
+    static readonly STATE = 19;
+    static readonly EVENT = 20;
+    static readonly IF = 21;
+    static readonly ELSE = 22;
+    static readonly RETURN = 23;
+    static readonly EVERY = 24;
+    static readonly LIMIT = 25;
+    static readonly AFTER = 26;
+    static readonly CANCEL = 27;
+    static readonly FOR = 28;
+    static readonly EVALUATE = 29;
+    static readonly CASE = 30;
+    static readonly BREAK = 31;
+    static readonly CONTINUE = 32;
+    static readonly FALLBACK = 33;
+    static readonly CATCH = 34;
+    static readonly AS = 35;
+    static readonly CONST = 36;
+    static readonly TYPE_OBJECT = 37;
+    static readonly TYPE_ARRAY = 38;
+    static readonly TYPE_STRING = 39;
+    static readonly TYPE_INT = 40;
+    static readonly TYPE_UINT = 41;
+    static readonly TYPE_FLOAT = 42;
+    static readonly TYPE_DOUBLE = 43;
+    static readonly TYPE_BOOLEAN = 44;
+    static readonly TYPE_NULL = 45;
+    static readonly TYPE_VOID = 46;
+    static readonly TYPE_UNDEFINED = 47;
+    static readonly TYPE_ANY = 48;
+    static readonly NUMBER = 49;
+    static readonly BOOLEAN = 50;
+    static readonly STRING = 51;
+    static readonly COMMENT = 52;
+    static readonly IDENTIFIER = 53;
+    static readonly ARROW_OPERATOR = 54;
+    static readonly INCREMENT = 55;
+    static readonly DECREMENT = 56;
+    static readonly PLUS = 57;
+    static readonly MINUS = 58;
+    static readonly DIVIDE = 59;
+    static readonly MULTIPLY = 60;
+    static readonly REMAINDER = 61;
+    static readonly ASSIGN = 62;
+    static readonly PLUS_ASSIGN = 63;
+    static readonly MINUS_ASSIGN = 64;
+    static readonly AND = 65;
+    static readonly OR = 66;
+    static readonly NOT = 67;
+    static readonly EQUALS = 68;
+    static readonly NOT_EQUALS = 69;
+    static readonly GT = 70;
+    static readonly LT = 71;
+    static readonly GTE = 72;
+    static readonly LTE = 73;
+    static readonly REST = 74;
+    static readonly PERIOD = 75;
+    static readonly COMMA = 76;
+    static readonly WILDCARD = 77;
+    static readonly PARENS_START = 78;
+    static readonly PARENS_END = 79;
+    static readonly BRACES_START = 80;
+    static readonly BRACES_END = 81;
+    static readonly BRACKETS_START = 82;
+    static readonly BRACKETS_END = 83;
+    static readonly DOUBLE_COLON = 84;
+    static readonly SEMI_COLON = 85;
+    static readonly COLON = 86;
+    static readonly WS = 87;
+    static readonly RULE_root = 0;
+    static readonly RULE_importDeclaration = 1;
+    static readonly RULE_importNative = 2;
+    static readonly RULE_importExternal = 3;
+    static readonly RULE_programDeclaration = 4;
+    static readonly RULE_programProperty = 5;
+    static readonly RULE_exposeDeclaration = 6;
+    static readonly RULE_groupDeclaration = 7;
+    static readonly RULE_configProperty = 8;
+    static readonly RULE_configPropertyBody = 9;
+    static readonly RULE_rootBody = 10;
+    static readonly RULE_interfaceDeclaration = 11;
+    static readonly RULE_interfaceProperty = 12;
+    static readonly RULE_statement = 13;
+    static readonly RULE_exportStatement = 14;
+    static readonly RULE_exportNamespace = 15;
+    static readonly RULE_exportIdentifier = 16;
+    static readonly RULE_expressionStatement = 17;
+    static readonly RULE_namespacedIdentifier = 18;
+    static readonly RULE_expression = 19;
+    static readonly RULE_primaryExpression = 20;
+    static readonly RULE_stateDeclaration = 21;
+    static readonly RULE_stateBody = 22;
+    static readonly RULE_eventDeclaration = 23;
+    static readonly RULE_afterDeclaration = 24;
+    static readonly RULE_everyDeclaration = 25;
+    static readonly RULE_limitClause = 26;
+    static readonly RULE_cancelStatement = 27;
+    static readonly RULE_breakStatement = 28;
+    static readonly RULE_continueStatement = 29;
+    static readonly RULE_functionNameIdentifier = 30;
+    static readonly RULE_functionDeclaration = 31;
+    static readonly RULE_functionDefinition = 32;
+    static readonly RULE_functionParameters = 33;
+    static readonly RULE_functionParameter = 34;
+    static readonly RULE_assignmentPattern = 35;
+    static readonly RULE_restElement = 36;
+    static readonly RULE_ifStatement = 37;
+    static readonly RULE_elseStatement = 38;
+    static readonly RULE_elseIfStatement = 39;
+    static readonly RULE_variableDeclaration = 40;
+    static readonly RULE_variableDeclarator = 41;
+    static readonly RULE_variableDeclaratorWithInit = 42;
+    static readonly RULE_catchStatement = 43;
+    static readonly RULE_catchAsStatement = 44;
+    static readonly RULE_comment = 45;
+    static readonly RULE_returnStatement = 46;
+    static readonly RULE_forStatement = 47;
+    static readonly RULE_evaluateCase = 48;
+    static readonly RULE_evaluateCaseTest = 49;
+    static readonly RULE_wildcard = 50;
+    static readonly RULE_evaluateFallback = 51;
+    static readonly RULE_evaluateBranch = 52;
+    static readonly RULE_evaluateArguments = 53;
+    static readonly RULE_evaluateStatement = 54;
+    static readonly RULE_callArguments = 55;
+    static readonly RULE_token = 56;
+    static readonly RULE_blockStatement = 57;
+    static readonly RULE_literal = 58;
+    static readonly RULE_valueInternal = 59;
+    static readonly RULE_lineEnd = 60;
+    static readonly RULE_customType = 61;
+    static readonly RULE_dataType = 62;
+    static readonly RULE_type = 63;
+    static readonly RULE_arrayExpressionInternal = 64;
+    static readonly RULE_objectExpressionInternal = 65;
+    static readonly RULE_objectProperty = 66;
+    static readonly RULE_stringLiteral = 67;
+    static readonly RULE_numberLiteral = 68;
+    static readonly RULE_booleanLiteral = 69;
+    static readonly RULE_nullLiteral = 70;
+    static readonly RULE_undefinedLiteral = 71;
+    static readonly RULE_identifier = 72;
+    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;
+    importNative(): ImportNativeContext;
+    importExternal(): ImportExternalContext;
+    programDeclaration(): ProgramDeclarationContext;
+    programProperty(): ProgramPropertyContext;
+    exposeDeclaration(): ExposeDeclarationContext;
+    groupDeclaration(): GroupDeclarationContext;
+    configProperty(): ConfigPropertyContext;
+    configPropertyBody(): ConfigPropertyBodyContext;
+    rootBody(): RootBodyContext;
+    interfaceDeclaration(): InterfaceDeclarationContext;
+    interfaceProperty(): InterfacePropertyContext;
+    statement(): StatementContext;
+    exportStatement(): ExportStatementContext;
+    exportNamespace(): ExportNamespaceContext;
+    exportIdentifier(): ExportIdentifierContext;
+    expressionStatement(): ExpressionStatementContext;
+    namespacedIdentifier(): NamespacedIdentifierContext;
+    expression(): ExpressionContext;
+    expression(_p: number): ExpressionContext;
+    primaryExpression(): PrimaryExpressionContext;
+    stateDeclaration(): StateDeclarationContext;
+    stateBody(): StateBodyContext;
+    eventDeclaration(): EventDeclarationContext;
+    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;
+    token(): TokenContext;
+    blockStatement(): BlockStatementContext;
+    literal(): LiteralContext;
+    valueInternal(): ValueInternalContext;
+    lineEnd(): LineEndContext;
+    customType(): CustomTypeContext;
+    customType(_p: number): CustomTypeContext;
+    dataType(): DataTypeContext;
+    dataType(_p: number): DataTypeContext;
+    type(): TypeContext;
+    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 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[];
+    identifier(i: number): IdentifierContext;
+    FROM(): TerminalNode | undefined;
+    BRACES_START(): TerminalNode | undefined;
+    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 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;
+    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
+    exposeDeclaration(): ExposeDeclarationContext | undefined;
+    programDeclaration(): ProgramDeclarationContext | 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;
+    exportStatement(): ExportStatementContext | 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 {
+    exportNamespace(): ExportNamespaceContext | undefined;
+    exportIdentifier(): ExportIdentifierContext | 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 ExportNamespaceContext extends ParserRuleContext {
+    EXPORT(): TerminalNode;
+    NAMESPACE(): TerminalNode;
+    identifier(): IdentifierContext[];
+    identifier(i: number): IdentifierContext;
+    BRACES_START(): TerminalNode;
+    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 ExportIdentifierContext extends ParserRuleContext {
+    EXPORT(): TerminalNode;
+    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 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;
+    valueInternal(): ValueInternalContext;
+    BRACES_START(): TerminalNode;
+    BRACES_END(): TerminalNode;
+    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;
+    eventDeclaration(): EventDeclarationContext | 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 EventDeclarationContext extends ParserRuleContext {
+    EVENT(): TerminalNode;
+    valueInternal(): ValueInternalContext;
+    functionParameters(): FunctionParametersContext;
+    ARROW_OPERATOR(): 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 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;
+    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;
+    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;
+    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;
+    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 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 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 {
+    literal(): LiteralContext | undefined;
+    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 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;
+    TYPE_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 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;
+    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