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 { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { MapParserListener } from "./MapParserListener";
import { MapParserVisitor } from "./MapParserVisitor";
export declare class MapParser extends Parser {
    static readonly INCLUDE = 1;
    static readonly CURVE = 2;
    static readonly GRADIENT = 3;
    static readonly TRACK = 4;
    static readonly STRUCTURE = 5;
    static readonly REPEATER = 6;
    static readonly BACKGROUND = 7;
    static readonly STATION = 8;
    static readonly SECTION = 9;
    static readonly SIGNAL = 10;
    static readonly BEACON = 11;
    static readonly SPEEDLIMIT = 12;
    static readonly PRETRAIN = 13;
    static readonly LIGHT = 14;
    static readonly FOG = 15;
    static readonly DRAWDISTANCE = 16;
    static readonly CABILLUMINANCE = 17;
    static readonly IRREGULARITY = 18;
    static readonly ADHESION = 19;
    static readonly SOUND = 20;
    static readonly SOUND3D = 21;
    static readonly ROLLINGNOISE = 22;
    static readonly FLANGENOISE = 23;
    static readonly JOINTNOISE = 24;
    static readonly TRAIN = 25;
    static readonly LEGACY = 26;
    static readonly X_ELEMENT = 27;
    static readonly Y_ELEMENT = 28;
    static readonly CANT = 29;
    static readonly SET_GAUGE = 30;
    static readonly GAUGE = 31;
    static readonly SET_CENTER = 32;
    static readonly SET_FUNCTION = 33;
    static readonly SET = 34;
    static readonly BEGIN_TRANSITION = 35;
    static readonly BEGIN = 36;
    static readonly BEGIN0 = 37;
    static readonly BEGIN_CIRCULAR = 38;
    static readonly BEGIN_CONST = 39;
    static readonly BEGIN_NEW = 40;
    static readonly END = 41;
    static readonly INTERPOLATE = 42;
    static readonly CHANGE = 43;
    static readonly POSITION = 44;
    static readonly LOAD = 45;
    static readonly PUT = 46;
    static readonly PUT0 = 47;
    static readonly PUTBETWEEN = 48;
    static readonly SET_SPEEDLIMIT = 49;
    static readonly SET_SIGNAL = 50;
    static readonly PASS = 51;
    static readonly AMBIENT = 52;
    static readonly DIFFUSE = 53;
    static readonly DIRECTION = 54;
    static readonly PLAY = 55;
    static readonly ADD = 56;
    static readonly ENABLE = 57;
    static readonly STOP = 58;
    static readonly SETTRACK = 59;
    static readonly PITCH = 60;
    static readonly TURN = 61;
    static readonly STATE_END = 62;
    static readonly DOT = 63;
    static readonly COMMA = 64;
    static readonly NUM = 65;
    static readonly NULL = 66;
    static readonly DISTANCE = 67;
    static readonly EQUAL = 68;
    static readonly PLUS = 69;
    static readonly MINUS = 70;
    static readonly MULT = 71;
    static readonly DIV = 72;
    static readonly MOD = 73;
    static readonly ABS = 74;
    static readonly ATAN2 = 75;
    static readonly CEIL = 76;
    static readonly COS = 77;
    static readonly EXP = 78;
    static readonly FLOOR = 79;
    static readonly LOG = 80;
    static readonly POW = 81;
    static readonly RAND = 82;
    static readonly SIN = 83;
    static readonly SQRT = 84;
    static readonly OPN_PAR = 85;
    static readonly CLS_PAR = 86;
    static readonly OPN_BRA = 87;
    static readonly CLS_BRA = 88;
    static readonly WHITESPACE = 89;
    static readonly COMMENT = 90;
    static readonly VAR_START = 91;
    static readonly VAR = 92;
    static readonly QUOTE = 93;
    static readonly ERROR_TOKEN = 94;
    static readonly RQUOTE = 95;
    static readonly CHAR = 96;
    static readonly E_WS = 97;
    static readonly ENCODE_END = 98;
    static readonly ENCODE_CHAR = 99;
    static readonly RULE_root = 0;
    static readonly RULE_statement = 1;
    static readonly RULE_element = 2;
    static readonly RULE_subelement = 3;
    static readonly RULE_function = 4;
    static readonly RULE_args = 5;
    static readonly RULE_nullableExpr = 6;
    static readonly RULE_expr = 7;
    static readonly RULE_var = 8;
    static readonly RULE_string = 9;
    static readonly RULE_string_text = 10;
    static readonly RULE_error_tokens = 11;
    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;
    statement(): StatementContext;
    element(): ElementContext;
    subelement(): SubelementContext;
    function(): FunctionContext;
    args(): ArgsContext;
    nullableExpr(): NullableExprContext;
    expr(): ExprContext;
    expr(_p: number): ExprContext;
    var(): VarContext;
    string(): StringContext;
    string_text(): String_textContext;
    error_tokens(): Error_tokensContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expr_sempred;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class RootContext extends ParserRuleContext {
    EOF(): TerminalNode;
    statement(): StatementContext[];
    statement(i: number): StatementContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class StatementContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: StatementContext): void;
}
export declare class DistanceStatementContext extends StatementContext {
    expr(): ExprContext;
    STATE_END(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class VarAssignStatementContext extends StatementContext {
    _v: VarContext;
    VAR_START(): TerminalNode;
    EQUAL(): TerminalNode;
    expr(): ExprContext;
    STATE_END(): TerminalNode;
    var(): VarContext;
    constructor(ctx: StatementContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class SimpleStatementContext extends StatementContext {
    element(): ElementContext;
    DOT(): TerminalNode;
    function(): FunctionContext;
    OPN_PAR(): TerminalNode;
    args(): ArgsContext;
    CLS_PAR(): TerminalNode;
    STATE_END(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class KeyStatementContext extends StatementContext {
    element(): ElementContext;
    OPN_BRA(): TerminalNode;
    expr(): ExprContext;
    CLS_BRA(): TerminalNode;
    DOT(): TerminalNode;
    function(): FunctionContext;
    OPN_PAR(): TerminalNode;
    args(): ArgsContext;
    CLS_PAR(): TerminalNode;
    STATE_END(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class KeyWithSubelementStatementContext extends StatementContext {
    element(): ElementContext;
    OPN_BRA(): TerminalNode;
    expr(): ExprContext;
    CLS_BRA(): TerminalNode;
    DOT(): TerminalNode[];
    DOT(i: number): TerminalNode;
    subelement(): SubelementContext;
    function(): FunctionContext;
    OPN_PAR(): TerminalNode;
    args(): ArgsContext;
    CLS_PAR(): TerminalNode;
    STATE_END(): TerminalNode;
    constructor(ctx: StatementContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class ElementContext extends ParserRuleContext {
    CURVE(): TerminalNode | undefined;
    GRADIENT(): TerminalNode | undefined;
    TRACK(): TerminalNode | undefined;
    STRUCTURE(): TerminalNode | undefined;
    REPEATER(): TerminalNode | undefined;
    BACKGROUND(): TerminalNode | undefined;
    STATION(): TerminalNode | undefined;
    SECTION(): TerminalNode | undefined;
    SIGNAL(): TerminalNode | undefined;
    BEACON(): TerminalNode | undefined;
    SPEEDLIMIT(): TerminalNode | undefined;
    PRETRAIN(): TerminalNode | undefined;
    LIGHT(): TerminalNode | undefined;
    FOG(): TerminalNode | undefined;
    DRAWDISTANCE(): TerminalNode | undefined;
    CABILLUMINANCE(): TerminalNode | undefined;
    IRREGULARITY(): TerminalNode | undefined;
    ADHESION(): TerminalNode | undefined;
    SOUND(): TerminalNode | undefined;
    SOUND3D(): TerminalNode | undefined;
    ROLLINGNOISE(): TerminalNode | undefined;
    FLANGENOISE(): TerminalNode | undefined;
    JOINTNOISE(): TerminalNode | undefined;
    TRAIN(): TerminalNode | undefined;
    LEGACY(): TerminalNode | undefined;
    GAUGE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class SubelementContext extends ParserRuleContext {
    X_ELEMENT(): TerminalNode | undefined;
    Y_ELEMENT(): TerminalNode | undefined;
    CANT(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class FunctionContext extends ParserRuleContext {
    SET_GAUGE(): TerminalNode | undefined;
    GAUGE(): TerminalNode | undefined;
    SET_CENTER(): TerminalNode | undefined;
    SET_FUNCTION(): TerminalNode | undefined;
    SET(): TerminalNode | undefined;
    BEGIN_TRANSITION(): TerminalNode | undefined;
    BEGIN(): TerminalNode | undefined;
    BEGIN0(): TerminalNode | undefined;
    BEGIN_CIRCULAR(): TerminalNode | undefined;
    BEGIN_CONST(): TerminalNode | undefined;
    END(): TerminalNode | undefined;
    BEGIN_NEW(): TerminalNode | undefined;
    INTERPOLATE(): TerminalNode | undefined;
    CHANGE(): TerminalNode | undefined;
    POSITION(): TerminalNode | undefined;
    LOAD(): TerminalNode | undefined;
    PUT(): TerminalNode | undefined;
    PUT0(): TerminalNode | undefined;
    PUTBETWEEN(): TerminalNode | undefined;
    SET_SPEEDLIMIT(): TerminalNode | undefined;
    SET_SIGNAL(): TerminalNode | undefined;
    PASS(): TerminalNode | undefined;
    AMBIENT(): TerminalNode | undefined;
    DIFFUSE(): TerminalNode | undefined;
    DIRECTION(): TerminalNode | undefined;
    PLAY(): TerminalNode | undefined;
    ADD(): TerminalNode | undefined;
    ENABLE(): TerminalNode | undefined;
    STOP(): TerminalNode | undefined;
    CANT(): TerminalNode | undefined;
    CURVE(): TerminalNode | undefined;
    FOG(): TerminalNode | undefined;
    SETTRACK(): TerminalNode | undefined;
    SPEEDLIMIT(): TerminalNode | undefined;
    PITCH(): TerminalNode | undefined;
    TURN(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class ArgsContext extends ParserRuleContext {
    nullableExpr(): NullableExprContext[];
    nullableExpr(i: number): NullableExprContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class NullableExprContext extends ParserRuleContext {
    _nullSyntax: Token;
    expr(): ExprContext | undefined;
    NULL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class ExprContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ExprContext): void;
}
export declare class ParensExprContext extends ExprContext {
    OPN_PAR(): TerminalNode;
    expr(): ExprContext;
    CLS_PAR(): TerminalNode;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class UnaryExprContext extends ExprContext {
    _op: Token;
    expr(): ExprContext;
    PLUS(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class InfixExprContext extends ExprContext {
    _left: ExprContext;
    _op: Token;
    _right: ExprContext;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    MULT(): TerminalNode | undefined;
    DIV(): TerminalNode | undefined;
    PLUS(): TerminalNode | undefined;
    MINUS(): TerminalNode | undefined;
    MOD(): TerminalNode | undefined;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class AbsExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    ABS(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class Atan2ExprContext extends ExprContext {
    _func: Token;
    _y: ExprContext;
    _x: ExprContext;
    OPN_PAR(): TerminalNode;
    COMMA(): TerminalNode;
    CLS_PAR(): TerminalNode;
    ATAN2(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class CeilExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    CEIL(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class CosExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    COS(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class ExpExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    EXP(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class FloorExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    FLOOR(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class LogExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    LOG(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class PowExprContext extends ExprContext {
    _func: Token;
    _x: ExprContext;
    _y: ExprContext;
    OPN_PAR(): TerminalNode;
    COMMA(): TerminalNode;
    CLS_PAR(): TerminalNode;
    POW(): TerminalNode;
    expr(): ExprContext[];
    expr(i: number): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class RandExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    RAND(): TerminalNode;
    expr(): ExprContext | undefined;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class SinExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    SIN(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class SqrtExprContext extends ExprContext {
    _func: Token;
    _value: ExprContext;
    OPN_PAR(): TerminalNode;
    CLS_PAR(): TerminalNode;
    SQRT(): TerminalNode;
    expr(): ExprContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class VarExprContext extends ExprContext {
    _v: VarContext;
    var(): VarContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class NumberExprContext extends ExprContext {
    _num: Token;
    NUM(): TerminalNode;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class StringExprContext extends ExprContext {
    _str: StringContext;
    string(): StringContext;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class DistanceExprContext extends ExprContext {
    _dist: Token;
    DISTANCE(): TerminalNode;
    constructor(ctx: ExprContext);
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class VarContext extends ParserRuleContext {
    varName: string | undefined;
    _v: Token;
    VAR_START(): TerminalNode;
    VAR(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class StringContext extends ParserRuleContext {
    value: string | undefined;
    _v: String_textContext;
    QUOTE(): TerminalNode;
    RQUOTE(): TerminalNode;
    string_text(): String_textContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class String_textContext extends ParserRuleContext {
    CHAR(): TerminalNode[];
    CHAR(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}
export declare class Error_tokensContext extends ParserRuleContext {
    ERROR_TOKEN(): TerminalNode[];
    ERROR_TOKEN(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: MapParserListener): void;
    exitRule(listener: MapParserListener): void;
    accept<Result>(visitor: MapParserVisitor<Result>): Result;
}