blend-r 1.1.6

package/dist/parser/blendApi/src/grammar/BlendApiParser.js

@@ -0,0 +1,978 @@
+"use strict";
+// Generated from src/grammar/BlendApi.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.PrimitiveTypeContext = exports.TypeContext = exports.FieldContext = exports.DirectOutputDefenitionContext = exports.OutputDefinitionContext = exports.InputDefinitionContext = exports.AuthenticatedContext = exports.ApiDefinitionContext = exports.ModuleDefinitionContext = exports.SectionDefinitionContext = exports.ProgramContext = exports.BlendApiParser = void 0;
+const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
+const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
+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 BlendApiParser extends Parser_1.Parser {
+    // @Override
+    // @NotNull
+    get vocabulary() {
+        return BlendApiParser.VOCABULARY;
+    }
+    // tslint:enable:no-trailing-whitespace
+    // @Override
+    get grammarFileName() { return "BlendApi.g4"; }
+    // @Override
+    get ruleNames() { return BlendApiParser.ruleNames; }
+    // @Override
+    get serializedATN() { return BlendApiParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(BlendApiParser._ATN, this);
+    }
+    // @RuleVersion(0)
+    program() {
+        let _localctx = new ProgramContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, BlendApiParser.RULE_program);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 22;
+                this.moduleDefinition();
+                this.state = 26;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendApiParser.T__0) {
+                    {
+                        {
+                            this.state = 23;
+                            this.sectionDefinition();
+                        }
+                    }
+                    this.state = 28;
+                    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)
+    sectionDefinition() {
+        let _localctx = new SectionDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 2, BlendApiParser.RULE_sectionDefinition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 29;
+                this.match(BlendApiParser.T__0);
+                this.state = 30;
+                this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                this.state = 31;
+                this.match(BlendApiParser.T__1);
+                this.state = 35;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendApiParser.T__4) {
+                    {
+                        {
+                            this.state = 32;
+                            this.apiDefinition();
+                        }
+                    }
+                    this.state = 37;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 38;
+                this.match(BlendApiParser.T__2);
+            }
+        }
+        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)
+    moduleDefinition() {
+        let _localctx = new ModuleDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 4, BlendApiParser.RULE_moduleDefinition);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 40;
+                this.match(BlendApiParser.T__3);
+                this.state = 41;
+                this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+            }
+        }
+        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)
+    apiDefinition() {
+        let _localctx = new ApiDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 6, BlendApiParser.RULE_apiDefinition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 43;
+                this.match(BlendApiParser.T__4);
+                this.state = 44;
+                this.match(BlendApiParser.IDENTIFIER);
+                this.state = 45;
+                this.match(BlendApiParser.T__5);
+                this.state = 46;
+                this.match(BlendApiParser.HTTP_METHOD);
+                this.state = 47;
+                this.match(BlendApiParser.T__6);
+                this.state = 48;
+                this.match(BlendApiParser.URL_IDENTIFIER);
+                this.state = 49;
+                this.match(BlendApiParser.T__1);
+                this.state = 51;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === BlendApiParser.T__7) {
+                    {
+                        this.state = 50;
+                        this.authenticated();
+                    }
+                }
+                this.state = 54;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === BlendApiParser.T__8) {
+                    {
+                        this.state = 53;
+                        this.inputDefinition();
+                    }
+                }
+                this.state = 57;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === BlendApiParser.T__10) {
+                    {
+                        this.state = 56;
+                        this.outputDefinition();
+                    }
+                }
+                this.state = 59;
+                this.match(BlendApiParser.T__2);
+            }
+        }
+        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)
+    authenticated() {
+        let _localctx = new AuthenticatedContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, BlendApiParser.RULE_authenticated);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 61;
+                this.match(BlendApiParser.T__7);
+            }
+        }
+        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)
+    inputDefinition() {
+        let _localctx = new InputDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 10, BlendApiParser.RULE_inputDefinition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 63;
+                this.match(BlendApiParser.T__8);
+                this.state = 64;
+                this.field();
+                this.state = 69;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendApiParser.T__9) {
+                    {
+                        {
+                            this.state = 65;
+                            this.match(BlendApiParser.T__9);
+                            this.state = 66;
+                            this.field();
+                        }
+                    }
+                    this.state = 71;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 72;
+                this.match(BlendApiParser.T__6);
+            }
+        }
+        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)
+    outputDefinition() {
+        let _localctx = new OutputDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 12, BlendApiParser.RULE_outputDefinition);
+        let _la;
+        try {
+            this.state = 89;
+            this._errHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this._input, 7, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 74;
+                        this.match(BlendApiParser.T__10);
+                        this.state = 75;
+                        this.field();
+                        this.state = 80;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === BlendApiParser.T__9) {
+                            {
+                                {
+                                    this.state = 76;
+                                    this.match(BlendApiParser.T__9);
+                                    this.state = 77;
+                                    this.field();
+                                }
+                            }
+                            this.state = 82;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                        this.state = 83;
+                        this.match(BlendApiParser.T__6);
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 85;
+                        this.match(BlendApiParser.T__10);
+                        this.state = 86;
+                        this.directOutputDefenition();
+                        this.state = 87;
+                        this.match(BlendApiParser.T__6);
+                    }
+                    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)
+    directOutputDefenition() {
+        let _localctx = new DirectOutputDefenitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 14, BlendApiParser.RULE_directOutputDefenition);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 91;
+                this.type();
+            }
+        }
+        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)
+    field() {
+        let _localctx = new FieldContext(this._ctx, this.state);
+        this.enterRule(_localctx, 16, BlendApiParser.RULE_field);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 93;
+                _la = this._input.LA(1);
+                if (!(_la === BlendApiParser.IDENTIFIER || _la === BlendApiParser.CAPITAL_IDENTIFIER)) {
+                    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 = 94;
+                this.match(BlendApiParser.T__11);
+                this.state = 95;
+                this.type();
+            }
+        }
+        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)
+    type() {
+        let _localctx = new TypeContext(this._ctx, this.state);
+        this.enterRule(_localctx, 18, BlendApiParser.RULE_type);
+        try {
+            this.state = 115;
+            this._errHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this._input, 8, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 97;
+                        this.primitiveType();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 98;
+                        this.primitiveType();
+                        this.state = 99;
+                        this.match(BlendApiParser.T__12);
+                    }
+                    break;
+                case 3:
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 101;
+                        this.primitiveType();
+                        this.state = 102;
+                        this.match(BlendApiParser.T__13);
+                    }
+                    break;
+                case 4:
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 104;
+                        this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                        this.state = 105;
+                        this.match(BlendApiParser.T__14);
+                        this.state = 106;
+                        this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                    }
+                    break;
+                case 5:
+                    this.enterOuterAlt(_localctx, 5);
+                    {
+                        this.state = 107;
+                        this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                        this.state = 108;
+                        this.match(BlendApiParser.T__14);
+                        this.state = 109;
+                        this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                        this.state = 110;
+                        this.match(BlendApiParser.T__13);
+                    }
+                    break;
+                case 6:
+                    this.enterOuterAlt(_localctx, 6);
+                    {
+                        this.state = 111;
+                        this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                        this.state = 112;
+                        this.match(BlendApiParser.T__14);
+                        this.state = 113;
+                        this.match(BlendApiParser.CAPITAL_IDENTIFIER);
+                        this.state = 114;
+                        this.match(BlendApiParser.T__12);
+                    }
+                    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)
+    primitiveType() {
+        let _localctx = new PrimitiveTypeContext(this._ctx, this.state);
+        this.enterRule(_localctx, 20, BlendApiParser.RULE_primitiveType);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 117;
+                _la = this._input.LA(1);
+                if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << BlendApiParser.T__15) | (1 << BlendApiParser.T__16) | (1 << BlendApiParser.T__17) | (1 << BlendApiParser.T__18) | (1 << BlendApiParser.T__19))) !== 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;
+    }
+    static get _ATN() {
+        if (!BlendApiParser.__ATN) {
+            BlendApiParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(BlendApiParser._serializedATN));
+        }
+        return BlendApiParser.__ATN;
+    }
+}
+exports.BlendApiParser = BlendApiParser;
+BlendApiParser.T__0 = 1;
+BlendApiParser.T__1 = 2;
+BlendApiParser.T__2 = 3;
+BlendApiParser.T__3 = 4;
+BlendApiParser.T__4 = 5;
+BlendApiParser.T__5 = 6;
+BlendApiParser.T__6 = 7;
+BlendApiParser.T__7 = 8;
+BlendApiParser.T__8 = 9;
+BlendApiParser.T__9 = 10;
+BlendApiParser.T__10 = 11;
+BlendApiParser.T__11 = 12;
+BlendApiParser.T__12 = 13;
+BlendApiParser.T__13 = 14;
+BlendApiParser.T__14 = 15;
+BlendApiParser.T__15 = 16;
+BlendApiParser.T__16 = 17;
+BlendApiParser.T__17 = 18;
+BlendApiParser.T__18 = 19;
+BlendApiParser.T__19 = 20;
+BlendApiParser.HTTP_METHOD = 21;
+BlendApiParser.IDENTIFIER = 22;
+BlendApiParser.CAPITAL_IDENTIFIER = 23;
+BlendApiParser.URL_IDENTIFIER = 24;
+BlendApiParser.WS = 25;
+BlendApiParser.RULE_program = 0;
+BlendApiParser.RULE_sectionDefinition = 1;
+BlendApiParser.RULE_moduleDefinition = 2;
+BlendApiParser.RULE_apiDefinition = 3;
+BlendApiParser.RULE_authenticated = 4;
+BlendApiParser.RULE_inputDefinition = 5;
+BlendApiParser.RULE_outputDefinition = 6;
+BlendApiParser.RULE_directOutputDefenition = 7;
+BlendApiParser.RULE_field = 8;
+BlendApiParser.RULE_type = 9;
+BlendApiParser.RULE_primitiveType = 10;
+// tslint:disable:no-trailing-whitespace
+BlendApiParser.ruleNames = [
+    "program", "sectionDefinition", "moduleDefinition", "apiDefinition", "authenticated",
+    "inputDefinition", "outputDefinition", "directOutputDefenition", "field",
+    "type", "primitiveType",
+];
+BlendApiParser._LITERAL_NAMES = [
+    undefined, "'section'", "'{'", "'}'", "'module'", "'api'", "'('", "')'",
+    "'authenticated'", "'input('", "','", "'output('", "':'", "'[]'", "'?'",
+    "'->'", "'string'", "'number'", "'boolean'", "'any'", "'object'",
+];
+BlendApiParser._SYMBOLIC_NAMES = [
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    "HTTP_METHOD", "IDENTIFIER", "CAPITAL_IDENTIFIER", "URL_IDENTIFIER", "WS",
+];
+BlendApiParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(BlendApiParser._LITERAL_NAMES, BlendApiParser._SYMBOLIC_NAMES, []);
+BlendApiParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x1Bz\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\x03\x02\x03\x02" +
+    "\x07\x02\x1B\n\x02\f\x02\x0E\x02\x1E\v\x02\x03\x03\x03\x03\x03\x03\x03" +
+    "\x03\x07\x03$\n\x03\f\x03\x0E\x03\'\v\x03\x03\x03\x03\x03\x03\x04\x03" +
+    "\x04\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" +
+    "\x05\x05\x056\n\x05\x03\x05\x05\x059\n\x05\x03\x05\x05\x05<\n\x05\x03" +
+    "\x05\x03\x05\x03\x06\x03\x06\x03\x07\x03\x07\x03\x07\x03\x07\x07\x07F" +
+    "\n\x07\f\x07\x0E\x07I\v\x07\x03\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x07" +
+    "\bQ\n\b\f\b\x0E\bT\v\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\\\n\b" +
+    "\x03\t\x03\t\x03\n\x03\n\x03\n\x03\n\x03\v\x03\v\x03\v\x03\v\x03\v\x03" +
+    "\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03" +
+    "\v\x05\vv\n\v\x03\f\x03\f\x03\f\x02\x02\x02\r\x02\x02\x04\x02\x06\x02" +
+    "\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x02\x04\x03" +
+    "\x02\x18\x19\x03\x02\x12\x16\x02{\x02\x18\x03\x02\x02\x02\x04\x1F\x03" +
+    "\x02\x02\x02\x06*\x03\x02\x02\x02\b-\x03\x02\x02\x02\n?\x03\x02\x02\x02" +
+    "\fA\x03\x02\x02\x02\x0E[\x03\x02\x02\x02\x10]\x03\x02\x02\x02\x12_\x03" +
+    "\x02\x02\x02\x14u\x03\x02\x02\x02\x16w\x03\x02\x02\x02\x18\x1C\x05\x06" +
+    "\x04\x02\x19\x1B\x05\x04\x03\x02\x1A\x19\x03\x02\x02\x02\x1B\x1E\x03\x02" +
+    "\x02\x02\x1C\x1A\x03\x02\x02\x02\x1C\x1D\x03\x02\x02\x02\x1D\x03\x03\x02" +
+    "\x02\x02\x1E\x1C\x03\x02\x02\x02\x1F \x07\x03\x02\x02 !\x07\x19\x02\x02" +
+    "!%\x07\x04\x02\x02\"$\x05\b\x05\x02#\"\x03\x02\x02\x02$\'\x03\x02\x02" +
+    "\x02%#\x03\x02\x02\x02%&\x03\x02\x02\x02&(\x03\x02\x02\x02\'%\x03\x02" +
+    "\x02\x02()\x07\x05\x02\x02)\x05\x03\x02\x02\x02*+\x07\x06\x02\x02+,\x07" +
+    "\x19\x02\x02,\x07\x03\x02\x02\x02-.\x07\x07\x02\x02./\x07\x18\x02\x02" +
+    "/0\x07\b\x02\x0201\x07\x17\x02\x0212\x07\t\x02\x0223\x07\x1A\x02\x023" +
+    "5\x07\x04\x02\x0246\x05\n\x06\x0254\x03\x02\x02\x0256\x03\x02\x02\x02" +
+    "68\x03\x02\x02\x0279\x05\f\x07\x0287\x03\x02\x02\x0289\x03\x02\x02\x02" +
+    "9;\x03\x02\x02\x02:<\x05\x0E\b\x02;:\x03\x02\x02\x02;<\x03\x02\x02\x02" +
+    "<=\x03\x02\x02\x02=>\x07\x05\x02\x02>\t\x03\x02\x02\x02?@\x07\n\x02\x02" +
+    "@\v\x03\x02\x02\x02AB\x07\v\x02\x02BG\x05\x12\n\x02CD\x07\f\x02\x02DF" +
+    "\x05\x12\n\x02EC\x03\x02\x02\x02FI\x03\x02\x02\x02GE\x03\x02\x02\x02G" +
+    "H\x03\x02\x02\x02HJ\x03\x02\x02\x02IG\x03\x02\x02\x02JK\x07\t\x02\x02" +
+    "K\r\x03\x02\x02\x02LM\x07\r\x02\x02MR\x05\x12\n\x02NO\x07\f\x02\x02OQ" +
+    "\x05\x12\n\x02PN\x03\x02\x02\x02QT\x03\x02\x02\x02RP\x03\x02\x02\x02R" +
+    "S\x03\x02\x02\x02SU\x03\x02\x02\x02TR\x03\x02\x02\x02UV\x07\t\x02\x02" +
+    "V\\\x03\x02\x02\x02WX\x07\r\x02\x02XY\x05\x10\t\x02YZ\x07\t\x02\x02Z\\" +
+    "\x03\x02\x02\x02[L\x03\x02\x02\x02[W\x03\x02\x02\x02\\\x0F\x03\x02\x02" +
+    "\x02]^\x05\x14\v\x02^\x11\x03\x02\x02\x02_`\t\x02\x02\x02`a\x07\x0E\x02" +
+    "\x02ab\x05\x14\v\x02b\x13\x03\x02\x02\x02cv\x05\x16\f\x02de\x05\x16\f" +
+    "\x02ef\x07\x0F\x02\x02fv\x03\x02\x02\x02gh\x05\x16\f\x02hi\x07\x10\x02" +
+    "\x02iv\x03\x02\x02\x02jk\x07\x19\x02\x02kl\x07\x11\x02\x02lv\x07\x19\x02" +
+    "\x02mn\x07\x19\x02\x02no\x07\x11\x02\x02op\x07\x19\x02\x02pv\x07\x10\x02" +
+    "\x02qr\x07\x19\x02\x02rs\x07\x11\x02\x02st\x07\x19\x02\x02tv\x07\x0F\x02" +
+    "\x02uc\x03\x02\x02\x02ud\x03\x02\x02\x02ug\x03\x02\x02\x02uj\x03\x02\x02" +
+    "\x02um\x03\x02\x02\x02uq\x03\x02\x02\x02v\x15\x03\x02\x02\x02wx\t\x03" +
+    "\x02\x02x\x17\x03\x02\x02\x02\v\x1C%58;GR[u";
+class ProgramContext extends ParserRuleContext_1.ParserRuleContext {
+    moduleDefinition() {
+        return this.getRuleContext(0, ModuleDefinitionContext);
+    }
+    sectionDefinition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(SectionDefinitionContext);
+        }
+        else {
+            return this.getRuleContext(i, SectionDefinitionContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_program; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterProgram) {
+            listener.enterProgram(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitProgram) {
+            listener.exitProgram(this);
+        }
+    }
+}
+exports.ProgramContext = ProgramContext;
+class SectionDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER() { return this.getToken(BlendApiParser.CAPITAL_IDENTIFIER, 0); }
+    apiDefinition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ApiDefinitionContext);
+        }
+        else {
+            return this.getRuleContext(i, ApiDefinitionContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_sectionDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterSectionDefinition) {
+            listener.enterSectionDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitSectionDefinition) {
+            listener.exitSectionDefinition(this);
+        }
+    }
+}
+exports.SectionDefinitionContext = SectionDefinitionContext;
+class ModuleDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER() { return this.getToken(BlendApiParser.CAPITAL_IDENTIFIER, 0); }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_moduleDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterModuleDefinition) {
+            listener.enterModuleDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitModuleDefinition) {
+            listener.exitModuleDefinition(this);
+        }
+    }
+}
+exports.ModuleDefinitionContext = ModuleDefinitionContext;
+class ApiDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() { return this.getToken(BlendApiParser.IDENTIFIER, 0); }
+    HTTP_METHOD() { return this.getToken(BlendApiParser.HTTP_METHOD, 0); }
+    URL_IDENTIFIER() { return this.getToken(BlendApiParser.URL_IDENTIFIER, 0); }
+    authenticated() {
+        return this.tryGetRuleContext(0, AuthenticatedContext);
+    }
+    inputDefinition() {
+        return this.tryGetRuleContext(0, InputDefinitionContext);
+    }
+    outputDefinition() {
+        return this.tryGetRuleContext(0, OutputDefinitionContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_apiDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterApiDefinition) {
+            listener.enterApiDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitApiDefinition) {
+            listener.exitApiDefinition(this);
+        }
+    }
+}
+exports.ApiDefinitionContext = ApiDefinitionContext;
+class AuthenticatedContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_authenticated; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterAuthenticated) {
+            listener.enterAuthenticated(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitAuthenticated) {
+            listener.exitAuthenticated(this);
+        }
+    }
+}
+exports.AuthenticatedContext = AuthenticatedContext;
+class InputDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    field(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FieldContext);
+        }
+        else {
+            return this.getRuleContext(i, FieldContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_inputDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterInputDefinition) {
+            listener.enterInputDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitInputDefinition) {
+            listener.exitInputDefinition(this);
+        }
+    }
+}
+exports.InputDefinitionContext = InputDefinitionContext;
+class OutputDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    field(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FieldContext);
+        }
+        else {
+            return this.getRuleContext(i, FieldContext);
+        }
+    }
+    directOutputDefenition() {
+        return this.tryGetRuleContext(0, DirectOutputDefenitionContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_outputDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterOutputDefinition) {
+            listener.enterOutputDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitOutputDefinition) {
+            listener.exitOutputDefinition(this);
+        }
+    }
+}
+exports.OutputDefinitionContext = OutputDefinitionContext;
+class DirectOutputDefenitionContext extends ParserRuleContext_1.ParserRuleContext {
+    type() {
+        return this.getRuleContext(0, TypeContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_directOutputDefenition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterDirectOutputDefenition) {
+            listener.enterDirectOutputDefenition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitDirectOutputDefenition) {
+            listener.exitDirectOutputDefenition(this);
+        }
+    }
+}
+exports.DirectOutputDefenitionContext = DirectOutputDefenitionContext;
+class FieldContext extends ParserRuleContext_1.ParserRuleContext {
+    type() {
+        return this.getRuleContext(0, TypeContext);
+    }
+    IDENTIFIER() { return this.tryGetToken(BlendApiParser.IDENTIFIER, 0); }
+    CAPITAL_IDENTIFIER() { return this.tryGetToken(BlendApiParser.CAPITAL_IDENTIFIER, 0); }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_field; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterField) {
+            listener.enterField(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitField) {
+            listener.exitField(this);
+        }
+    }
+}
+exports.FieldContext = FieldContext;
+class TypeContext extends ParserRuleContext_1.ParserRuleContext {
+    primitiveType() {
+        return this.tryGetRuleContext(0, PrimitiveTypeContext);
+    }
+    CAPITAL_IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendApiParser.CAPITAL_IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendApiParser.CAPITAL_IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_type; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterType) {
+            listener.enterType(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitType) {
+            listener.exitType(this);
+        }
+    }
+}
+exports.TypeContext = TypeContext;
+class PrimitiveTypeContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendApiParser.RULE_primitiveType; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterPrimitiveType) {
+            listener.enterPrimitiveType(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitPrimitiveType) {
+            listener.exitPrimitiveType(this);
+        }
+    }
+}
+exports.PrimitiveTypeContext = PrimitiveTypeContext;