udm-rules-vue 0.0.1

package/dist/grammar/bom/BomParser.d.ts

@@ -0,0 +1,656 @@
+import { BomParserListener } from './BomParserListener.js';
+import { BomParserVisitor } from './BomParserVisitor.js';
+import * as antlr from "antlr4ng";
+export declare class BomParser extends antlr.Parser {
+    static readonly Public = 1;
+    static readonly Class = 2;
+    static readonly Interface = 3;
+    static readonly Static = 4;
+    static readonly Abstract = 5;
+    static readonly Final = 6;
+    static readonly ReadOnly = 7;
+    static readonly Writeonly = 8;
+    static readonly Property = 9;
+    static readonly Domain = 10;
+    static readonly Package = 11;
+    static readonly Extends = 12;
+    static readonly Implements = 13;
+    static readonly Throws = 14;
+    static readonly EnumClass = 15;
+    static readonly GenericityObjectCount = 16;
+    static readonly Dot = 17;
+    static readonly Colon = 18;
+    static readonly Comma = 19;
+    static readonly Null = 20;
+    static readonly LeftBrace = 21;
+    static readonly RightBrace = 22;
+    static readonly Semicolon = 23;
+    static readonly LeftBracket = 24;
+    static readonly RightBracket = 25;
+    static readonly LeftParen = 26;
+    static readonly RightParen = 27;
+    static readonly String = 28;
+    static readonly Float = 29;
+    static readonly Integer = 30;
+    static readonly Identifier = 31;
+    static readonly Char = 32;
+    static readonly WS = 33;
+    static readonly RULE_boms = 0;
+    static readonly RULE_bom = 1;
+    static readonly RULE_classDeclare = 2;
+    static readonly RULE_standardClassDeclare = 3;
+    static readonly RULE_standardDomainClassDeclare = 4;
+    static readonly RULE_standardInterfaceClassDeclare = 5;
+    static readonly RULE_standardEumnClassDeclare = 6;
+    static readonly RULE_classBody = 7;
+    static readonly RULE_classBodyContent = 8;
+    static readonly RULE_innerClass = 9;
+    static readonly RULE_innerClassDeclare = 10;
+    static readonly RULE_interfaceClassDeclare = 11;
+    static readonly RULE_staticClassDeclare = 12;
+    static readonly RULE_enumClassDeclare = 13;
+    static readonly RULE_classDomain = 14;
+    static readonly RULE_classDomainItem = 15;
+    static readonly RULE_classDomainValue = 16;
+    static readonly RULE_field = 17;
+    static readonly RULE_method = 18;
+    static readonly RULE_objectConstructor = 19;
+    static readonly RULE_throwsPart = 20;
+    static readonly RULE_parameters = 21;
+    static readonly RULE_parameterDeclare = 22;
+    static readonly RULE_domainDeclare = 23;
+    static readonly RULE_domainValue = 24;
+    static readonly RULE_otherValue = 25;
+    static readonly RULE_numberDomainValue = 26;
+    static readonly RULE_limitValue = 27;
+    static readonly RULE_limitTag = 28;
+    static readonly RULE_staticValue = 29;
+    static readonly RULE_number = 30;
+    static readonly RULE_scopeValue = 31;
+    static readonly RULE_implementsPart = 32;
+    static readonly RULE_extendsPart = 33;
+    static readonly RULE_packageDeclare = 34;
+    static readonly RULE_datatype = 35;
+    static readonly RULE_arrayTag = 36;
+    static readonly RULE_packageName = 37;
+    static readonly RULE_propertyItem = 38;
+    static readonly RULE_propertyName = 39;
+    static readonly RULE_className = 40;
+    static readonly RULE_fieldName = 41;
+    static readonly RULE_methodName = 42;
+    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;
+    constructor(input: antlr.TokenStream);
+    boms(): BomsContext;
+    bom(): BomContext;
+    classDeclare(): ClassDeclareContext;
+    standardClassDeclare(): StandardClassDeclareContext;
+    standardDomainClassDeclare(): StandardDomainClassDeclareContext;
+    standardInterfaceClassDeclare(): StandardInterfaceClassDeclareContext;
+    standardEumnClassDeclare(): StandardEumnClassDeclareContext;
+    classBody(): ClassBodyContext;
+    classBodyContent(): ClassBodyContentContext;
+    innerClass(): InnerClassContext;
+    innerClassDeclare(): InnerClassDeclareContext;
+    interfaceClassDeclare(): InterfaceClassDeclareContext;
+    staticClassDeclare(): StaticClassDeclareContext;
+    enumClassDeclare(): EnumClassDeclareContext;
+    classDomain(): ClassDomainContext;
+    classDomainItem(): ClassDomainItemContext;
+    classDomainValue(): ClassDomainValueContext;
+    field(): FieldContext;
+    method(): MethodContext;
+    objectConstructor(): ObjectConstructorContext;
+    throwsPart(): ThrowsPartContext;
+    parameters(): ParametersContext;
+    parameterDeclare(): ParameterDeclareContext;
+    domainDeclare(): DomainDeclareContext;
+    domainValue(): DomainValueContext;
+    otherValue(): OtherValueContext;
+    numberDomainValue(): NumberDomainValueContext;
+    limitValue(): LimitValueContext;
+    limitTag(): LimitTagContext;
+    staticValue(): StaticValueContext;
+    number_(): NumberContext;
+    scopeValue(): ScopeValueContext;
+    implementsPart(): ImplementsPartContext;
+    extendsPart(): ExtendsPartContext;
+    packageDeclare(): PackageDeclareContext;
+    datatype(): DatatypeContext;
+    arrayTag(): ArrayTagContext;
+    packageName(): PackageNameContext;
+    propertyItem(): PropertyItemContext;
+    propertyName(): PropertyNameContext;
+    className(): ClassNameContext;
+    fieldName(): FieldNameContext;
+    methodName(): MethodNameContext;
+    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 BomsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    propertyItem(): PropertyItemContext[];
+    propertyItem(i: number): PropertyItemContext | null;
+    bom(): BomContext[];
+    bom(i: number): BomContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class BomContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    classDeclare(): ClassDeclareContext;
+    packageDeclare(): PackageDeclareContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    standardClassDeclare(): StandardClassDeclareContext;
+    classBody(): ClassBodyContext;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StandardClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    standardDomainClassDeclare(): StandardDomainClassDeclareContext | null;
+    standardInterfaceClassDeclare(): StandardInterfaceClassDeclareContext | null;
+    standardEumnClassDeclare(): StandardEumnClassDeclareContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StandardDomainClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Class(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    Public(): antlr.TerminalNode | null;
+    Abstract(): antlr.TerminalNode | null;
+    extendsPart(): ExtendsPartContext | null;
+    implementsPart(): ImplementsPartContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StandardInterfaceClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Interface(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    Public(): antlr.TerminalNode | null;
+    extendsPart(): ExtendsPartContext | null;
+    implementsPart(): ImplementsPartContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StandardEumnClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Public(): antlr.TerminalNode;
+    Final(): antlr.TerminalNode;
+    Class(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    Extends(): antlr.TerminalNode;
+    EnumClass(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassBodyContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LeftBrace(): antlr.TerminalNode;
+    RightBrace(): antlr.TerminalNode;
+    propertyItem(): PropertyItemContext[];
+    propertyItem(i: number): PropertyItemContext | null;
+    classDomain(): ClassDomainContext | null;
+    classBodyContent(): ClassBodyContentContext[];
+    classBodyContent(i: number): ClassBodyContentContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassBodyContentContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    field(): FieldContext | null;
+    objectConstructor(): ObjectConstructorContext | null;
+    method(): MethodContext | null;
+    innerClass(): InnerClassContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class InnerClassContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    innerClassDeclare(): InnerClassDeclareContext;
+    classBody(): ClassBodyContext;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class InnerClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    staticClassDeclare(): StaticClassDeclareContext | null;
+    enumClassDeclare(): EnumClassDeclareContext | null;
+    interfaceClassDeclare(): InterfaceClassDeclareContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class InterfaceClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Interface(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    Public(): antlr.TerminalNode | null;
+    extendsPart(): ExtendsPartContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StaticClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Class(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    Public(): antlr.TerminalNode | null;
+    Static(): antlr.TerminalNode | null;
+    extendsPart(): ExtendsPartContext | null;
+    implementsPart(): ImplementsPartContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class EnumClassDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Class(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    Extends(): antlr.TerminalNode;
+    EnumClass(): antlr.TerminalNode;
+    Static(): antlr.TerminalNode | null;
+    Public(): antlr.TerminalNode | null;
+    Final(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassDomainContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Domain(): antlr.TerminalNode;
+    LeftBrace(): antlr.TerminalNode;
+    classDomainItem(): ClassDomainItemContext;
+    RightBrace(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassDomainItemContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    classDomainValue(): ClassDomainValueContext[];
+    classDomainValue(i: number): ClassDomainValueContext | null;
+    Comma(): antlr.TerminalNode[];
+    Comma(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassDomainValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Static(): antlr.TerminalNode;
+    Identifier(): antlr.TerminalNode | null;
+    String(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class FieldContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Public(): antlr.TerminalNode;
+    datatype(): DatatypeContext;
+    fieldName(): FieldNameContext;
+    Semicolon(): antlr.TerminalNode;
+    Static(): antlr.TerminalNode | null;
+    Final(): antlr.TerminalNode | null;
+    ReadOnly(): antlr.TerminalNode | null;
+    Writeonly(): antlr.TerminalNode | null;
+    Abstract(): antlr.TerminalNode | null;
+    domainDeclare(): DomainDeclareContext | null;
+    propertyItem(): PropertyItemContext[];
+    propertyItem(i: number): PropertyItemContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class MethodContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Public(): antlr.TerminalNode;
+    datatype(): DatatypeContext;
+    methodName(): MethodNameContext;
+    LeftParen(): antlr.TerminalNode;
+    RightParen(): antlr.TerminalNode;
+    Semicolon(): antlr.TerminalNode;
+    Static(): antlr.TerminalNode | null;
+    Final(): antlr.TerminalNode | null;
+    Abstract(): antlr.TerminalNode | null;
+    parameters(): ParametersContext | null;
+    throwsPart(): ThrowsPartContext | null;
+    domainDeclare(): DomainDeclareContext | null;
+    propertyItem(): PropertyItemContext[];
+    propertyItem(i: number): PropertyItemContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ObjectConstructorContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Public(): antlr.TerminalNode;
+    className(): ClassNameContext;
+    LeftParen(): antlr.TerminalNode;
+    RightParen(): antlr.TerminalNode;
+    Semicolon(): antlr.TerminalNode;
+    parameters(): ParametersContext | null;
+    throwsPart(): ThrowsPartContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ThrowsPartContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Throws(): antlr.TerminalNode;
+    datatype(): DatatypeContext[];
+    datatype(i: number): DatatypeContext | null;
+    Comma(): antlr.TerminalNode[];
+    Comma(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ParametersContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    parameterDeclare(): ParameterDeclareContext[];
+    parameterDeclare(i: number): ParameterDeclareContext | null;
+    Comma(): antlr.TerminalNode[];
+    Comma(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ParameterDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    datatype(): DatatypeContext;
+    fieldName(): FieldNameContext;
+    domainDeclare(): DomainDeclareContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class DomainDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Domain(): antlr.TerminalNode;
+    domainValue(): DomainValueContext;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class DomainValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: DomainValueContext): void;
+}
+export declare class OtherDomainValueContext extends DomainValueContext {
+    constructor(ctx: DomainValueContext);
+    otherValue(): OtherValueContext;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class GenericityDomainValueContext extends DomainValueContext {
+    constructor(ctx: DomainValueContext);
+    GenericityObjectCount(): antlr.TerminalNode;
+    Class(): antlr.TerminalNode | null;
+    datatype(): DatatypeContext | null;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class LiteralDomainValueContext extends DomainValueContext {
+    constructor(ctx: DomainValueContext);
+    LeftBrace(): antlr.TerminalNode;
+    scopeValue(): ScopeValueContext[];
+    scopeValue(i: number): ScopeValueContext | null;
+    RightBrace(): antlr.TerminalNode;
+    Comma(): antlr.TerminalNode[];
+    Comma(i: number): antlr.TerminalNode | null;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StaticDomainValueContext extends DomainValueContext {
+    constructor(ctx: DomainValueContext);
+    LeftBrace(): antlr.TerminalNode;
+    staticValue(): StaticValueContext[];
+    staticValue(i: number): StaticValueContext | null;
+    RightBrace(): antlr.TerminalNode;
+    Comma(): antlr.TerminalNode[];
+    Comma(i: number): antlr.TerminalNode | null;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class LimitDomainValueContext extends DomainValueContext {
+    constructor(ctx: DomainValueContext);
+    limitValue(): LimitValueContext;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class OtherValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    String(): antlr.TerminalNode | null;
+    numberDomainValue(): NumberDomainValueContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class NumberDomainValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    number_(): NumberContext[];
+    number_(i: number): NumberContext | null;
+    Comma(): antlr.TerminalNode[];
+    Comma(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class LimitValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    limitTag(): LimitTagContext[];
+    limitTag(i: number): LimitTagContext | null;
+    number_(): NumberContext[];
+    number_(i: number): NumberContext | null;
+    Comma(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class LimitTagContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LeftBracket(): antlr.TerminalNode | null;
+    RightBracket(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class StaticValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Static(): antlr.TerminalNode;
+    fieldName(): FieldNameContext | null;
+    String(): antlr.TerminalNode | null;
+    number(): NumberContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class NumberContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Float(): antlr.TerminalNode | null;
+    Integer(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ScopeValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    String(): antlr.TerminalNode | null;
+    number(): NumberContext | null;
+    datatype(): DatatypeContext | null;
+    LeftParen(): antlr.TerminalNode | null;
+    RightParen(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ImplementsPartContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Implements(): antlr.TerminalNode;
+    datatype(): DatatypeContext[];
+    datatype(i: number): DatatypeContext | null;
+    Comma(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ExtendsPartContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Extends(): antlr.TerminalNode;
+    datatype(): DatatypeContext;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class PackageDeclareContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Package(): antlr.TerminalNode;
+    Semicolon(): antlr.TerminalNode;
+    packageName(): PackageNameContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class DatatypeContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    className(): ClassNameContext;
+    packageName(): PackageNameContext | null;
+    Dot(): antlr.TerminalNode | null;
+    arrayTag(): ArrayTagContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ArrayTagContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LeftBracket(): antlr.TerminalNode;
+    RightBracket(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class PackageNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Identifier(): antlr.TerminalNode[];
+    Identifier(i: number): antlr.TerminalNode | null;
+    Dot(): antlr.TerminalNode[];
+    Dot(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class PropertyItemContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Property(): antlr.TerminalNode;
+    propertyName(): PropertyNameContext;
+    String(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class PropertyNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Identifier(): antlr.TerminalNode | null;
+    String(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class ClassNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Identifier(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class FieldNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Identifier(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}
+export declare class MethodNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Identifier(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: BomParserListener): void;
+    exitRule(listener: BomParserListener): void;
+    accept<Result>(visitor: BomParserVisitor<Result>): Result | null;
+}