import * as antlr from "antlr4ng";
import { Token } from "antlr4ng";
import { GroupListener } from "./GroupListener.js";
import { STGroup } from "../../STGroup.js";
import { FormalArgument } from "../FormalArgument.js";
export declare class GroupParser extends antlr.Parser {
    static readonly TRUE = 1;
    static readonly FALSE = 2;
    static readonly LBRACK = 3;
    static readonly RBRACK = 4;
    static readonly AT = 5;
    static readonly DOT = 6;
    static readonly COLON = 7;
    static readonly SEMICOLON = 8;
    static readonly COMMA = 9;
    static readonly LPAREN = 10;
    static readonly RPAREN = 11;
    static readonly ASSIGN = 12;
    static readonly EQUAL = 13;
    static readonly IMPORT = 14;
    static readonly GROUP = 15;
    static readonly IMPLEMENTS = 16;
    static readonly DELIMITERS = 17;
    static readonly DEFAULT = 18;
    static readonly ID = 19;
    static readonly STRING = 20;
    static readonly BIGSTRING_NO_NL = 21;
    static readonly BIGSTRING = 22;
    static readonly ANONYMOUS_TEMPLATE = 23;
    static readonly COMMENT = 24;
    static readonly LINE_COMMENT = 25;
    static readonly WS = 26;
    static readonly RULE_group = 0;
    static readonly RULE_oldStyleHeader = 1;
    static readonly RULE_groupName = 2;
    static readonly RULE_delimiters = 3;
    static readonly RULE_def = 4;
    static readonly RULE_templateDef = 5;
    static readonly RULE_formalArgs = 6;
    static readonly RULE_formalArg = 7;
    static readonly RULE_dictDef = 8;
    static readonly RULE_dict = 9;
    static readonly RULE_dictPairs = 10;
    static readonly RULE_defaultValuePair = 11;
    static readonly RULE_keyValuePair = 12;
    static readonly RULE_keyValue = 13;
    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;
    currentGroup: STGroup;
    getSourceName(): string;
    error(msg: string, re: antlr.RecognitionException): void;
    addArgument(args: FormalArgument[], t: Token, defaultValueToken?: Token): void;
    constructor(input: antlr.TokenStream);
    group(aGroup: STGroup, prefix: string): GroupContext;
    oldStyleHeader(): OldStyleHeaderContext;
    groupName(): GroupNameContext;
    delimiters(): DelimitersContext;
    def(prefix: string): DefContext;
    templateDef(prefix: string): TemplateDefContext;
    formalArgs(): FormalArgsContext;
    formalArg(args: FormalArgument[]): FormalArgContext;
    dictDef(): DictDefContext;
    dict(): DictContext;
    dictPairs(mapping: Map<string, unknown>): DictPairsContext;
    defaultValuePair(mapping: Map<string, unknown>): DefaultValuePairContext;
    keyValuePair(mapping: Map<string, unknown>): KeyValuePairContext;
    keyValue(): KeyValueContext;
    sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
    private keyValue_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 GroupContext extends antlr.ParserRuleContext {
    aGroup: STGroup;
    prefix: string;
    _STRING?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, aGroup: STGroup, prefix: string);
    EOF(): antlr.TerminalNode;
    oldStyleHeader(): OldStyleHeaderContext | null;
    delimiters(): DelimitersContext | null;
    IMPORT(): antlr.TerminalNode[];
    IMPORT(i: number): antlr.TerminalNode | null;
    def(): DefContext[];
    def(i: number): DefContext | null;
    STRING(): antlr.TerminalNode[];
    STRING(i: number): antlr.TerminalNode | null;
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    DOT(): antlr.TerminalNode[];
    DOT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class OldStyleHeaderContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    GROUP(): antlr.TerminalNode;
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    SEMICOLON(): antlr.TerminalNode;
    COLON(): antlr.TerminalNode | null;
    IMPLEMENTS(): antlr.TerminalNode | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class GroupNameContext extends antlr.ParserRuleContext {
    _a?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    DOT(): antlr.TerminalNode[];
    DOT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class DelimitersContext extends antlr.ParserRuleContext {
    _a?: Token | null;
    _b?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    DELIMITERS(): antlr.TerminalNode;
    COMMA(): antlr.TerminalNode;
    STRING(): antlr.TerminalNode[];
    STRING(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class DefContext extends antlr.ParserRuleContext {
    prefix: string;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, prefix: string);
    templateDef(): TemplateDefContext | null;
    dictDef(): DictDefContext | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class TemplateDefContext extends antlr.ParserRuleContext {
    prefix: string;
    _enclosing?: Token | null;
    _name?: Token | null;
    _formalArgs?: FormalArgsContext;
    _STRING?: Token | null;
    _BIGSTRING?: Token | null;
    _BIGSTRING_NO_NL?: Token | null;
    _alias?: Token | null;
    _target?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, prefix: string);
    ASSIGN(): antlr.TerminalNode;
    AT(): antlr.TerminalNode | null;
    DOT(): antlr.TerminalNode | null;
    LPAREN(): antlr.TerminalNode | null;
    RPAREN(): antlr.TerminalNode | null;
    formalArgs(): FormalArgsContext | null;
    STRING(): antlr.TerminalNode | null;
    BIGSTRING(): antlr.TerminalNode | null;
    BIGSTRING_NO_NL(): antlr.TerminalNode | null;
    ID(): antlr.TerminalNode[];
    ID(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class FormalArgsContext extends antlr.ParserRuleContext {
    args: FormalArgument[];
    hasOptionalParameter: boolean;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    formalArg(): FormalArgContext[];
    formalArg(i: number): FormalArgContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class FormalArgContext extends antlr.ParserRuleContext {
    args: FormalArgument[];
    _ID?: Token | null;
    _a?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, args: FormalArgument[]);
    ID(): antlr.TerminalNode;
    EQUAL(): antlr.TerminalNode | null;
    RBRACK(): antlr.TerminalNode | null;
    LBRACK(): antlr.TerminalNode | null;
    STRING(): antlr.TerminalNode | null;
    ANONYMOUS_TEMPLATE(): antlr.TerminalNode | null;
    TRUE(): antlr.TerminalNode | null;
    FALSE(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class DictDefContext extends antlr.ParserRuleContext {
    _ID?: Token | null;
    _dict?: DictContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ID(): antlr.TerminalNode;
    ASSIGN(): antlr.TerminalNode;
    dict(): DictContext;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class DictContext extends antlr.ParserRuleContext {
    mapping: Map<string, unknown> | undefined;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LBRACK(): antlr.TerminalNode;
    dictPairs(): DictPairsContext;
    RBRACK(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class DictPairsContext extends antlr.ParserRuleContext {
    mapping: Map<string, unknown>;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, mapping: Map<string, unknown>);
    keyValuePair(): KeyValuePairContext[];
    keyValuePair(i: number): KeyValuePairContext | null;
    defaultValuePair(): DefaultValuePairContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class DefaultValuePairContext extends antlr.ParserRuleContext {
    mapping: Map<string, unknown>;
    _keyValue?: KeyValueContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, mapping: Map<string, unknown>);
    DEFAULT(): antlr.TerminalNode;
    COLON(): antlr.TerminalNode;
    keyValue(): KeyValueContext;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class KeyValuePairContext extends antlr.ParserRuleContext {
    mapping: Map<string, unknown>;
    _STRING?: Token | null;
    _keyValue?: KeyValueContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number, mapping: Map<string, unknown>);
    STRING(): antlr.TerminalNode;
    COLON(): antlr.TerminalNode;
    keyValue(): KeyValueContext;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}
export declare class KeyValueContext extends antlr.ParserRuleContext {
    value: unknown;
    _BIGSTRING?: Token | null;
    _BIGSTRING_NO_NL?: Token | null;
    _ANONYMOUS_TEMPLATE?: Token | null;
    _STRING?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    BIGSTRING(): antlr.TerminalNode | null;
    BIGSTRING_NO_NL(): antlr.TerminalNode | null;
    ANONYMOUS_TEMPLATE(): antlr.TerminalNode | null;
    STRING(): antlr.TerminalNode | null;
    TRUE(): antlr.TerminalNode | null;
    FALSE(): antlr.TerminalNode | null;
    LBRACK(): antlr.TerminalNode | null;
    RBRACK(): antlr.TerminalNode | null;
    ID(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: GroupListener): void;
    exitRule(listener: GroupListener): void;
}