ifc-expressions 2.3.0 → 3.0.0-beta.2

package/dist/gen/parser/IfcExpressionParser.d.ts

@@ -1,7 +1,8 @@
-import { ATN, DFA, FailedPredicateException, Parser, RuleContext, ParserRuleContext, TerminalNode, Token, TokenStream } from 'antlr4';
-import IfcExpressionListener from "./IfcExpressionListener.js";
-import IfcExpressionVisitor from "./IfcExpressionVisitor.js";
-export default class IfcExpressionParser extends Parser {
+import * as antlr from "antlr4ng";
+import { Token } from "antlr4ng";
+import { IfcExpressionListener } from "./IfcExpressionListener.js";
+import { IfcExpressionVisitor } from "./IfcExpressionVisitor.js";
+export declare class IfcExpressionParser extends antlr.Parser {
     static readonly T__0 = 1;
     static readonly T__1 = 2;
     static readonly T__2 = 3;
@@ -26,34 +27,35 @@ export default class IfcExpressionParser extends Parser {
     static readonly NEWLINE = 22;
     static readonly BOOLEAN_BINARY_OP = 23;
     static readonly CMP_OP = 24;
-    static readonly EOF: number;
     static readonly RULE_expr = 0;
     static readonly RULE_singleExpr = 1;
     static readonly RULE_methodCallChain = 2;
-    static readonly RULE_functionCall = 3;
-    static readonly RULE_exprList = 4;
-    static readonly RULE_arrayExpr = 5;
-    static readonly RULE_arrayElementList = 6;
-    static readonly RULE_literal = 7;
-    static readonly RULE_numLiteral = 8;
-    static readonly RULE_stringLiteral = 9;
-    static readonly RULE_booleanLiteral = 10;
-    static readonly RULE_logicalLiteral = 11;
-    static readonly RULE_variableRef = 12;
-    static readonly literalNames: (string | null)[];
-    static readonly symbolicNames: (string | null)[];
+    static readonly RULE_methodAccessor = 3;
+    static readonly RULE_functionCall = 4;
+    static readonly RULE_exprList = 5;
+    static readonly RULE_arrayExpr = 6;
+    static readonly RULE_arrayElementList = 7;
+    static readonly RULE_literal = 8;
+    static readonly RULE_numLiteral = 9;
+    static readonly RULE_stringLiteral = 10;
+    static readonly RULE_booleanLiteral = 11;
+    static readonly RULE_logicalLiteral = 12;
+    static readonly RULE_variableRef = 13;
+    static readonly literalNames: string[];
+    static readonly symbolicNames: string[];
     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): FailedPredicateException;
-    constructor(input: TokenStream);
+    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException;
+    constructor(input: antlr.TokenStream);
     expr(): ExprContext;
     singleExpr(): SingleExprContext;
     singleExpr(_p: number): SingleExprContext;
     methodCallChain(): MethodCallChainContext;
+    methodAccessor(): MethodAccessorContext;
     functionCall(): FunctionCallContext;
     exprList(): ExprListContext;
     arrayExpr(): ArrayExprContext;
@@ -64,268 +66,289 @@ export default class IfcExpressionParser extends Parser {
     booleanLiteral(): BooleanLiteralContext;
     logicalLiteral(): LogicalLiteralContext;
     variableRef(): VariableRefContext;
-    sempred(localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
+    sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
     private singleExpr_sempred;
     static readonly _serializedATN: number[];
     private static __ATN;
-    static get _ATN(): ATN;
-    static DecisionsToDFA: DFA[];
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
 }
-export declare class ExprContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
+export declare class ExprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     singleExpr(): SingleExprContext;
-    EOF(): TerminalNode;
+    EOF(): antlr.TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SingleExprContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
+export declare class SingleExprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     get ruleIndex(): number;
     copyFrom(ctx: SingleExprContext): void;
 }
-export declare class SEComparisonContext extends SingleExprContext {
-    _left: SingleExprContext;
-    _right: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    CMP_OP(): TerminalNode;
-    singleExpr_list(): SingleExprContext[];
-    singleExpr(i: number): SingleExprContext;
-    enterRule(listener: IfcExpressionListener): void;
-    exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
-}
-export declare class SELiteralContext extends SingleExprContext {
-    _sub: LiteralContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    literal(): LiteralContext;
+export declare class SEUnaryMultipleMinusContext extends SingleExprContext {
+    _sub?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
 export declare class SEParenthesisContext extends SingleExprContext {
-    _sub: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
+    _sub?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
     singleExpr(): SingleExprContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEMulDivContext extends SingleExprContext {
-    _left: SingleExprContext;
-    _op: Token;
-    _right: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr_list(): SingleExprContext[];
-    singleExpr(i: number): SingleExprContext;
+export declare class SEUnaryMinusContext extends SingleExprContext {
+    _sub?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEPowerContext extends SingleExprContext {
-    _left: SingleExprContext;
-    _op: Token;
-    _right: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr_list(): SingleExprContext[];
-    singleExpr(i: number): SingleExprContext;
+export declare class SENotContext extends SingleExprContext {
+    _sub?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEBooleanBinaryOpContext extends SingleExprContext {
-    _left: SingleExprContext;
-    _op: Token;
-    _right: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr_list(): SingleExprContext[];
-    singleExpr(i: number): SingleExprContext;
-    BOOLEAN_BINARY_OP(): TerminalNode;
+export declare class SEVariableRefContext extends SingleExprContext {
+    _sub?: VariableRefContext;
+    constructor(ctx: SingleExprContext);
+    variableRef(): VariableRefContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
 export declare class SEFunctionCallContext extends SingleExprContext {
-    _sub: FunctionCallContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
+    _sub?: FunctionCallContext;
+    constructor(ctx: SingleExprContext);
     functionCall(): FunctionCallContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
+}
+export declare class SELiteralContext extends SingleExprContext {
+    _sub?: LiteralContext;
+    constructor(ctx: SingleExprContext);
+    literal(): LiteralContext;
+    enterRule(listener: IfcExpressionListener): void;
+    exitRule(listener: IfcExpressionListener): void;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
 export declare class SEArrayExprContext extends SingleExprContext {
-    _sub: ArrayExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
+    _sub?: ArrayExprContext;
+    constructor(ctx: SingleExprContext);
     arrayExpr(): ArrayExprContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SENotContext extends SingleExprContext {
-    _sub: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr(): SingleExprContext;
+export declare class SEPowerContext extends SingleExprContext {
+    _left?: SingleExprContext;
+    _op?: Token | null;
+    _right?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext[];
+    singleExpr(i: number): SingleExprContext | null;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEVariableRefContext extends SingleExprContext {
-    _sub: VariableRefContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    variableRef(): VariableRefContext;
+export declare class SEMulDivContext extends SingleExprContext {
+    _left?: SingleExprContext;
+    _op?: Token | null;
+    _right?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext[];
+    singleExpr(i: number): SingleExprContext | null;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEUnaryMultipleMinusContext extends SingleExprContext {
-    _sub: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr(): SingleExprContext;
+export declare class SEAddSubContext extends SingleExprContext {
+    _left?: SingleExprContext;
+    _op?: Token | null;
+    _right?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext[];
+    singleExpr(i: number): SingleExprContext | null;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEUnaryMinusContext extends SingleExprContext {
-    _sub: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr(): SingleExprContext;
+export declare class SEComparisonContext extends SingleExprContext {
+    _left?: SingleExprContext;
+    _right?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    CMP_OP(): antlr.TerminalNode;
+    singleExpr(): SingleExprContext[];
+    singleExpr(i: number): SingleExprContext | null;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class SEAddSubContext extends SingleExprContext {
-    _left: SingleExprContext;
-    _op: Token;
-    _right: SingleExprContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
-    singleExpr_list(): SingleExprContext[];
-    singleExpr(i: number): SingleExprContext;
+export declare class SEBooleanBinaryOpContext extends SingleExprContext {
+    _left?: SingleExprContext;
+    _op?: Token | null;
+    _right?: SingleExprContext;
+    constructor(ctx: SingleExprContext);
+    singleExpr(): SingleExprContext[];
+    singleExpr(i: number): SingleExprContext | null;
+    BOOLEAN_BINARY_OP(): antlr.TerminalNode;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
 export declare class SEMethodCallContext extends SingleExprContext {
-    _target: SingleExprContext;
-    _call: MethodCallChainContext;
-    constructor(parser: IfcExpressionParser, ctx: SingleExprContext);
+    _target?: SingleExprContext;
+    _call?: MethodCallChainContext;
+    constructor(ctx: SingleExprContext);
     singleExpr(): SingleExprContext;
     methodCallChain(): MethodCallChainContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class MethodCallChainContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
+export declare class MethodCallChainContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     get ruleIndex(): number;
     copyFrom(ctx: MethodCallChainContext): void;
 }
 export declare class MethodCallChainInnerContext extends MethodCallChainContext {
-    _target: FunctionCallContext;
-    _call: MethodCallChainContext;
-    constructor(parser: IfcExpressionParser, ctx: MethodCallChainContext);
-    DOT(): TerminalNode;
-    functionCall(): FunctionCallContext;
+    _target?: MethodAccessorContext;
+    _call?: MethodCallChainContext;
+    constructor(ctx: MethodCallChainContext);
+    DOT(): antlr.TerminalNode;
+    methodAccessor(): MethodAccessorContext;
     methodCallChain(): MethodCallChainContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
 export declare class MethodCallChainEndContext extends MethodCallChainContext {
-    _call: FunctionCallContext;
-    constructor(parser: IfcExpressionParser, ctx: MethodCallChainContext);
-    DOT(): TerminalNode;
+    _call?: MethodAccessorContext;
+    constructor(ctx: MethodCallChainContext);
+    DOT(): antlr.TerminalNode;
+    methodAccessor(): MethodAccessorContext;
+    enterRule(listener: IfcExpressionListener): void;
+    exitRule(listener: IfcExpressionListener): void;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
+}
+export declare class MethodAccessorContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: MethodAccessorContext): void;
+}
+export declare class MethodFunctionCallContext extends MethodAccessorContext {
+    constructor(ctx: MethodAccessorContext);
     functionCall(): FunctionCallContext;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class FunctionCallContext extends ParserRuleContext {
-    _sub: ExprListContext;
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    IDENTIFIER(): TerminalNode;
-    exprList(): ExprListContext;
+export declare class MethodPropertyAccessContext extends MethodAccessorContext {
+    constructor(ctx: MethodAccessorContext);
+    IDENTIFIER(): antlr.TerminalNode;
+    enterRule(listener: IfcExpressionListener): void;
+    exitRule(listener: IfcExpressionListener): void;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
+}
+export declare class FunctionCallContext extends antlr.ParserRuleContext {
+    _sub?: ExprListContext;
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    IDENTIFIER(): antlr.TerminalNode;
+    exprList(): ExprListContext | null;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class ExprListContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
+export declare class ExprListContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     singleExpr(): SingleExprContext;
-    exprList(): ExprListContext;
+    exprList(): ExprListContext | null;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class ArrayExprContext extends ParserRuleContext {
-    _sub: ArrayElementListContext;
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    arrayElementList(): ArrayElementListContext;
+export declare class ArrayExprContext extends antlr.ParserRuleContext {
+    _sub?: ArrayElementListContext;
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    arrayElementList(): ArrayElementListContext | null;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class ArrayElementListContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
+export declare class ArrayElementListContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     singleExpr(): SingleExprContext;
-    arrayElementList(): ArrayElementListContext;
+    arrayElementList(): ArrayElementListContext | null;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class LiteralContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    numLiteral(): NumLiteralContext;
-    stringLiteral(): StringLiteralContext;
-    booleanLiteral(): BooleanLiteralContext;
-    logicalLiteral(): LogicalLiteralContext;
+export declare class LiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    numLiteral(): NumLiteralContext | null;
+    stringLiteral(): StringLiteralContext | null;
+    booleanLiteral(): BooleanLiteralContext | null;
+    logicalLiteral(): LogicalLiteralContext | null;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class NumLiteralContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    INT(): TerminalNode;
-    FLOAT(): TerminalNode;
+export declare class NumLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    INT(): antlr.TerminalNode | null;
+    FLOAT(): antlr.TerminalNode | null;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class StringLiteralContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    QUOTED_STRING(): TerminalNode;
+export declare class StringLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    QUOTED_STRING(): antlr.TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class BooleanLiteralContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    BOOLEAN(): TerminalNode;
+export declare class BooleanLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    BOOLEAN(): antlr.TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class LogicalLiteralContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    LOGICAL_UNKNOWN(): TerminalNode;
+export declare class LogicalLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LOGICAL_UNKNOWN(): antlr.TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }
-export declare class VariableRefContext extends ParserRuleContext {
-    constructor(parser?: IfcExpressionParser, parent?: ParserRuleContext, invokingState?: number);
-    IDENTIFIER(): TerminalNode;
+export declare class VariableRefContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    IDENTIFIER(): antlr.TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: IfcExpressionListener): void;
     exitRule(listener: IfcExpressionListener): void;
-    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result;
+    accept<Result>(visitor: IfcExpressionVisitor<Result>): Result | null;
 }