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