sof-mssql 1.0.0

package/dist/generated/grammar/fhirpathParser.js

@@ -0,0 +1,3022 @@
+"use strict";
+// Generated from grammar/fhirpath.g4 by ANTLR 4.9.0-SNAPSHOT
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierContext = exports.QualifiedIdentifierContext = exports.TypeSpecifierContext = exports.PluralDateTimePrecisionContext = exports.DateTimePrecisionContext = exports.UnitContext = exports.QuantityContext = exports.ParamListContext = exports.FunctionContext = exports.TotalInvocationContext = exports.IndexInvocationContext = exports.ThisInvocationContext = exports.FunctionInvocationContext = exports.MemberInvocationContext = exports.InvocationContext = exports.ExternalConstantContext = exports.QuantityLiteralContext = exports.TimeLiteralContext = exports.DateTimeLiteralContext = exports.DateLiteralContext = exports.LongNumberLiteralContext = exports.NumberLiteralContext = exports.StringLiteralContext = exports.BooleanLiteralContext = exports.NullLiteralContext = exports.LiteralContext = exports.ParenthesizedTermContext = exports.ExternalConstantTermContext = exports.LiteralTermContext = exports.InvocationTermContext = exports.TermContext = exports.ImpliesExpressionContext = exports.OrExpressionContext = exports.AndExpressionContext = exports.MembershipExpressionContext = exports.EqualityExpressionContext = exports.InequalityExpressionContext = exports.UnionExpressionContext = exports.TypeExpressionContext = exports.AdditiveExpressionContext = exports.MultiplicativeExpressionContext = exports.PolarityExpressionContext = exports.IndexerExpressionContext = exports.InvocationExpressionContext = exports.TermExpressionContext = exports.ExpressionContext = exports.EntireExpressionContext = exports.fhirpathParser = void 0;
+const ATN_1 = require("antlr4ts/atn/ATN");
+const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
+const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
+const NoViableAltException_1 = require("antlr4ts/NoViableAltException");
+const Parser_1 = require("antlr4ts/Parser");
+const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
+const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
+const RecognitionException_1 = require("antlr4ts/RecognitionException");
+const Token_1 = require("antlr4ts/Token");
+const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
+const Utils = __importStar(require("antlr4ts/misc/Utils"));
+class fhirpathParser extends Parser_1.Parser {
+    static T__0 = 1;
+    static T__1 = 2;
+    static T__2 = 3;
+    static T__3 = 4;
+    static T__4 = 5;
+    static T__5 = 6;
+    static T__6 = 7;
+    static T__7 = 8;
+    static T__8 = 9;
+    static T__9 = 10;
+    static T__10 = 11;
+    static T__11 = 12;
+    static T__12 = 13;
+    static T__13 = 14;
+    static T__14 = 15;
+    static T__15 = 16;
+    static T__16 = 17;
+    static T__17 = 18;
+    static T__18 = 19;
+    static T__19 = 20;
+    static T__20 = 21;
+    static T__21 = 22;
+    static T__22 = 23;
+    static T__23 = 24;
+    static T__24 = 25;
+    static T__25 = 26;
+    static T__26 = 27;
+    static T__27 = 28;
+    static T__28 = 29;
+    static T__29 = 30;
+    static T__30 = 31;
+    static T__31 = 32;
+    static T__32 = 33;
+    static T__33 = 34;
+    static T__34 = 35;
+    static T__35 = 36;
+    static T__36 = 37;
+    static T__37 = 38;
+    static T__38 = 39;
+    static T__39 = 40;
+    static T__40 = 41;
+    static T__41 = 42;
+    static T__42 = 43;
+    static T__43 = 44;
+    static T__44 = 45;
+    static T__45 = 46;
+    static T__46 = 47;
+    static T__47 = 48;
+    static T__48 = 49;
+    static T__49 = 50;
+    static T__50 = 51;
+    static T__51 = 52;
+    static T__52 = 53;
+    static T__53 = 54;
+    static DATE = 55;
+    static DATETIME = 56;
+    static TIME = 57;
+    static IDENTIFIER = 58;
+    static DELIMITEDIDENTIFIER = 59;
+    static STRING = 60;
+    static NUMBER = 61;
+    static LONGNUMBER = 62;
+    static WS = 63;
+    static COMMENT = 64;
+    static LINE_COMMENT = 65;
+    static RULE_entireExpression = 0;
+    static RULE_expression = 1;
+    static RULE_term = 2;
+    static RULE_literal = 3;
+    static RULE_externalConstant = 4;
+    static RULE_invocation = 5;
+    static RULE_function = 6;
+    static RULE_paramList = 7;
+    static RULE_quantity = 8;
+    static RULE_unit = 9;
+    static RULE_dateTimePrecision = 10;
+    static RULE_pluralDateTimePrecision = 11;
+    static RULE_typeSpecifier = 12;
+    static RULE_qualifiedIdentifier = 13;
+    static RULE_identifier = 14;
+    // tslint:disable:no-trailing-whitespace
+    static ruleNames = [
+        "entireExpression",
+        "expression",
+        "term",
+        "literal",
+        "externalConstant",
+        "invocation",
+        "function",
+        "paramList",
+        "quantity",
+        "unit",
+        "dateTimePrecision",
+        "pluralDateTimePrecision",
+        "typeSpecifier",
+        "qualifiedIdentifier",
+        "identifier",
+    ];
+    static _LITERAL_NAMES = [
+        undefined,
+        "'.'",
+        "'['",
+        "']'",
+        "'+'",
+        "'-'",
+        "'*'",
+        "'/'",
+        "'div'",
+        "'mod'",
+        "'&'",
+        "'is'",
+        "'as'",
+        "'|'",
+        "'<='",
+        "'<'",
+        "'>'",
+        "'>='",
+        "'='",
+        "'~'",
+        "'!='",
+        "'!~'",
+        "'in'",
+        "'contains'",
+        "'and'",
+        "'or'",
+        "'xor'",
+        "'implies'",
+        "'('",
+        "')'",
+        "'{'",
+        "'}'",
+        "'true'",
+        "'false'",
+        "'%'",
+        "'$this'",
+        "'$index'",
+        "'$total'",
+        "','",
+        "'year'",
+        "'month'",
+        "'week'",
+        "'day'",
+        "'hour'",
+        "'minute'",
+        "'second'",
+        "'millisecond'",
+        "'years'",
+        "'months'",
+        "'weeks'",
+        "'days'",
+        "'hours'",
+        "'minutes'",
+        "'seconds'",
+        "'milliseconds'",
+    ];
+    static _SYMBOLIC_NAMES = [
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        "DATE",
+        "DATETIME",
+        "TIME",
+        "IDENTIFIER",
+        "DELIMITEDIDENTIFIER",
+        "STRING",
+        "NUMBER",
+        "LONGNUMBER",
+        "WS",
+        "COMMENT",
+        "LINE_COMMENT",
+    ];
+    static VOCABULARY = new VocabularyImpl_1.VocabularyImpl(fhirpathParser._LITERAL_NAMES, fhirpathParser._SYMBOLIC_NAMES, []);
+    // @Override
+    // @NotNull
+    get vocabulary() {
+        return fhirpathParser.VOCABULARY;
+    }
+    // tslint:enable:no-trailing-whitespace
+    // @Override
+    get grammarFileName() {
+        return "fhirpath.g4";
+    }
+    // @Override
+    get ruleNames() {
+        return fhirpathParser.ruleNames;
+    }
+    // @Override
+    get serializedATN() {
+        return fhirpathParser._serializedATN;
+    }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(fhirpathParser._ATN, this);
+    }
+    // @RuleVersion(0)
+    entireExpression() {
+        let _localctx = new EntireExpressionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, fhirpathParser.RULE_entireExpression);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 30;
+                this.expression(0);
+                this.state = 31;
+                this.match(fhirpathParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    expression(_p) {
+        if (_p === undefined) {
+            _p = 0;
+        }
+        let _parentctx = this._ctx;
+        let _parentState = this.state;
+        let _localctx = new ExpressionContext(this._ctx, _parentState);
+        let _prevctx = _localctx;
+        let _startState = 2;
+        this.enterRecursionRule(_localctx, 2, fhirpathParser.RULE_expression, _p);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 37;
+                this._errHandler.sync(this);
+                switch (this._input.LA(1)) {
+                    case fhirpathParser.T__10:
+                    case fhirpathParser.T__11:
+                    case fhirpathParser.T__21:
+                    case fhirpathParser.T__22:
+                    case fhirpathParser.T__27:
+                    case fhirpathParser.T__29:
+                    case fhirpathParser.T__31:
+                    case fhirpathParser.T__32:
+                    case fhirpathParser.T__33:
+                    case fhirpathParser.T__34:
+                    case fhirpathParser.T__35:
+                    case fhirpathParser.T__36:
+                    case fhirpathParser.DATE:
+                    case fhirpathParser.DATETIME:
+                    case fhirpathParser.TIME:
+                    case fhirpathParser.IDENTIFIER:
+                    case fhirpathParser.DELIMITEDIDENTIFIER:
+                    case fhirpathParser.STRING:
+                    case fhirpathParser.NUMBER:
+                    case fhirpathParser.LONGNUMBER:
+                        {
+                            _localctx = new TermExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 34;
+                            this.term();
+                        }
+                        break;
+                    case fhirpathParser.T__3:
+                    case fhirpathParser.T__4:
+                        {
+                            _localctx = new PolarityExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 35;
+                            _la = this._input.LA(1);
+                            if (!(_la === fhirpathParser.T__3 || _la === fhirpathParser.T__4)) {
+                                this._errHandler.recoverInline(this);
+                            }
+                            else {
+                                if (this._input.LA(1) === Token_1.Token.EOF) {
+                                    this.matchedEOF = true;
+                                }
+                                this._errHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            this.state = 36;
+                            this.expression(11);
+                        }
+                        break;
+                    default:
+                        throw new NoViableAltException_1.NoViableAltException(this);
+                }
+                this._ctx._stop = this._input.tryLT(-1);
+                this.state = 79;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 2, this._ctx);
+                while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        if (this._parseListeners != null) {
+                            this.triggerExitRuleEvent();
+                        }
+                        _prevctx = _localctx;
+                        {
+                            this.state = 77;
+                            this._errHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this._input, 1, this._ctx)) {
+                                case 1:
+                                    {
+                                        _localctx = new MultiplicativeExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 39;
+                                        if (!this.precpred(this._ctx, 10)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 10)");
+                                        }
+                                        this.state = 40;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << fhirpathParser.T__5) |
+                                                    (1 << fhirpathParser.T__6) |
+                                                    (1 << fhirpathParser.T__7) |
+                                                    (1 << fhirpathParser.T__8))) !==
+                                                0)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 41;
+                                        this.expression(11);
+                                    }
+                                    break;
+                                case 2:
+                                    {
+                                        _localctx = new AdditiveExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 42;
+                                        if (!this.precpred(this._ctx, 9)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
+                                        }
+                                        this.state = 43;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << fhirpathParser.T__3) |
+                                                    (1 << fhirpathParser.T__4) |
+                                                    (1 << fhirpathParser.T__9))) !==
+                                                0)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 44;
+                                        this.expression(10);
+                                    }
+                                    break;
+                                case 3:
+                                    {
+                                        _localctx = new UnionExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 45;
+                                        if (!this.precpred(this._ctx, 7)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
+                                        }
+                                        this.state = 46;
+                                        this.match(fhirpathParser.T__12);
+                                        this.state = 47;
+                                        this.expression(8);
+                                    }
+                                    break;
+                                case 4:
+                                    {
+                                        _localctx = new InequalityExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 48;
+                                        if (!this.precpred(this._ctx, 6)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
+                                        }
+                                        this.state = 49;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << fhirpathParser.T__13) |
+                                                    (1 << fhirpathParser.T__14) |
+                                                    (1 << fhirpathParser.T__15) |
+                                                    (1 << fhirpathParser.T__16))) !==
+                                                0)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 50;
+                                        this.expression(7);
+                                    }
+                                    break;
+                                case 5:
+                                    {
+                                        _localctx = new EqualityExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 51;
+                                        if (!this.precpred(this._ctx, 5)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
+                                        }
+                                        this.state = 52;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << fhirpathParser.T__17) |
+                                                    (1 << fhirpathParser.T__18) |
+                                                    (1 << fhirpathParser.T__19) |
+                                                    (1 << fhirpathParser.T__20))) !==
+                                                0)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 53;
+                                        this.expression(6);
+                                    }
+                                    break;
+                                case 6:
+                                    {
+                                        _localctx = new MembershipExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 54;
+                                        if (!this.precpred(this._ctx, 4)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
+                                        }
+                                        this.state = 55;
+                                        _la = this._input.LA(1);
+                                        if (!(_la === fhirpathParser.T__21 ||
+                                            _la === fhirpathParser.T__22)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 56;
+                                        this.expression(5);
+                                    }
+                                    break;
+                                case 7:
+                                    {
+                                        _localctx = new AndExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 57;
+                                        if (!this.precpred(this._ctx, 3)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
+                                        }
+                                        this.state = 58;
+                                        this.match(fhirpathParser.T__23);
+                                        this.state = 59;
+                                        this.expression(4);
+                                    }
+                                    break;
+                                case 8:
+                                    {
+                                        _localctx = new OrExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 60;
+                                        if (!this.precpred(this._ctx, 2)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
+                                        }
+                                        this.state = 61;
+                                        _la = this._input.LA(1);
+                                        if (!(_la === fhirpathParser.T__24 ||
+                                            _la === fhirpathParser.T__25)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 62;
+                                        this.expression(3);
+                                    }
+                                    break;
+                                case 9:
+                                    {
+                                        _localctx = new ImpliesExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 63;
+                                        if (!this.precpred(this._ctx, 1)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
+                                        }
+                                        this.state = 64;
+                                        this.match(fhirpathParser.T__26);
+                                        this.state = 65;
+                                        this.expression(2);
+                                    }
+                                    break;
+                                case 10:
+                                    {
+                                        _localctx = new InvocationExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 66;
+                                        if (!this.precpred(this._ctx, 13)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 13)");
+                                        }
+                                        this.state = 67;
+                                        this.match(fhirpathParser.T__0);
+                                        this.state = 68;
+                                        this.invocation();
+                                    }
+                                    break;
+                                case 11:
+                                    {
+                                        _localctx = new IndexerExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 69;
+                                        if (!this.precpred(this._ctx, 12)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 12)");
+                                        }
+                                        this.state = 70;
+                                        this.match(fhirpathParser.T__1);
+                                        this.state = 71;
+                                        this.expression(0);
+                                        this.state = 72;
+                                        this.match(fhirpathParser.T__2);
+                                    }
+                                    break;
+                                case 12:
+                                    {
+                                        _localctx = new TypeExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, fhirpathParser.RULE_expression);
+                                        this.state = 74;
+                                        if (!this.precpred(this._ctx, 8)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 8)");
+                                        }
+                                        this.state = 75;
+                                        _la = this._input.LA(1);
+                                        if (!(_la === fhirpathParser.T__10 ||
+                                            _la === fhirpathParser.T__11)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 76;
+                                        this.typeSpecifier();
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    this.state = 81;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 2, this._ctx);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(_parentctx);
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    term() {
+        let _localctx = new TermContext(this._ctx, this.state);
+        this.enterRule(_localctx, 4, fhirpathParser.RULE_term);
+        try {
+            this.state = 89;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case fhirpathParser.T__10:
+                case fhirpathParser.T__11:
+                case fhirpathParser.T__21:
+                case fhirpathParser.T__22:
+                case fhirpathParser.T__34:
+                case fhirpathParser.T__35:
+                case fhirpathParser.T__36:
+                case fhirpathParser.IDENTIFIER:
+                case fhirpathParser.DELIMITEDIDENTIFIER:
+                    _localctx = new InvocationTermContext(_localctx);
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 82;
+                        this.invocation();
+                    }
+                    break;
+                case fhirpathParser.T__29:
+                case fhirpathParser.T__31:
+                case fhirpathParser.T__32:
+                case fhirpathParser.DATE:
+                case fhirpathParser.DATETIME:
+                case fhirpathParser.TIME:
+                case fhirpathParser.STRING:
+                case fhirpathParser.NUMBER:
+                case fhirpathParser.LONGNUMBER:
+                    _localctx = new LiteralTermContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 83;
+                        this.literal();
+                    }
+                    break;
+                case fhirpathParser.T__33:
+                    _localctx = new ExternalConstantTermContext(_localctx);
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 84;
+                        this.externalConstant();
+                    }
+                    break;
+                case fhirpathParser.T__27:
+                    _localctx = new ParenthesizedTermContext(_localctx);
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 85;
+                        this.match(fhirpathParser.T__27);
+                        this.state = 86;
+                        this.expression(0);
+                        this.state = 87;
+                        this.match(fhirpathParser.T__28);
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    literal() {
+        let _localctx = new LiteralContext(this._ctx, this.state);
+        this.enterRule(_localctx, 6, fhirpathParser.RULE_literal);
+        let _la;
+        try {
+            this.state = 101;
+            this._errHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this._input, 4, this._ctx)) {
+                case 1:
+                    _localctx = new NullLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 91;
+                        this.match(fhirpathParser.T__29);
+                        this.state = 92;
+                        this.match(fhirpathParser.T__30);
+                    }
+                    break;
+                case 2:
+                    _localctx = new BooleanLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 93;
+                        _la = this._input.LA(1);
+                        if (!(_la === fhirpathParser.T__31 || _la === fhirpathParser.T__32)) {
+                            this._errHandler.recoverInline(this);
+                        }
+                        else {
+                            if (this._input.LA(1) === Token_1.Token.EOF) {
+                                this.matchedEOF = true;
+                            }
+                            this._errHandler.reportMatch(this);
+                            this.consume();
+                        }
+                    }
+                    break;
+                case 3:
+                    _localctx = new StringLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 94;
+                        this.match(fhirpathParser.STRING);
+                    }
+                    break;
+                case 4:
+                    _localctx = new NumberLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 95;
+                        this.match(fhirpathParser.NUMBER);
+                    }
+                    break;
+                case 5:
+                    _localctx = new LongNumberLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 5);
+                    {
+                        this.state = 96;
+                        this.match(fhirpathParser.LONGNUMBER);
+                    }
+                    break;
+                case 6:
+                    _localctx = new DateLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 6);
+                    {
+                        this.state = 97;
+                        this.match(fhirpathParser.DATE);
+                    }
+                    break;
+                case 7:
+                    _localctx = new DateTimeLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 7);
+                    {
+                        this.state = 98;
+                        this.match(fhirpathParser.DATETIME);
+                    }
+                    break;
+                case 8:
+                    _localctx = new TimeLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 8);
+                    {
+                        this.state = 99;
+                        this.match(fhirpathParser.TIME);
+                    }
+                    break;
+                case 9:
+                    _localctx = new QuantityLiteralContext(_localctx);
+                    this.enterOuterAlt(_localctx, 9);
+                    {
+                        this.state = 100;
+                        this.quantity();
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    externalConstant() {
+        let _localctx = new ExternalConstantContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, fhirpathParser.RULE_externalConstant);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 103;
+                this.match(fhirpathParser.T__33);
+                this.state = 106;
+                this._errHandler.sync(this);
+                switch (this._input.LA(1)) {
+                    case fhirpathParser.T__10:
+                    case fhirpathParser.T__11:
+                    case fhirpathParser.T__21:
+                    case fhirpathParser.T__22:
+                    case fhirpathParser.IDENTIFIER:
+                    case fhirpathParser.DELIMITEDIDENTIFIER:
+                        {
+                            this.state = 104;
+                            this.identifier();
+                        }
+                        break;
+                    case fhirpathParser.STRING:
+                        {
+                            this.state = 105;
+                            this.match(fhirpathParser.STRING);
+                        }
+                        break;
+                    default:
+                        throw new NoViableAltException_1.NoViableAltException(this);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    invocation() {
+        let _localctx = new InvocationContext(this._ctx, this.state);
+        this.enterRule(_localctx, 10, fhirpathParser.RULE_invocation);
+        try {
+            this.state = 113;
+            this._errHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this._input, 6, this._ctx)) {
+                case 1:
+                    _localctx = new MemberInvocationContext(_localctx);
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 108;
+                        this.identifier();
+                    }
+                    break;
+                case 2:
+                    _localctx = new FunctionInvocationContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 109;
+                        this.function();
+                    }
+                    break;
+                case 3:
+                    _localctx = new ThisInvocationContext(_localctx);
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 110;
+                        this.match(fhirpathParser.T__34);
+                    }
+                    break;
+                case 4:
+                    _localctx = new IndexInvocationContext(_localctx);
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 111;
+                        this.match(fhirpathParser.T__35);
+                    }
+                    break;
+                case 5:
+                    _localctx = new TotalInvocationContext(_localctx);
+                    this.enterOuterAlt(_localctx, 5);
+                    {
+                        this.state = 112;
+                        this.match(fhirpathParser.T__36);
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    function() {
+        let _localctx = new FunctionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 12, fhirpathParser.RULE_function);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 115;
+                this.identifier();
+                this.state = 116;
+                this.match(fhirpathParser.T__27);
+                this.state = 118;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (((_la & ~0x1f) === 0 &&
+                    ((1 << _la) &
+                        ((1 << fhirpathParser.T__3) |
+                            (1 << fhirpathParser.T__4) |
+                            (1 << fhirpathParser.T__10) |
+                            (1 << fhirpathParser.T__11) |
+                            (1 << fhirpathParser.T__21) |
+                            (1 << fhirpathParser.T__22) |
+                            (1 << fhirpathParser.T__27) |
+                            (1 << fhirpathParser.T__29))) !==
+                        0) ||
+                    (((_la - 32) & ~0x1f) === 0 &&
+                        ((1 << (_la - 32)) &
+                            ((1 << (fhirpathParser.T__31 - 32)) |
+                                (1 << (fhirpathParser.T__32 - 32)) |
+                                (1 << (fhirpathParser.T__33 - 32)) |
+                                (1 << (fhirpathParser.T__34 - 32)) |
+                                (1 << (fhirpathParser.T__35 - 32)) |
+                                (1 << (fhirpathParser.T__36 - 32)) |
+                                (1 << (fhirpathParser.DATE - 32)) |
+                                (1 << (fhirpathParser.DATETIME - 32)) |
+                                (1 << (fhirpathParser.TIME - 32)) |
+                                (1 << (fhirpathParser.IDENTIFIER - 32)) |
+                                (1 << (fhirpathParser.DELIMITEDIDENTIFIER - 32)) |
+                                (1 << (fhirpathParser.STRING - 32)) |
+                                (1 << (fhirpathParser.NUMBER - 32)) |
+                                (1 << (fhirpathParser.LONGNUMBER - 32)))) !==
+                            0)) {
+                    {
+                        this.state = 117;
+                        this.paramList();
+                    }
+                }
+                this.state = 120;
+                this.match(fhirpathParser.T__28);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    paramList() {
+        let _localctx = new ParamListContext(this._ctx, this.state);
+        this.enterRule(_localctx, 14, fhirpathParser.RULE_paramList);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 122;
+                this.expression(0);
+                this.state = 127;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === fhirpathParser.T__37) {
+                    {
+                        {
+                            this.state = 123;
+                            this.match(fhirpathParser.T__37);
+                            this.state = 124;
+                            this.expression(0);
+                        }
+                    }
+                    this.state = 129;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    quantity() {
+        let _localctx = new QuantityContext(this._ctx, this.state);
+        this.enterRule(_localctx, 16, fhirpathParser.RULE_quantity);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 130;
+                this.match(fhirpathParser.NUMBER);
+                this.state = 132;
+                this._errHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this._input, 9, this._ctx)) {
+                    case 1:
+                        {
+                            this.state = 131;
+                            this.unit();
+                        }
+                        break;
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    unit() {
+        let _localctx = new UnitContext(this._ctx, this.state);
+        this.enterRule(_localctx, 18, fhirpathParser.RULE_unit);
+        try {
+            this.state = 137;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case fhirpathParser.T__38:
+                case fhirpathParser.T__39:
+                case fhirpathParser.T__40:
+                case fhirpathParser.T__41:
+                case fhirpathParser.T__42:
+                case fhirpathParser.T__43:
+                case fhirpathParser.T__44:
+                case fhirpathParser.T__45:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 134;
+                        this.dateTimePrecision();
+                    }
+                    break;
+                case fhirpathParser.T__46:
+                case fhirpathParser.T__47:
+                case fhirpathParser.T__48:
+                case fhirpathParser.T__49:
+                case fhirpathParser.T__50:
+                case fhirpathParser.T__51:
+                case fhirpathParser.T__52:
+                case fhirpathParser.T__53:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 135;
+                        this.pluralDateTimePrecision();
+                    }
+                    break;
+                case fhirpathParser.STRING:
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 136;
+                        this.match(fhirpathParser.STRING);
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    dateTimePrecision() {
+        let _localctx = new DateTimePrecisionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 20, fhirpathParser.RULE_dateTimePrecision);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 139;
+                _la = this._input.LA(1);
+                if (!(((_la - 39) & ~0x1f) === 0 &&
+                    ((1 << (_la - 39)) &
+                        ((1 << (fhirpathParser.T__38 - 39)) |
+                            (1 << (fhirpathParser.T__39 - 39)) |
+                            (1 << (fhirpathParser.T__40 - 39)) |
+                            (1 << (fhirpathParser.T__41 - 39)) |
+                            (1 << (fhirpathParser.T__42 - 39)) |
+                            (1 << (fhirpathParser.T__43 - 39)) |
+                            (1 << (fhirpathParser.T__44 - 39)) |
+                            (1 << (fhirpathParser.T__45 - 39)))) !==
+                        0)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    pluralDateTimePrecision() {
+        let _localctx = new PluralDateTimePrecisionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 22, fhirpathParser.RULE_pluralDateTimePrecision);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 141;
+                _la = this._input.LA(1);
+                if (!(((_la - 47) & ~0x1f) === 0 &&
+                    ((1 << (_la - 47)) &
+                        ((1 << (fhirpathParser.T__46 - 47)) |
+                            (1 << (fhirpathParser.T__47 - 47)) |
+                            (1 << (fhirpathParser.T__48 - 47)) |
+                            (1 << (fhirpathParser.T__49 - 47)) |
+                            (1 << (fhirpathParser.T__50 - 47)) |
+                            (1 << (fhirpathParser.T__51 - 47)) |
+                            (1 << (fhirpathParser.T__52 - 47)) |
+                            (1 << (fhirpathParser.T__53 - 47)))) !==
+                        0)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    typeSpecifier() {
+        let _localctx = new TypeSpecifierContext(this._ctx, this.state);
+        this.enterRule(_localctx, 24, fhirpathParser.RULE_typeSpecifier);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 143;
+                this.qualifiedIdentifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    qualifiedIdentifier() {
+        let _localctx = new QualifiedIdentifierContext(this._ctx, this.state);
+        this.enterRule(_localctx, 26, fhirpathParser.RULE_qualifiedIdentifier);
+        try {
+            let _alt;
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 145;
+                this.identifier();
+                this.state = 150;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 11, this._ctx);
+                while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 146;
+                                this.match(fhirpathParser.T__0);
+                                this.state = 147;
+                                this.identifier();
+                            }
+                        }
+                    }
+                    this.state = 152;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 11, this._ctx);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    identifier() {
+        let _localctx = new IdentifierContext(this._ctx, this.state);
+        this.enterRule(_localctx, 28, fhirpathParser.RULE_identifier);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 153;
+                _la = this._input.LA(1);
+                if (!(((_la & ~0x1f) === 0 &&
+                    ((1 << _la) &
+                        ((1 << fhirpathParser.T__10) |
+                            (1 << fhirpathParser.T__11) |
+                            (1 << fhirpathParser.T__21) |
+                            (1 << fhirpathParser.T__22))) !==
+                        0) ||
+                    _la === fhirpathParser.IDENTIFIER ||
+                    _la === fhirpathParser.DELIMITEDIDENTIFIER)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    sempred(_localctx, ruleIndex, predIndex) {
+        switch (ruleIndex) {
+            case 1:
+                return this.expression_sempred(_localctx, predIndex);
+        }
+        return true;
+    }
+    expression_sempred(_localctx, predIndex) {
+        switch (predIndex) {
+            case 0:
+                return this.precpred(this._ctx, 10);
+            case 1:
+                return this.precpred(this._ctx, 9);
+            case 2:
+                return this.precpred(this._ctx, 7);
+            case 3:
+                return this.precpred(this._ctx, 6);
+            case 4:
+                return this.precpred(this._ctx, 5);
+            case 5:
+                return this.precpred(this._ctx, 4);
+            case 6:
+                return this.precpred(this._ctx, 3);
+            case 7:
+                return this.precpred(this._ctx, 2);
+            case 8:
+                return this.precpred(this._ctx, 1);
+            case 9:
+                return this.precpred(this._ctx, 13);
+            case 10:
+                return this.precpred(this._ctx, 12);
+            case 11:
+                return this.precpred(this._ctx, 8);
+        }
+        return true;
+    }
+    static _serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03C\x9E\x04\x02" +
+        "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
+        "\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
+        "\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x03\x02\x03\x02\x03\x02\x03\x03" +
+        "\x03\x03\x03\x03\x03\x03\x05\x03(\n\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+        "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+        "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+        "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+        "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x07\x03P\n\x03" +
+        "\f\x03\x0E\x03S\v\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
+        "\x03\x04\x05\x04\\\n\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
+        "\x03\x05\x03\x05\x03\x05\x03\x05\x05\x05h\n\x05\x03\x06\x03\x06\x03\x06" +
+        "\x05\x06m\n\x06\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x05\x07t\n\x07" +
+        "\x03\b\x03\b\x03\b\x05\by\n\b\x03\b\x03\b\x03\t\x03\t\x03\t\x07\t\x80" +
+        "\n\t\f\t\x0E\t\x83\v\t\x03\n\x03\n\x05\n\x87\n\n\x03\v\x03\v\x03\v\x05" +
+        "\v\x8C\n\v\x03\f\x03\f\x03\r\x03\r\x03\x0E\x03\x0E\x03\x0F\x03\x0F\x03" +
+        "\x0F\x07\x0F\x97\n\x0F\f\x0F\x0E\x0F\x9A\v\x0F\x03\x10\x03\x10\x03\x10" +
+        "\x02\x02\x03\x04\x11\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02" +
+        "\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02\x02\x0E" +
+        "\x03\x02\x06\x07\x03\x02\b\v\x04\x02\x06\x07\f\f\x03\x02\x10\x13\x03\x02" +
+        '\x14\x17\x03\x02\x18\x19\x03\x02\x1B\x1C\x03\x02\r\x0E\x03\x02"#\x03' +
+        "\x02)0\x03\x0218\x05\x02\r\x0E\x18\x19<=\x02\xB1\x02 \x03\x02\x02\x02" +
+        "\x04\'\x03\x02\x02\x02\x06[\x03\x02\x02\x02\bg\x03\x02\x02\x02\ni\x03" +
+        "\x02\x02\x02\fs\x03\x02\x02\x02\x0Eu\x03\x02\x02\x02\x10|\x03\x02\x02" +
+        "\x02\x12\x84\x03\x02\x02\x02\x14\x8B\x03\x02\x02\x02\x16\x8D\x03\x02\x02" +
+        "\x02\x18\x8F\x03\x02\x02\x02\x1A\x91\x03\x02\x02\x02\x1C\x93\x03\x02\x02" +
+        '\x02\x1E\x9B\x03\x02\x02\x02 !\x05\x04\x03\x02!"\x07\x02\x02\x03"\x03' +
+        "\x03\x02\x02\x02#$\b\x03\x01\x02$(\x05\x06\x04\x02%&\t\x02\x02\x02&(\x05" +
+        "\x04\x03\r\'#\x03\x02\x02\x02\'%\x03\x02\x02\x02(Q\x03\x02\x02\x02)*\f" +
+        "\f\x02\x02*+\t\x03\x02\x02+P\x05\x04\x03\r,-\f\v\x02\x02-.\t\x04\x02\x02" +
+        ".P\x05\x04\x03\f/0\f\t\x02\x0201\x07\x0F\x02\x021P\x05\x04\x03\n23\f\b" +
+        "\x02\x0234\t\x05\x02\x024P\x05\x04\x03\t56\f\x07\x02\x0267\t\x06\x02\x02" +
+        "7P\x05\x04\x03\b89\f\x06\x02\x029:\t\x07\x02\x02:P\x05\x04\x03\x07;<\f" +
+        "\x05\x02\x02<=\x07\x1A\x02\x02=P\x05\x04\x03\x06>?\f\x04\x02\x02?@\t\b" +
+        "\x02\x02@P\x05\x04\x03\x05AB\f\x03\x02\x02BC\x07\x1D\x02\x02CP\x05\x04" +
+        "\x03\x04DE\f\x0F\x02\x02EF\x07\x03\x02\x02FP\x05\f\x07\x02GH\f\x0E\x02" +
+        "\x02HI\x07\x04\x02\x02IJ\x05\x04\x03\x02JK\x07\x05\x02\x02KP\x03\x02\x02" +
+        "\x02LM\f\n\x02\x02MN\t\t\x02\x02NP\x05\x1A\x0E\x02O)\x03\x02\x02\x02O" +
+        ",\x03\x02\x02\x02O/\x03\x02\x02\x02O2\x03\x02\x02\x02O5\x03\x02\x02\x02" +
+        "O8\x03\x02\x02\x02O;\x03\x02\x02\x02O>\x03\x02\x02\x02OA\x03\x02\x02\x02" +
+        "OD\x03\x02\x02\x02OG\x03\x02\x02\x02OL\x03\x02\x02\x02PS\x03\x02\x02\x02" +
+        "QO\x03\x02\x02\x02QR\x03\x02\x02\x02R\x05\x03\x02\x02\x02SQ\x03\x02\x02" +
+        "\x02T\\\x05\f\x07\x02U\\\x05\b\x05\x02V\\\x05\n\x06\x02WX\x07\x1E\x02" +
+        "\x02XY\x05\x04\x03\x02YZ\x07\x1F\x02\x02Z\\\x03\x02\x02\x02[T\x03\x02" +
+        "\x02\x02[U\x03\x02\x02\x02[V\x03\x02\x02\x02[W\x03\x02\x02\x02\\\x07\x03" +
+        "\x02\x02\x02]^\x07 \x02\x02^h\x07!\x02\x02_h\t\n\x02\x02`h\x07>\x02\x02" +
+        "ah\x07?\x02\x02bh\x07@\x02\x02ch\x079\x02\x02dh\x07:\x02\x02eh\x07;\x02" +
+        "\x02fh\x05\x12\n\x02g]\x03\x02\x02\x02g_\x03\x02\x02\x02g`\x03\x02\x02" +
+        "\x02ga\x03\x02\x02\x02gb\x03\x02\x02\x02gc\x03\x02\x02\x02gd\x03\x02\x02" +
+        "\x02ge\x03\x02\x02\x02gf\x03\x02\x02\x02h\t\x03\x02\x02\x02il\x07$\x02" +
+        "\x02jm\x05\x1E\x10\x02km\x07>\x02\x02lj\x03\x02\x02\x02lk\x03\x02\x02" +
+        "\x02m\v\x03\x02\x02\x02nt\x05\x1E\x10\x02ot\x05\x0E\b\x02pt\x07%\x02\x02" +
+        "qt\x07&\x02\x02rt\x07\'\x02\x02sn\x03\x02\x02\x02so\x03\x02\x02\x02sp" +
+        "\x03\x02\x02\x02sq\x03\x02\x02\x02sr\x03\x02\x02\x02t\r\x03\x02\x02\x02" +
+        "uv\x05\x1E\x10\x02vx\x07\x1E\x02\x02wy\x05\x10\t\x02xw\x03\x02\x02\x02" +
+        "xy\x03\x02\x02\x02yz\x03\x02\x02\x02z{\x07\x1F\x02\x02{\x0F\x03\x02\x02" +
+        "\x02|\x81\x05\x04\x03\x02}~\x07(\x02\x02~\x80\x05\x04\x03\x02\x7F}\x03" +
+        "\x02\x02\x02\x80\x83\x03\x02\x02\x02\x81\x7F\x03\x02\x02\x02\x81\x82\x03" +
+        "\x02\x02\x02\x82\x11\x03\x02\x02\x02\x83\x81\x03\x02\x02\x02\x84\x86\x07" +
+        "?\x02\x02\x85\x87\x05\x14\v\x02\x86\x85\x03\x02\x02\x02\x86\x87\x03\x02" +
+        "\x02\x02\x87\x13\x03\x02\x02\x02\x88\x8C\x05\x16\f\x02\x89\x8C\x05\x18" +
+        "\r\x02\x8A\x8C\x07>\x02\x02\x8B\x88\x03\x02\x02\x02\x8B\x89\x03\x02\x02" +
+        "\x02\x8B\x8A\x03\x02\x02\x02\x8C\x15\x03\x02\x02\x02\x8D\x8E\t\v\x02\x02" +
+        "\x8E\x17\x03\x02\x02\x02\x8F\x90\t\f\x02\x02\x90\x19\x03\x02\x02\x02\x91" +
+        "\x92\x05\x1C\x0F\x02\x92\x1B\x03\x02\x02\x02\x93\x98\x05\x1E\x10\x02\x94" +
+        "\x95\x07\x03\x02\x02\x95\x97\x05\x1E\x10\x02\x96\x94\x03\x02\x02\x02\x97" +
+        "\x9A\x03\x02\x02\x02\x98\x96\x03\x02\x02\x02\x98\x99\x03\x02\x02\x02\x99" +
+        "\x1D\x03\x02\x02\x02\x9A\x98\x03\x02\x02\x02\x9B\x9C\t\r\x02\x02\x9C\x1F" +
+        "\x03\x02\x02\x02\x0E\'OQ[glsx\x81\x86\x8B\x98";
+    static __ATN;
+    static get _ATN() {
+        if (!fhirpathParser.__ATN) {
+            fhirpathParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(fhirpathParser._serializedATN));
+        }
+        return fhirpathParser.__ATN;
+    }
+}
+exports.fhirpathParser = fhirpathParser;
+class EntireExpressionContext extends ParserRuleContext_1.ParserRuleContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    EOF() {
+        return this.getToken(fhirpathParser.EOF, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_entireExpression;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterEntireExpression) {
+            listener.enterEntireExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitEntireExpression) {
+            listener.exitEntireExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitEntireExpression) {
+            return visitor.visitEntireExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.EntireExpressionContext = EntireExpressionContext;
+class ExpressionContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_expression;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.ExpressionContext = ExpressionContext;
+class TermExpressionContext extends ExpressionContext {
+    term() {
+        return this.getRuleContext(0, TermContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTermExpression) {
+            listener.enterTermExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTermExpression) {
+            listener.exitTermExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTermExpression) {
+            return visitor.visitTermExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TermExpressionContext = TermExpressionContext;
+class InvocationExpressionContext extends ExpressionContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    invocation() {
+        return this.getRuleContext(0, InvocationContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterInvocationExpression) {
+            listener.enterInvocationExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitInvocationExpression) {
+            listener.exitInvocationExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitInvocationExpression) {
+            return visitor.visitInvocationExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.InvocationExpressionContext = InvocationExpressionContext;
+class IndexerExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIndexerExpression) {
+            listener.enterIndexerExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIndexerExpression) {
+            listener.exitIndexerExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIndexerExpression) {
+            return visitor.visitIndexerExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IndexerExpressionContext = IndexerExpressionContext;
+class PolarityExpressionContext extends ExpressionContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterPolarityExpression) {
+            listener.enterPolarityExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitPolarityExpression) {
+            listener.exitPolarityExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitPolarityExpression) {
+            return visitor.visitPolarityExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.PolarityExpressionContext = PolarityExpressionContext;
+class MultiplicativeExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterMultiplicativeExpression) {
+            listener.enterMultiplicativeExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitMultiplicativeExpression) {
+            listener.exitMultiplicativeExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMultiplicativeExpression) {
+            return visitor.visitMultiplicativeExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.MultiplicativeExpressionContext = MultiplicativeExpressionContext;
+class AdditiveExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterAdditiveExpression) {
+            listener.enterAdditiveExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitAdditiveExpression) {
+            listener.exitAdditiveExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAdditiveExpression) {
+            return visitor.visitAdditiveExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.AdditiveExpressionContext = AdditiveExpressionContext;
+class TypeExpressionContext extends ExpressionContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    typeSpecifier() {
+        return this.getRuleContext(0, TypeSpecifierContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTypeExpression) {
+            listener.enterTypeExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTypeExpression) {
+            listener.exitTypeExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTypeExpression) {
+            return visitor.visitTypeExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TypeExpressionContext = TypeExpressionContext;
+class UnionExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterUnionExpression) {
+            listener.enterUnionExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitUnionExpression) {
+            listener.exitUnionExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitUnionExpression) {
+            return visitor.visitUnionExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.UnionExpressionContext = UnionExpressionContext;
+class InequalityExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterInequalityExpression) {
+            listener.enterInequalityExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitInequalityExpression) {
+            listener.exitInequalityExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitInequalityExpression) {
+            return visitor.visitInequalityExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.InequalityExpressionContext = InequalityExpressionContext;
+class EqualityExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterEqualityExpression) {
+            listener.enterEqualityExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitEqualityExpression) {
+            listener.exitEqualityExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitEqualityExpression) {
+            return visitor.visitEqualityExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.EqualityExpressionContext = EqualityExpressionContext;
+class MembershipExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterMembershipExpression) {
+            listener.enterMembershipExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitMembershipExpression) {
+            listener.exitMembershipExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMembershipExpression) {
+            return visitor.visitMembershipExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.MembershipExpressionContext = MembershipExpressionContext;
+class AndExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterAndExpression) {
+            listener.enterAndExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitAndExpression) {
+            listener.exitAndExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAndExpression) {
+            return visitor.visitAndExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.AndExpressionContext = AndExpressionContext;
+class OrExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterOrExpression) {
+            listener.enterOrExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitOrExpression) {
+            listener.exitOrExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitOrExpression) {
+            return visitor.visitOrExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.OrExpressionContext = OrExpressionContext;
+class ImpliesExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterImpliesExpression) {
+            listener.enterImpliesExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitImpliesExpression) {
+            listener.exitImpliesExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitImpliesExpression) {
+            return visitor.visitImpliesExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ImpliesExpressionContext = ImpliesExpressionContext;
+class TermContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_term;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.TermContext = TermContext;
+class InvocationTermContext extends TermContext {
+    invocation() {
+        return this.getRuleContext(0, InvocationContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterInvocationTerm) {
+            listener.enterInvocationTerm(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitInvocationTerm) {
+            listener.exitInvocationTerm(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitInvocationTerm) {
+            return visitor.visitInvocationTerm(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.InvocationTermContext = InvocationTermContext;
+class LiteralTermContext extends TermContext {
+    literal() {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterLiteralTerm) {
+            listener.enterLiteralTerm(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitLiteralTerm) {
+            listener.exitLiteralTerm(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitLiteralTerm) {
+            return visitor.visitLiteralTerm(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.LiteralTermContext = LiteralTermContext;
+class ExternalConstantTermContext extends TermContext {
+    externalConstant() {
+        return this.getRuleContext(0, ExternalConstantContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterExternalConstantTerm) {
+            listener.enterExternalConstantTerm(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitExternalConstantTerm) {
+            listener.exitExternalConstantTerm(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitExternalConstantTerm) {
+            return visitor.visitExternalConstantTerm(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ExternalConstantTermContext = ExternalConstantTermContext;
+class ParenthesizedTermContext extends TermContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterParenthesizedTerm) {
+            listener.enterParenthesizedTerm(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitParenthesizedTerm) {
+            listener.exitParenthesizedTerm(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitParenthesizedTerm) {
+            return visitor.visitParenthesizedTerm(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ParenthesizedTermContext = ParenthesizedTermContext;
+class LiteralContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_literal;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.LiteralContext = LiteralContext;
+class NullLiteralContext extends LiteralContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterNullLiteral) {
+            listener.enterNullLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitNullLiteral) {
+            listener.exitNullLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitNullLiteral) {
+            return visitor.visitNullLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.NullLiteralContext = NullLiteralContext;
+class BooleanLiteralContext extends LiteralContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterBooleanLiteral) {
+            listener.enterBooleanLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitBooleanLiteral) {
+            listener.exitBooleanLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBooleanLiteral) {
+            return visitor.visitBooleanLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.BooleanLiteralContext = BooleanLiteralContext;
+class StringLiteralContext extends LiteralContext {
+    STRING() {
+        return this.getToken(fhirpathParser.STRING, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterStringLiteral) {
+            listener.enterStringLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitStringLiteral) {
+            listener.exitStringLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitStringLiteral) {
+            return visitor.visitStringLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.StringLiteralContext = StringLiteralContext;
+class NumberLiteralContext extends LiteralContext {
+    NUMBER() {
+        return this.getToken(fhirpathParser.NUMBER, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterNumberLiteral) {
+            listener.enterNumberLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitNumberLiteral) {
+            listener.exitNumberLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitNumberLiteral) {
+            return visitor.visitNumberLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.NumberLiteralContext = NumberLiteralContext;
+class LongNumberLiteralContext extends LiteralContext {
+    LONGNUMBER() {
+        return this.getToken(fhirpathParser.LONGNUMBER, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterLongNumberLiteral) {
+            listener.enterLongNumberLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitLongNumberLiteral) {
+            listener.exitLongNumberLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitLongNumberLiteral) {
+            return visitor.visitLongNumberLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.LongNumberLiteralContext = LongNumberLiteralContext;
+class DateLiteralContext extends LiteralContext {
+    DATE() {
+        return this.getToken(fhirpathParser.DATE, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterDateLiteral) {
+            listener.enterDateLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitDateLiteral) {
+            listener.exitDateLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitDateLiteral) {
+            return visitor.visitDateLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.DateLiteralContext = DateLiteralContext;
+class DateTimeLiteralContext extends LiteralContext {
+    DATETIME() {
+        return this.getToken(fhirpathParser.DATETIME, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterDateTimeLiteral) {
+            listener.enterDateTimeLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitDateTimeLiteral) {
+            listener.exitDateTimeLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitDateTimeLiteral) {
+            return visitor.visitDateTimeLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.DateTimeLiteralContext = DateTimeLiteralContext;
+class TimeLiteralContext extends LiteralContext {
+    TIME() {
+        return this.getToken(fhirpathParser.TIME, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTimeLiteral) {
+            listener.enterTimeLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTimeLiteral) {
+            listener.exitTimeLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTimeLiteral) {
+            return visitor.visitTimeLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TimeLiteralContext = TimeLiteralContext;
+class QuantityLiteralContext extends LiteralContext {
+    quantity() {
+        return this.getRuleContext(0, QuantityContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterQuantityLiteral) {
+            listener.enterQuantityLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitQuantityLiteral) {
+            listener.exitQuantityLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitQuantityLiteral) {
+            return visitor.visitQuantityLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.QuantityLiteralContext = QuantityLiteralContext;
+class ExternalConstantContext extends ParserRuleContext_1.ParserRuleContext {
+    identifier() {
+        return this.tryGetRuleContext(0, IdentifierContext);
+    }
+    STRING() {
+        return this.tryGetToken(fhirpathParser.STRING, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_externalConstant;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterExternalConstant) {
+            listener.enterExternalConstant(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitExternalConstant) {
+            listener.exitExternalConstant(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitExternalConstant) {
+            return visitor.visitExternalConstant(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ExternalConstantContext = ExternalConstantContext;
+class InvocationContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_invocation;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.InvocationContext = InvocationContext;
+class MemberInvocationContext extends InvocationContext {
+    identifier() {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterMemberInvocation) {
+            listener.enterMemberInvocation(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitMemberInvocation) {
+            listener.exitMemberInvocation(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMemberInvocation) {
+            return visitor.visitMemberInvocation(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.MemberInvocationContext = MemberInvocationContext;
+class FunctionInvocationContext extends InvocationContext {
+    function() {
+        return this.getRuleContext(0, FunctionContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterFunctionInvocation) {
+            listener.enterFunctionInvocation(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitFunctionInvocation) {
+            listener.exitFunctionInvocation(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitFunctionInvocation) {
+            return visitor.visitFunctionInvocation(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.FunctionInvocationContext = FunctionInvocationContext;
+class ThisInvocationContext extends InvocationContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterThisInvocation) {
+            listener.enterThisInvocation(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitThisInvocation) {
+            listener.exitThisInvocation(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitThisInvocation) {
+            return visitor.visitThisInvocation(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ThisInvocationContext = ThisInvocationContext;
+class IndexInvocationContext extends InvocationContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIndexInvocation) {
+            listener.enterIndexInvocation(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIndexInvocation) {
+            listener.exitIndexInvocation(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIndexInvocation) {
+            return visitor.visitIndexInvocation(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IndexInvocationContext = IndexInvocationContext;
+class TotalInvocationContext extends InvocationContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTotalInvocation) {
+            listener.enterTotalInvocation(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTotalInvocation) {
+            listener.exitTotalInvocation(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTotalInvocation) {
+            return visitor.visitTotalInvocation(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TotalInvocationContext = TotalInvocationContext;
+class FunctionContext extends ParserRuleContext_1.ParserRuleContext {
+    identifier() {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    paramList() {
+        return this.tryGetRuleContext(0, ParamListContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_function;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterFunction) {
+            listener.enterFunction(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitFunction) {
+            listener.exitFunction(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitFunction) {
+            return visitor.visitFunction(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.FunctionContext = FunctionContext;
+class ParamListContext extends ParserRuleContext_1.ParserRuleContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_paramList;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterParamList) {
+            listener.enterParamList(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitParamList) {
+            listener.exitParamList(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitParamList) {
+            return visitor.visitParamList(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ParamListContext = ParamListContext;
+class QuantityContext extends ParserRuleContext_1.ParserRuleContext {
+    NUMBER() {
+        return this.getToken(fhirpathParser.NUMBER, 0);
+    }
+    unit() {
+        return this.tryGetRuleContext(0, UnitContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_quantity;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterQuantity) {
+            listener.enterQuantity(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitQuantity) {
+            listener.exitQuantity(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitQuantity) {
+            return visitor.visitQuantity(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.QuantityContext = QuantityContext;
+class UnitContext extends ParserRuleContext_1.ParserRuleContext {
+    dateTimePrecision() {
+        return this.tryGetRuleContext(0, DateTimePrecisionContext);
+    }
+    pluralDateTimePrecision() {
+        return this.tryGetRuleContext(0, PluralDateTimePrecisionContext);
+    }
+    STRING() {
+        return this.tryGetToken(fhirpathParser.STRING, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_unit;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterUnit) {
+            listener.enterUnit(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitUnit) {
+            listener.exitUnit(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitUnit) {
+            return visitor.visitUnit(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.UnitContext = UnitContext;
+class DateTimePrecisionContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_dateTimePrecision;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterDateTimePrecision) {
+            listener.enterDateTimePrecision(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitDateTimePrecision) {
+            listener.exitDateTimePrecision(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitDateTimePrecision) {
+            return visitor.visitDateTimePrecision(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.DateTimePrecisionContext = DateTimePrecisionContext;
+class PluralDateTimePrecisionContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_pluralDateTimePrecision;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterPluralDateTimePrecision) {
+            listener.enterPluralDateTimePrecision(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitPluralDateTimePrecision) {
+            listener.exitPluralDateTimePrecision(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitPluralDateTimePrecision) {
+            return visitor.visitPluralDateTimePrecision(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.PluralDateTimePrecisionContext = PluralDateTimePrecisionContext;
+class TypeSpecifierContext extends ParserRuleContext_1.ParserRuleContext {
+    qualifiedIdentifier() {
+        return this.getRuleContext(0, QualifiedIdentifierContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_typeSpecifier;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTypeSpecifier) {
+            listener.enterTypeSpecifier(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTypeSpecifier) {
+            listener.exitTypeSpecifier(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTypeSpecifier) {
+            return visitor.visitTypeSpecifier(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TypeSpecifierContext = TypeSpecifierContext;
+class QualifiedIdentifierContext extends ParserRuleContext_1.ParserRuleContext {
+    identifier(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+        else {
+            return this.getRuleContext(i, IdentifierContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_qualifiedIdentifier;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterQualifiedIdentifier) {
+            listener.enterQualifiedIdentifier(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitQualifiedIdentifier) {
+            listener.exitQualifiedIdentifier(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitQualifiedIdentifier) {
+            return visitor.visitQualifiedIdentifier(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.QualifiedIdentifierContext = QualifiedIdentifierContext;
+class IdentifierContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() {
+        return this.tryGetToken(fhirpathParser.IDENTIFIER, 0);
+    }
+    DELIMITEDIDENTIFIER() {
+        return this.tryGetToken(fhirpathParser.DELIMITEDIDENTIFIER, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return fhirpathParser.RULE_identifier;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIdentifier) {
+            listener.enterIdentifier(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIdentifier) {
+            listener.exitIdentifier(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIdentifier) {
+            return visitor.visitIdentifier(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IdentifierContext = IdentifierContext;
+//# sourceMappingURL=fhirpathParser.js.map