import * as antlr from "antlr4ng";
import { Token } from "antlr4ng";
import { STParserListener } from "./STParserListener.js";
import { ErrorManager } from "../../misc/ErrorManager.js";
export declare class STParser extends antlr.Parser {
    static readonly RBRACK = 17;
    static readonly LBRACK = 16;
    static readonly ELSE = 5;
    static readonly ELLIPSIS = 11;
    static readonly LCURLY = 20;
    static readonly BANG = 10;
    static readonly EQUALS = 12;
    static readonly TEXT = 22;
    static readonly ID = 25;
    static readonly SEMI = 9;
    static readonly LPAREN = 14;
    static readonly IF = 4;
    static readonly ELSEIF = 6;
    static readonly COLON = 13;
    static readonly RPAREN = 15;
    static readonly WS = 27;
    static readonly COMMA = 18;
    static readonly RCURLY = 21;
    static readonly ENDIF = 7;
    static readonly RDELIM = 24;
    static readonly SUPER = 8;
    static readonly DOT = 19;
    static readonly LDELIM = 23;
    static readonly STRING = 26;
    static readonly PIPE = 28;
    static readonly OR = 29;
    static readonly AND = 30;
    static readonly INDENT = 31;
    static readonly NEWLINE = 32;
    static readonly AT = 33;
    static readonly END = 34;
    static readonly TRUE = 35;
    static readonly FALSE = 36;
    static readonly COMMENT = 37;
    static readonly SLASH = 38;
    static readonly EXPR = 39;
    static readonly OPTIONS = 40;
    static readonly PROP = 41;
    static readonly PROP_IND = 42;
    static readonly INCLUDE = 43;
    static readonly INCLUDE_IND = 44;
    static readonly EXEC_FUNC = 45;
    static readonly INCLUDE_SUPER = 46;
    static readonly INCLUDE_SUPER_REGION = 47;
    static readonly INCLUDE_REGION = 48;
    static readonly TO_STR = 49;
    static readonly LIST = 50;
    static readonly MAP = 51;
    static readonly ZIP = 52;
    static readonly SUBTEMPLATE = 53;
    static readonly ARGS = 54;
    static readonly ELEMENTS = 55;
    static readonly REGION = 56;
    static readonly NULL = 57;
    static readonly INDENTED_EXPR = 58;
    static readonly RULE_templateAndEOF = 0;
    static readonly RULE_template = 1;
    static readonly RULE_element = 2;
    static readonly RULE_singleElement = 3;
    static readonly RULE_compoundElement = 4;
    static readonly RULE_exprTag = 5;
    static readonly RULE_region = 6;
    static readonly RULE_subtemplate = 7;
    static readonly RULE_ifstat = 8;
    static readonly RULE_conditional = 9;
    static readonly RULE_andConditional = 10;
    static readonly RULE_notConditional = 11;
    static readonly RULE_notConditionalExpr = 12;
    static readonly RULE_exprOptions = 13;
    static readonly RULE_option = 14;
    static readonly RULE_exprNoComma = 15;
    static readonly RULE_expr = 16;
    static readonly RULE_mapExpr = 17;
    static readonly RULE_mapTemplateRef = 18;
    static readonly RULE_memberExpr = 19;
    static readonly RULE_includeExpr = 20;
    static readonly RULE_primary = 21;
    static readonly RULE_qualifiedId = 22;
    static readonly RULE_args = 23;
    static readonly RULE_argExprList = 24;
    static readonly RULE_arg = 25;
    static readonly RULE_namedArg = 26;
    static readonly RULE_list = 27;
    static readonly RULE_listElement = 28;
    static readonly literalNames: (string | null)[];
    static readonly symbolicNames: (string | null)[];
    static readonly ruleNames: string[];
    get grammarFileName(): string;
    get literalNames(): (string | null)[];
    get symbolicNames(): (string | null)[];
    get ruleNames(): string[];
    get serializedATN(): number[];
    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException;
    private errMgr;
    private templateToken?;
    static create(input: antlr.TokenStream, errMgr: ErrorManager, templateToken?: antlr.Token): STParser;
    constructor(input: antlr.TokenStream);
    templateAndEOF(): TemplateAndEOFContext;
    template(): TemplateContext;
    element(): ElementContext;
    singleElement(): SingleElementContext;
    compoundElement(): CompoundElementContext;
    exprTag(): ExprTagContext;
    region(): RegionContext;
    subtemplate(): SubtemplateContext;
    ifstat(): IfstatContext;
    conditional(): ConditionalContext;
    andConditional(): AndConditionalContext;
    notConditional(): NotConditionalContext;
    notConditionalExpr(): NotConditionalExprContext;
    exprOptions(): ExprOptionsContext;
    option(): OptionContext;
    exprNoComma(): ExprNoCommaContext;
    expr(): ExprContext;
    mapExpr(): MapExprContext;
    mapTemplateRef(): MapTemplateRefContext;
    memberExpr(): MemberExprContext;
    includeExpr(): IncludeExprContext;
    primary(): PrimaryContext;
    qualifiedId(): QualifiedIdContext;
    args(): ArgsContext;
    argExprList(): ArgExprListContext;
    arg(): ArgContext;
    namedArg(): NamedArgContext;
    list(): ListContext;
    listElement(): ListElementContext;
    sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
    private element_sempred;
    private includeExpr_sempred;
    private list_sempred;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): antlr.ATN;
    private static readonly vocabulary;
    get vocabulary(): antlr.Vocabulary;
    private static readonly decisionsToDFA;
}
export declare class TemplateAndEOFContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    template(): TemplateContext;
    EOF(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class TemplateContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    element(): ElementContext[];
    element(i: number): ElementContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    COMMENT(): antlr.TerminalNode | null;
    NEWLINE(): antlr.TerminalNode | null;
    INDENT(): antlr.TerminalNode | null;
    singleElement(): SingleElementContext | null;
    compoundElement(): CompoundElementContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class SingleElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    exprTag(): ExprTagContext | null;
    TEXT(): antlr.TerminalNode | null;
    NEWLINE(): antlr.TerminalNode | null;
    COMMENT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class CompoundElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ifstat(): IfstatContext | null;
    region(): RegionContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ExprTagContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LDELIM(): antlr.TerminalNode;
    expr(): ExprContext;
    RDELIM(): antlr.TerminalNode;
    SEMI(): antlr.TerminalNode | null;
    exprOptions(): ExprOptionsContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class RegionContext extends antlr.ParserRuleContext {
    _indent?: Token | null;
    _x?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    AT(): antlr.TerminalNode;
    ID(): antlr.TerminalNode;
    RDELIM(): antlr.TerminalNode[];
    RDELIM(i: number): antlr.TerminalNode | null;
    template(): TemplateContext;
    LDELIM(): antlr.TerminalNode[];
    LDELIM(i: number): antlr.TerminalNode | null;
    END(): antlr.TerminalNode;
    INDENT(): antlr.TerminalNode[];
    INDENT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class SubtemplateContext extends antlr.ParserRuleContext {
    _lc?: Token | null;
    _ID?: Token | null;
    _ids: antlr.Token[];
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    template(): TemplateContext;
    RCURLY(): antlr.TerminalNode;
    LCURLY(): antlr.TerminalNode;
    PIPE(): antlr.TerminalNode | null;
    INDENT(): antlr.TerminalNode | null;
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class IfstatContext extends antlr.ParserRuleContext {
    _indent?: Token | null;
    _c1?: ConditionalContext;
    _t1?: TemplateContext;
    _conditional?: ConditionalContext;
    _c2: ConditionalContext[];
    _template?: TemplateContext;
    _t2: TemplateContext[];
    _t3?: TemplateContext;
    _endif?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LDELIM(): antlr.TerminalNode[];
    LDELIM(i: number): antlr.TerminalNode | null;
    IF(): antlr.TerminalNode;
    LPAREN(): antlr.TerminalNode[];
    LPAREN(i: number): antlr.TerminalNode | null;
    RPAREN(): antlr.TerminalNode[];
    RPAREN(i: number): antlr.TerminalNode | null;
    RDELIM(): antlr.TerminalNode[];
    RDELIM(i: number): antlr.TerminalNode | null;
    ENDIF(): antlr.TerminalNode;
    conditional(): ConditionalContext[];
    conditional(i: number): ConditionalContext | null;
    template(): TemplateContext[];
    template(i: number): TemplateContext | null;
    ELSEIF(): antlr.TerminalNode[];
    ELSEIF(i: number): antlr.TerminalNode | null;
    ELSE(): antlr.TerminalNode | null;
    INDENT(): antlr.TerminalNode[];
    INDENT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ConditionalContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    andConditional(): AndConditionalContext[];
    andConditional(i: number): AndConditionalContext | null;
    OR(): antlr.TerminalNode[];
    OR(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class AndConditionalContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    notConditional(): NotConditionalContext[];
    notConditional(i: number): NotConditionalContext | null;
    AND(): antlr.TerminalNode[];
    AND(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class NotConditionalContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    memberExpr(): MemberExprContext;
    BANG(): antlr.TerminalNode[];
    BANG(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class NotConditionalExprContext extends antlr.ParserRuleContext {
    _p?: Token | null;
    _prop?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    LPAREN(): antlr.TerminalNode[];
    LPAREN(i: number): antlr.TerminalNode | null;
    mapExpr(): MapExprContext[];
    mapExpr(i: number): MapExprContext | null;
    RPAREN(): antlr.TerminalNode[];
    RPAREN(i: number): antlr.TerminalNode | null;
    DOT(): antlr.TerminalNode[];
    DOT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ExprOptionsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    option(): OptionContext[];
    option(i: number): OptionContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class OptionContext extends antlr.ParserRuleContext {
    _ID?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode;
    EQUALS(): antlr.TerminalNode | null;
    exprNoComma(): ExprNoCommaContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ExprNoCommaContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    memberExpr(): MemberExprContext;
    COLON(): antlr.TerminalNode | null;
    mapTemplateRef(): MapTemplateRefContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ExprContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    mapExpr(): MapExprContext;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class MapExprContext extends antlr.ParserRuleContext {
    _c?: Token | null;
    _col?: Token | null;
    _mapTemplateRef?: MapTemplateRefContext;
    _x: MapTemplateRefContext[];
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    memberExpr(): MemberExprContext[];
    memberExpr(i: number): MemberExprContext | null;
    mapTemplateRef(): MapTemplateRefContext[];
    mapTemplateRef(i: number): MapTemplateRefContext | null;
    COLON(): antlr.TerminalNode[];
    COLON(i: number): antlr.TerminalNode | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class MapTemplateRefContext extends antlr.ParserRuleContext {
    _lp?: Token | null;
    _rp?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    qualifiedId(): QualifiedIdContext | null;
    LPAREN(): antlr.TerminalNode[];
    LPAREN(i: number): antlr.TerminalNode | null;
    args(): ArgsContext | null;
    RPAREN(): antlr.TerminalNode[];
    RPAREN(i: number): antlr.TerminalNode | null;
    subtemplate(): SubtemplateContext | null;
    mapExpr(): MapExprContext | null;
    argExprList(): ArgExprListContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class MemberExprContext extends antlr.ParserRuleContext {
    _p?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    includeExpr(): IncludeExprContext | null;
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    LPAREN(): antlr.TerminalNode[];
    LPAREN(i: number): antlr.TerminalNode | null;
    mapExpr(): MapExprContext[];
    mapExpr(i: number): MapExprContext | null;
    RPAREN(): antlr.TerminalNode[];
    RPAREN(i: number): antlr.TerminalNode | null;
    DOT(): antlr.TerminalNode[];
    DOT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class IncludeExprContext extends antlr.ParserRuleContext {
    _rp?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode | null;
    LPAREN(): antlr.TerminalNode | null;
    RPAREN(): antlr.TerminalNode | null;
    expr(): ExprContext | null;
    SUPER(): antlr.TerminalNode | null;
    DOT(): antlr.TerminalNode | null;
    args(): ArgsContext | null;
    qualifiedId(): QualifiedIdContext | null;
    AT(): antlr.TerminalNode | null;
    primary(): PrimaryContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class PrimaryContext extends antlr.ParserRuleContext {
    _lp?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode | null;
    STRING(): antlr.TerminalNode | null;
    TRUE(): antlr.TerminalNode | null;
    FALSE(): antlr.TerminalNode | null;
    subtemplate(): SubtemplateContext | null;
    list(): ListContext | null;
    expr(): ExprContext | null;
    RPAREN(): antlr.TerminalNode[];
    RPAREN(i: number): antlr.TerminalNode | null;
    LPAREN(): antlr.TerminalNode[];
    LPAREN(i: number): antlr.TerminalNode | null;
    argExprList(): ArgExprListContext | null;
    conditional(): ConditionalContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class QualifiedIdContext extends antlr.ParserRuleContext {
    _r?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    SLASH(): antlr.TerminalNode[];
    SLASH(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ArgsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    argExprList(): ArgExprListContext | null;
    namedArg(): NamedArgContext[];
    namedArg(i: number): NamedArgContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    ELLIPSIS(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ArgExprListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    arg(): ArgContext[];
    arg(i: number): ArgContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ArgContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    exprNoComma(): ExprNoCommaContext;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class NamedArgContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode;
    EQUALS(): antlr.TerminalNode;
    arg(): ArgContext;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ListContext extends antlr.ParserRuleContext {
    _lb?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    RBRACK(): antlr.TerminalNode;
    LBRACK(): antlr.TerminalNode;
    listElement(): ListElementContext[];
    listElement(i: number): ListElementContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}
export declare class ListElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    exprNoComma(): ExprNoCommaContext | null;
    get ruleIndex(): number;
    enterRule(listener: STParserListener): void;
    exitRule(listener: STParserListener): void;
}