quixos-protocol/src/capability-language/generated/QuixosCapabilityParser.ts

import * as antlr from "antlr4ng";
import { Token } from "antlr4ng";

import { QuixosCapabilityVisitor } from "./QuixosCapabilityVisitor.js";

// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
// eslint-disable-next-line no-unused-vars
type int = number;


export class QuixosCapabilityParser extends antlr.Parser {
    public static readonly WORKSPACE = 1;
    public static readonly ATOM = 2;
    public static readonly INTERFACE = 3;
    public static readonly INTERFACES = 4;
    public static readonly PACKAGE = 5;
    public static readonly VALUE = 6;
    public static readonly RELATION = 7;
    public static readonly OPERATION = 8;
    public static readonly FUNCTION = 9;
    public static readonly CONSTRUCTOR = 10;
    public static readonly CONSTRUCTS = 11;
    public static readonly CONFORM = 12;
    public static readonly AS = 13;
    public static readonly BIND = 14;
    public static readonly TO = 15;
    public static readonly PRIVATE = 16;
    public static readonly SHARED = 17;
    public static readonly STATE = 18;
    public static readonly EDGE = 19;
    public static readonly PROJECTION = 20;
    public static readonly WITH = 21;
    public static readonly USING = 22;
    public static readonly VIA = 23;
    public static readonly MATERIALIZE = 24;
    public static readonly IF = 25;
    public static readonly ABSENT = 26;
    public static readonly ON = 27;
    public static readonly POLICY = 28;
    public static readonly DEFAULT = 29;
    public static readonly SOURCE = 30;
    public static readonly REPOSITORY = 31;
    public static readonly COMMIT = 32;
    public static readonly REVISION = 33;
    public static readonly ID = 34;
    public static readonly DOC = 35;
    public static readonly MODE = 36;
    public static readonly EMITS = 37;
    public static readonly RECEIVER = 38;
    public static readonly REQUIRES = 39;
    public static readonly ANY = 40;
    public static readonly GET = 41;
    public static readonly SET = 42;
    public static readonly WATCH = 43;
    public static readonly START = 44;
    public static readonly STOP = 45;
    public static readonly READ = 46;
    public static readonly WRITE = 47;
    public static readonly RESOLVE = 48;
    public static readonly CONNECT = 49;
    public static readonly DISCONNECT = 50;
    public static readonly CALL = 51;
    public static readonly WATCH_START = 52;
    public static readonly WATCH_STOP = 53;
    public static readonly SUBSCRIBE = 54;
    public static readonly UNSUBSCRIBE = 55;
    public static readonly OPTIMISTIC_REGISTER = 56;
    public static readonly CRDT = 57;
    public static readonly OPTIONAL_ONE = 58;
    public static readonly EXACTLY_ONE = 59;
    public static readonly MANY_UNIQUE = 60;
    public static readonly MANY = 61;
    public static readonly ORDERED = 62;
    public static readonly UNIT = 63;
    public static readonly WATCH_HANDLE = 64;
    public static readonly MESSAGE = 65;
    public static readonly ATOM_REF = 66;
    public static readonly INTERFACE_REF = 67;
    public static readonly OPTIONAL = 68;
    public static readonly LIST = 69;
    public static readonly BOOL = 70;
    public static readonly BYTES = 71;
    public static readonly DOUBLE = 72;
    public static readonly INT32 = 73;
    public static readonly INT64 = 74;
    public static readonly STRING = 75;
    public static readonly UINT32 = 76;
    public static readonly UINT64 = 77;
    public static readonly TRUE = 78;
    public static readonly FALSE = 79;
    public static readonly NULL = 80;
    public static readonly ARROW = 81;
    public static readonly COLON = 82;
    public static readonly SEMI = 83;
    public static readonly COMMA = 84;
    public static readonly DOT = 85;
    public static readonly LBRACE = 86;
    public static readonly RBRACE = 87;
    public static readonly LBRACK = 88;
    public static readonly RBRACK = 89;
    public static readonly LPAREN = 90;
    public static readonly RPAREN = 91;
    public static readonly LT = 92;
    public static readonly GT = 93;
    public static readonly INTEGER = 94;
    public static readonly JSON_NUMBER = 95;
    public static readonly IDENTIFIER = 96;
    public static readonly STRING_LITERAL = 97;
    public static readonly LINE_COMMENT = 98;
    public static readonly BLOCK_COMMENT = 99;
    public static readonly WS = 100;
    public static readonly RULE_document = 0;
    public static readonly RULE_workspaceDecl = 1;
    public static readonly RULE_workspaceItem = 2;
    public static readonly RULE_atomDecl = 3;
    public static readonly RULE_interfaceDecl = 4;
    public static readonly RULE_sourceBlock = 5;
    public static readonly RULE_interfaceMember = 6;
    public static readonly RULE_operationMember = 7;
    public static readonly RULE_valueMember = 8;
    public static readonly RULE_valueMemberOperation = 9;
    public static readonly RULE_relationshipMember = 10;
    public static readonly RULE_relationshipOperation = 11;
    public static readonly RULE_targetConstraint = 12;
    public static readonly RULE_packageDecl = 13;
    public static readonly RULE_packageExport = 14;
    public static readonly RULE_packageOperationExport = 15;
    public static readonly RULE_packageFunctionExport = 16;
    public static readonly RULE_packageConstructorExport = 17;
    public static readonly RULE_eventClause = 18;
    public static readonly RULE_operationMode = 19;
    public static readonly RULE_receiverRequirement = 20;
    public static readonly RULE_identifierList = 21;
    public static readonly RULE_dependencyBlock = 22;
    public static readonly RULE_dependencyPort = 23;
    public static readonly RULE_primitiveList = 24;
    public static readonly RULE_primitive = 25;
    public static readonly RULE_sharedAttachmentDecl = 26;
    public static readonly RULE_attachmentDecl = 27;
    public static readonly RULE_stateDecl = 28;
    public static readonly RULE_storagePolicy = 29;
    public static readonly RULE_edgeDecl = 30;
    public static readonly RULE_edgeEndpoint = 31;
    public static readonly RULE_conformanceDecl = 32;
    public static readonly RULE_conformanceItem = 33;
    public static readonly RULE_relationshipMaterializationDecl = 34;
    public static readonly RULE_operationBindingDecl = 35;
    public static readonly RULE_memberOperationRef = 36;
    public static readonly RULE_operationName = 37;
    public static readonly RULE_operationProvider = 38;
    public static readonly RULE_statePrimitive = 39;
    public static readonly RULE_edgePrimitive = 40;
    public static readonly RULE_dependencyBindingBlock = 41;
    public static readonly RULE_dependencyBinding = 42;
    public static readonly RULE_constructorBindingDecl = 43;
    public static readonly RULE_valueType = 44;
    public static readonly RULE_scalarType = 45;
    public static readonly RULE_cardinality = 46;
    public static readonly RULE_jsonLiteral = 47;
    public static readonly RULE_jsonObject = 48;
    public static readonly RULE_jsonMember = 49;
    public static readonly RULE_jsonArray = 50;
    public static readonly RULE_identifier = 51;
    public static readonly RULE_stringLiteral = 52;

    public static readonly literalNames = [
        null, "'workspace'", "'atom'", "'interface'", "'interfaces'", "'package'", 
        "'value'", "'relation'", "'operation'", "'function'", "'constructor'", 
        "'constructs'", "'conform'", "'as'", "'bind'", "'to'", "'private'", 
        "'shared'", "'state'", "'edge'", "'projection'", "'with'", "'using'", 
        "'via'", "'materialize'", "'if'", "'absent'", "'on'", "'policy'", 
        "'default'", "'source'", "'repository'", "'commit'", "'revision'", 
        "'id'", "'doc'", "'mode'", "'emits'", "'receiver'", "'requires'", 
        "'any'", "'get'", "'set'", "'watch'", "'start'", "'stop'", "'read'", 
        "'write'", "'resolve'", "'connect'", "'disconnect'", "'call'", "'watch-start'", 
        "'watch-stop'", "'subscribe'", "'unsubscribe'", "'optimistic-register'", 
        "'crdt'", "'optional-one'", "'exactly-one'", "'many-unique'", "'many'", 
        "'ordered'", "'unit'", "'watch-handle'", "'message'", "'atom-ref'", 
        "'interface-ref'", "'optional'", "'list'", "'bool'", "'bytes'", 
        "'double'", "'int32'", "'int64'", "'string'", "'uint32'", "'uint64'", 
        "'true'", "'false'", "'null'", "'->'", "':'", "';'", "','", "'.'", 
        "'{'", "'}'", "'['", "']'", "'('", "')'", "'<'", "'>'"
    ];

    public static readonly symbolicNames = [
        null, "WORKSPACE", "ATOM", "INTERFACE", "INTERFACES", "PACKAGE", 
        "VALUE", "RELATION", "OPERATION", "FUNCTION", "CONSTRUCTOR", "CONSTRUCTS", 
        "CONFORM", "AS", "BIND", "TO", "PRIVATE", "SHARED", "STATE", "EDGE", 
        "PROJECTION", "WITH", "USING", "VIA", "MATERIALIZE", "IF", "ABSENT", 
        "ON", "POLICY", "DEFAULT", "SOURCE", "REPOSITORY", "COMMIT", "REVISION", 
        "ID", "DOC", "MODE", "EMITS", "RECEIVER", "REQUIRES", "ANY", "GET", 
        "SET", "WATCH", "START", "STOP", "READ", "WRITE", "RESOLVE", "CONNECT", 
        "DISCONNECT", "CALL", "WATCH_START", "WATCH_STOP", "SUBSCRIBE", 
        "UNSUBSCRIBE", "OPTIMISTIC_REGISTER", "CRDT", "OPTIONAL_ONE", "EXACTLY_ONE", 
        "MANY_UNIQUE", "MANY", "ORDERED", "UNIT", "WATCH_HANDLE", "MESSAGE", 
        "ATOM_REF", "INTERFACE_REF", "OPTIONAL", "LIST", "BOOL", "BYTES", 
        "DOUBLE", "INT32", "INT64", "STRING", "UINT32", "UINT64", "TRUE", 
        "FALSE", "NULL", "ARROW", "COLON", "SEMI", "COMMA", "DOT", "LBRACE", 
        "RBRACE", "LBRACK", "RBRACK", "LPAREN", "RPAREN", "LT", "GT", "INTEGER", 
        "JSON_NUMBER", "IDENTIFIER", "STRING_LITERAL", "LINE_COMMENT", "BLOCK_COMMENT", 
        "WS"
    ];
    public static readonly ruleNames = [
        "document", "workspaceDecl", "workspaceItem", "atomDecl", "interfaceDecl", 
        "sourceBlock", "interfaceMember", "operationMember", "valueMember", 
        "valueMemberOperation", "relationshipMember", "relationshipOperation", 
        "targetConstraint", "packageDecl", "packageExport", "packageOperationExport", 
        "packageFunctionExport", "packageConstructorExport", "eventClause", 
        "operationMode", "receiverRequirement", "identifierList", "dependencyBlock", 
        "dependencyPort", "primitiveList", "primitive", "sharedAttachmentDecl", 
        "attachmentDecl", "stateDecl", "storagePolicy", "edgeDecl", "edgeEndpoint", 
        "conformanceDecl", "conformanceItem", "relationshipMaterializationDecl", 
        "operationBindingDecl", "memberOperationRef", "operationName", "operationProvider", 
        "statePrimitive", "edgePrimitive", "dependencyBindingBlock", "dependencyBinding", 
        "constructorBindingDecl", "valueType", "scalarType", "cardinality", 
        "jsonLiteral", "jsonObject", "jsonMember", "jsonArray", "identifier", 
        "stringLiteral",
    ];

    public get grammarFileName(): string { return "QuixosCapability.g4"; }
    public get literalNames(): (string | null)[] { return QuixosCapabilityParser.literalNames; }
    public get symbolicNames(): (string | null)[] { return QuixosCapabilityParser.symbolicNames; }
    public get ruleNames(): string[] { return QuixosCapabilityParser.ruleNames; }
    public get serializedATN(): number[] { return QuixosCapabilityParser._serializedATN; }

    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException {
        return new antlr.FailedPredicateException(this, predicate, message);
    }

    public constructor(input: antlr.TokenStream) {
        super(input);
        this.interpreter = new antlr.ParserATNSimulator(this, QuixosCapabilityParser._ATN, QuixosCapabilityParser.decisionsToDFA, new antlr.PredictionContextCache());
    }
    public document(): DocumentContext {
        let localContext = new DocumentContext(this.context, this.state);
        this.enterRule(localContext, 0, QuixosCapabilityParser.RULE_document);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 106;
            this.workspaceDecl();
            this.state = 107;
            this.match(QuixosCapabilityParser.EOF);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public workspaceDecl(): WorkspaceDeclContext {
        let localContext = new WorkspaceDeclContext(this.context, this.state);
        this.enterRule(localContext, 2, QuixosCapabilityParser.RULE_workspaceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 109;
            this.match(QuixosCapabilityParser.WORKSPACE);
            this.state = 110;
            this.identifier();
            this.state = 111;
            this.match(QuixosCapabilityParser.ID);
            this.state = 112;
            this.stringLiteral();
            this.state = 113;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 114;
            this.stringLiteral();
            this.state = 115;
            this.match(QuixosCapabilityParser.COMMIT);
            this.state = 116;
            this.stringLiteral();
            this.state = 117;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 121;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 136236) !== 0)) {
                {
                {
                this.state = 118;
                this.workspaceItem();
                }
                }
                this.state = 123;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 124;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public workspaceItem(): WorkspaceItemContext {
        let localContext = new WorkspaceItemContext(this.context, this.state);
        this.enterRule(localContext, 4, QuixosCapabilityParser.RULE_workspaceItem);
        try {
            this.state = 132;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 126;
                this.atomDecl();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 127;
                this.interfaceDecl();
                }
                break;
            case QuixosCapabilityParser.PACKAGE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 128;
                this.packageDecl();
                }
                break;
            case QuixosCapabilityParser.SHARED:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 129;
                this.sharedAttachmentDecl();
                }
                break;
            case QuixosCapabilityParser.CONFORM:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 130;
                this.conformanceDecl();
                }
                break;
            case QuixosCapabilityParser.CONSTRUCTOR:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 131;
                this.constructorBindingDecl();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public atomDecl(): AtomDeclContext {
        let localContext = new AtomDeclContext(this.context, this.state);
        this.enterRule(localContext, 6, QuixosCapabilityParser.RULE_atomDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 134;
            this.match(QuixosCapabilityParser.ATOM);
            this.state = 135;
            this.identifier();
            this.state = 136;
            this.match(QuixosCapabilityParser.ID);
            this.state = 137;
            this.stringLiteral();
            this.state = 140;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 35) {
                {
                this.state = 138;
                this.match(QuixosCapabilityParser.DOC);
                this.state = 139;
                this.stringLiteral();
                }
            }

            this.state = 142;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public interfaceDecl(): InterfaceDeclContext {
        let localContext = new InterfaceDeclContext(this.context, this.state);
        this.enterRule(localContext, 8, QuixosCapabilityParser.RULE_interfaceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 144;
            this.match(QuixosCapabilityParser.INTERFACE);
            this.state = 145;
            this.identifier();
            this.state = 146;
            this.match(QuixosCapabilityParser.ID);
            this.state = 147;
            this.stringLiteral();
            this.state = 148;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 149;
            this.stringLiteral();
            this.state = 150;
            this.sourceBlock();
            this.state = 151;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 155;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 448) !== 0)) {
                {
                {
                this.state = 152;
                this.interfaceMember();
                }
                }
                this.state = 157;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 158;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public sourceBlock(): SourceBlockContext {
        let localContext = new SourceBlockContext(this.context, this.state);
        this.enterRule(localContext, 10, QuixosCapabilityParser.RULE_sourceBlock);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 160;
            this.match(QuixosCapabilityParser.SOURCE);
            this.state = 161;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 162;
            this.match(QuixosCapabilityParser.REPOSITORY);
            this.state = 163;
            this.stringLiteral();
            this.state = 164;
            this.match(QuixosCapabilityParser.SEMI);
            this.state = 165;
            this.match(QuixosCapabilityParser.COMMIT);
            this.state = 166;
            this.stringLiteral();
            this.state = 167;
            this.match(QuixosCapabilityParser.SEMI);
            this.state = 168;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public interfaceMember(): InterfaceMemberContext {
        let localContext = new InterfaceMemberContext(this.context, this.state);
        this.enterRule(localContext, 12, QuixosCapabilityParser.RULE_interfaceMember);
        try {
            this.state = 173;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 170;
                this.valueMember();
                }
                break;
            case QuixosCapabilityParser.RELATION:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 171;
                this.relationshipMember();
                }
                break;
            case QuixosCapabilityParser.OPERATION:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 172;
                this.operationMember();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationMember(): OperationMemberContext {
        let localContext = new OperationMemberContext(this.context, this.state);
        this.enterRule(localContext, 14, QuixosCapabilityParser.RULE_operationMember);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 175;
            this.match(QuixosCapabilityParser.OPERATION);
            this.state = 176;
            this.identifier();
            this.state = 177;
            this.match(QuixosCapabilityParser.ID);
            this.state = 178;
            this.stringLiteral();
            this.state = 179;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 180;
            this.valueType();
            this.state = 181;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 182;
            this.valueType();
            this.state = 183;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 184;
            this.match(QuixosCapabilityParser.CALL);
            this.state = 185;
            this.match(QuixosCapabilityParser.ID);
            this.state = 186;
            this.stringLiteral();
            this.state = 187;
            this.match(QuixosCapabilityParser.SEMI);
            this.state = 188;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public valueMember(): ValueMemberContext {
        let localContext = new ValueMemberContext(this.context, this.state);
        this.enterRule(localContext, 16, QuixosCapabilityParser.RULE_valueMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 190;
            this.match(QuixosCapabilityParser.VALUE);
            this.state = 191;
            this.identifier();
            this.state = 192;
            this.match(QuixosCapabilityParser.ID);
            this.state = 193;
            this.stringLiteral();
            this.state = 194;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 195;
            this.valueType();
            this.state = 196;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 200;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 41)) & ~0x1F) === 0 && ((1 << (_la - 41)) & 7) !== 0)) {
                {
                {
                this.state = 197;
                this.valueMemberOperation();
                }
                }
                this.state = 202;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 203;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public valueMemberOperation(): ValueMemberOperationContext {
        let localContext = new ValueMemberOperationContext(this.context, this.state);
        this.enterRule(localContext, 18, QuixosCapabilityParser.RULE_valueMemberOperation);
        try {
            this.state = 224;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.GET:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 205;
                this.match(QuixosCapabilityParser.GET);
                this.state = 206;
                this.match(QuixosCapabilityParser.ID);
                this.state = 207;
                this.stringLiteral();
                this.state = 208;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.SET:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 210;
                this.match(QuixosCapabilityParser.SET);
                this.state = 211;
                this.match(QuixosCapabilityParser.ID);
                this.state = 212;
                this.stringLiteral();
                this.state = 213;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.WATCH:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 215;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 216;
                this.match(QuixosCapabilityParser.START);
                this.state = 217;
                this.match(QuixosCapabilityParser.ID);
                this.state = 218;
                this.stringLiteral();
                this.state = 219;
                this.match(QuixosCapabilityParser.STOP);
                this.state = 220;
                this.match(QuixosCapabilityParser.ID);
                this.state = 221;
                this.stringLiteral();
                this.state = 222;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relationshipMember(): RelationshipMemberContext {
        let localContext = new RelationshipMemberContext(this.context, this.state);
        this.enterRule(localContext, 20, QuixosCapabilityParser.RULE_relationshipMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 226;
            this.match(QuixosCapabilityParser.RELATION);
            this.state = 227;
            this.identifier();
            this.state = 228;
            this.match(QuixosCapabilityParser.ID);
            this.state = 229;
            this.stringLiteral();
            this.state = 230;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 231;
            this.cardinality();
            this.state = 232;
            this.targetConstraint();
            this.state = 234;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 62) {
                {
                this.state = 233;
                this.match(QuixosCapabilityParser.ORDERED);
                }
            }

            this.state = 236;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 240;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 225) !== 0)) {
                {
                {
                this.state = 237;
                this.relationshipOperation();
                }
                }
                this.state = 242;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 243;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relationshipOperation(): RelationshipOperationContext {
        let localContext = new RelationshipOperationContext(this.context, this.state);
        this.enterRule(localContext, 22, QuixosCapabilityParser.RULE_relationshipOperation);
        try {
            this.state = 269;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.RESOLVE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 245;
                this.match(QuixosCapabilityParser.RESOLVE);
                this.state = 246;
                this.match(QuixosCapabilityParser.ID);
                this.state = 247;
                this.stringLiteral();
                this.state = 248;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CONNECT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 250;
                this.match(QuixosCapabilityParser.CONNECT);
                this.state = 251;
                this.match(QuixosCapabilityParser.ID);
                this.state = 252;
                this.stringLiteral();
                this.state = 253;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.DISCONNECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 255;
                this.match(QuixosCapabilityParser.DISCONNECT);
                this.state = 256;
                this.match(QuixosCapabilityParser.ID);
                this.state = 257;
                this.stringLiteral();
                this.state = 258;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.WATCH:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 260;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 261;
                this.match(QuixosCapabilityParser.START);
                this.state = 262;
                this.match(QuixosCapabilityParser.ID);
                this.state = 263;
                this.stringLiteral();
                this.state = 264;
                this.match(QuixosCapabilityParser.STOP);
                this.state = 265;
                this.match(QuixosCapabilityParser.ID);
                this.state = 266;
                this.stringLiteral();
                this.state = 267;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public targetConstraint(): TargetConstraintContext {
        let localContext = new TargetConstraintContext(this.context, this.state);
        this.enterRule(localContext, 24, QuixosCapabilityParser.RULE_targetConstraint);
        try {
            this.state = 275;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 271;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 272;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 273;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 274;
                this.identifier();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageDecl(): PackageDeclContext {
        let localContext = new PackageDeclContext(this.context, this.state);
        this.enterRule(localContext, 26, QuixosCapabilityParser.RULE_packageDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 277;
            this.match(QuixosCapabilityParser.PACKAGE);
            this.state = 278;
            this.identifier();
            this.state = 279;
            this.match(QuixosCapabilityParser.ID);
            this.state = 280;
            this.stringLiteral();
            this.state = 281;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 282;
            this.stringLiteral();
            this.state = 283;
            this.sourceBlock();
            this.state = 284;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 288;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 1792) !== 0)) {
                {
                {
                this.state = 285;
                this.packageExport();
                }
                }
                this.state = 290;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 291;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageExport(): PackageExportContext {
        let localContext = new PackageExportContext(this.context, this.state);
        this.enterRule(localContext, 28, QuixosCapabilityParser.RULE_packageExport);
        try {
            this.state = 296;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.OPERATION:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 293;
                this.packageOperationExport();
                }
                break;
            case QuixosCapabilityParser.FUNCTION:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 294;
                this.packageFunctionExport();
                }
                break;
            case QuixosCapabilityParser.CONSTRUCTOR:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 295;
                this.packageConstructorExport();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageOperationExport(): PackageOperationExportContext {
        let localContext = new PackageOperationExportContext(this.context, this.state);
        this.enterRule(localContext, 30, QuixosCapabilityParser.RULE_packageOperationExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 298;
            this.match(QuixosCapabilityParser.OPERATION);
            this.state = 299;
            this.identifier();
            this.state = 300;
            this.match(QuixosCapabilityParser.ID);
            this.state = 301;
            this.stringLiteral();
            this.state = 302;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 303;
            this.valueType();
            this.state = 304;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 305;
            this.valueType();
            this.state = 306;
            this.match(QuixosCapabilityParser.MODE);
            this.state = 307;
            this.operationMode();
            this.state = 309;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 37) {
                {
                this.state = 308;
                this.eventClause();
                }
            }

            this.state = 311;
            this.match(QuixosCapabilityParser.RECEIVER);
            this.state = 312;
            this.receiverRequirement();
            this.state = 314;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 39) {
                {
                this.state = 313;
                this.dependencyBlock();
                }
            }

            this.state = 316;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageFunctionExport(): PackageFunctionExportContext {
        let localContext = new PackageFunctionExportContext(this.context, this.state);
        this.enterRule(localContext, 32, QuixosCapabilityParser.RULE_packageFunctionExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 318;
            this.match(QuixosCapabilityParser.FUNCTION);
            this.state = 319;
            this.identifier();
            this.state = 320;
            this.match(QuixosCapabilityParser.ID);
            this.state = 321;
            this.stringLiteral();
            this.state = 322;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 323;
            this.valueType();
            this.state = 324;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 325;
            this.valueType();
            this.state = 327;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 39) {
                {
                this.state = 326;
                this.dependencyBlock();
                }
            }

            this.state = 329;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageConstructorExport(): PackageConstructorExportContext {
        let localContext = new PackageConstructorExportContext(this.context, this.state);
        this.enterRule(localContext, 34, QuixosCapabilityParser.RULE_packageConstructorExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 331;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 332;
            this.identifier();
            this.state = 333;
            this.match(QuixosCapabilityParser.ID);
            this.state = 334;
            this.stringLiteral();
            this.state = 335;
            this.match(QuixosCapabilityParser.CONSTRUCTS);
            this.state = 336;
            this.identifier();
            this.state = 337;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 338;
            this.valueType();
            this.state = 340;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 39) {
                {
                this.state = 339;
                this.dependencyBlock();
                }
            }

            this.state = 342;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public eventClause(): EventClauseContext {
        let localContext = new EventClauseContext(this.context, this.state);
        this.enterRule(localContext, 36, QuixosCapabilityParser.RULE_eventClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 344;
            this.match(QuixosCapabilityParser.EMITS);
            this.state = 345;
            this.valueType();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationMode(): OperationModeContext {
        let localContext = new OperationModeContext(this.context, this.state);
        this.enterRule(localContext, 38, QuixosCapabilityParser.RULE_operationMode);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 347;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 51)) & ~0x1F) === 0 && ((1 << (_la - 51)) & 31) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public receiverRequirement(): ReceiverRequirementContext {
        let localContext = new ReceiverRequirementContext(this.context, this.state);
        this.enterRule(localContext, 40, QuixosCapabilityParser.RULE_receiverRequirement);
        let _la: number;
        try {
            this.state = 358;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ANY:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 349;
                this.match(QuixosCapabilityParser.ANY);
                }
                break;
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 350;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 351;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACES:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 352;
                this.match(QuixosCapabilityParser.INTERFACES);
                this.state = 353;
                this.match(QuixosCapabilityParser.LBRACK);
                this.state = 355;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 30 || _la === 96) {
                    {
                    this.state = 354;
                    this.identifierList();
                    }
                }

                this.state = 357;
                this.match(QuixosCapabilityParser.RBRACK);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifierList(): IdentifierListContext {
        let localContext = new IdentifierListContext(this.context, this.state);
        this.enterRule(localContext, 42, QuixosCapabilityParser.RULE_identifierList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 360;
            this.identifier();
            this.state = 365;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 84) {
                {
                {
                this.state = 361;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 362;
                this.identifier();
                }
                }
                this.state = 367;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dependencyBlock(): DependencyBlockContext {
        let localContext = new DependencyBlockContext(this.context, this.state);
        this.enterRule(localContext, 44, QuixosCapabilityParser.RULE_dependencyBlock);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 368;
            this.match(QuixosCapabilityParser.REQUIRES);
            this.state = 369;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 373;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 787464) !== 0)) {
                {
                {
                this.state = 370;
                this.dependencyPort();
                }
                }
                this.state = 375;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 376;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dependencyPort(): DependencyPortContext {
        let localContext = new DependencyPortContext(this.context, this.state);
        this.enterRule(localContext, 46, QuixosCapabilityParser.RULE_dependencyPort);
        try {
            this.state = 413;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 378;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 379;
                this.identifier();
                this.state = 380;
                this.match(QuixosCapabilityParser.ID);
                this.state = 381;
                this.stringLiteral();
                this.state = 382;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 383;
                this.valueType();
                this.state = 384;
                this.primitiveList();
                this.state = 385;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 387;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 388;
                this.identifier();
                this.state = 389;
                this.match(QuixosCapabilityParser.ID);
                this.state = 390;
                this.stringLiteral();
                this.state = 391;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 392;
                this.cardinality();
                this.state = 393;
                this.targetConstraint();
                this.state = 394;
                this.primitiveList();
                this.state = 395;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 397;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 398;
                this.identifier();
                this.state = 399;
                this.match(QuixosCapabilityParser.ID);
                this.state = 400;
                this.stringLiteral();
                this.state = 401;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 402;
                this.identifier();
                this.state = 403;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CONSTRUCTOR:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 405;
                this.match(QuixosCapabilityParser.CONSTRUCTOR);
                this.state = 406;
                this.identifier();
                this.state = 407;
                this.match(QuixosCapabilityParser.ID);
                this.state = 408;
                this.stringLiteral();
                this.state = 409;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 410;
                this.identifier();
                this.state = 411;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public primitiveList(): PrimitiveListContext {
        let localContext = new PrimitiveListContext(this.context, this.state);
        this.enterRule(localContext, 48, QuixosCapabilityParser.RULE_primitiveList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 415;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 416;
            this.primitive();
            this.state = 421;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 84) {
                {
                {
                this.state = 417;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 418;
                this.primitive();
                }
                }
                this.state = 423;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 424;
            this.match(QuixosCapabilityParser.RBRACK);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public primitive(): PrimitiveContext {
        let localContext = new PrimitiveContext(this.context, this.state);
        this.enterRule(localContext, 50, QuixosCapabilityParser.RULE_primitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 426;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 46)) & ~0x1F) === 0 && ((1 << (_la - 46)) & 223) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public sharedAttachmentDecl(): SharedAttachmentDeclContext {
        let localContext = new SharedAttachmentDeclContext(this.context, this.state);
        this.enterRule(localContext, 52, QuixosCapabilityParser.RULE_sharedAttachmentDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 428;
            this.match(QuixosCapabilityParser.SHARED);
            this.state = 429;
            this.attachmentDecl();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public attachmentDecl(): AttachmentDeclContext {
        let localContext = new AttachmentDeclContext(this.context, this.state);
        this.enterRule(localContext, 54, QuixosCapabilityParser.RULE_attachmentDecl);
        try {
            this.state = 433;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 431;
                this.stateDecl();
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 432;
                this.edgeDecl();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stateDecl(): StateDeclContext {
        let localContext = new StateDeclContext(this.context, this.state);
        this.enterRule(localContext, 56, QuixosCapabilityParser.RULE_stateDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 435;
            this.match(QuixosCapabilityParser.STATE);
            this.state = 436;
            this.identifier();
            this.state = 437;
            this.match(QuixosCapabilityParser.ID);
            this.state = 438;
            this.stringLiteral();
            this.state = 439;
            this.match(QuixosCapabilityParser.ON);
            this.state = 440;
            this.identifier();
            this.state = 441;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 442;
            this.valueType();
            this.state = 443;
            this.match(QuixosCapabilityParser.POLICY);
            this.state = 444;
            this.storagePolicy();
            this.state = 447;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 29) {
                {
                this.state = 445;
                this.match(QuixosCapabilityParser.DEFAULT);
                this.state = 446;
                this.jsonLiteral();
                }
            }

            this.state = 449;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public storagePolicy(): StoragePolicyContext {
        let localContext = new StoragePolicyContext(this.context, this.state);
        this.enterRule(localContext, 58, QuixosCapabilityParser.RULE_storagePolicy);
        try {
            this.state = 457;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.OPTIMISTIC_REGISTER:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 451;
                this.match(QuixosCapabilityParser.OPTIMISTIC_REGISTER);
                }
                break;
            case QuixosCapabilityParser.CRDT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 452;
                this.match(QuixosCapabilityParser.CRDT);
                this.state = 453;
                this.match(QuixosCapabilityParser.LPAREN);
                this.state = 454;
                this.valueType();
                this.state = 455;
                this.match(QuixosCapabilityParser.RPAREN);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public edgeDecl(): EdgeDeclContext {
        let localContext = new EdgeDeclContext(this.context, this.state);
        this.enterRule(localContext, 60, QuixosCapabilityParser.RULE_edgeDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 459;
            this.match(QuixosCapabilityParser.EDGE);
            this.state = 460;
            this.identifier();
            this.state = 461;
            this.match(QuixosCapabilityParser.ID);
            this.state = 462;
            this.stringLiteral();
            this.state = 463;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 464;
            this.edgeEndpoint();
            this.state = 465;
            this.edgeEndpoint();
            this.state = 466;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public edgeEndpoint(): EdgeEndpointContext {
        let localContext = new EdgeEndpointContext(this.context, this.state);
        this.enterRule(localContext, 62, QuixosCapabilityParser.RULE_edgeEndpoint);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 468;
            this.targetConstraint();
            this.state = 469;
            this.match(QuixosCapabilityParser.PROJECTION);
            this.state = 470;
            this.identifier();
            this.state = 471;
            this.match(QuixosCapabilityParser.ID);
            this.state = 472;
            this.stringLiteral();
            this.state = 473;
            this.cardinality();
            this.state = 475;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 62) {
                {
                this.state = 474;
                this.match(QuixosCapabilityParser.ORDERED);
                }
            }

            this.state = 477;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public conformanceDecl(): ConformanceDeclContext {
        let localContext = new ConformanceDeclContext(this.context, this.state);
        this.enterRule(localContext, 64, QuixosCapabilityParser.RULE_conformanceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 479;
            this.match(QuixosCapabilityParser.CONFORM);
            this.state = 480;
            this.identifier();
            this.state = 481;
            this.match(QuixosCapabilityParser.AS);
            this.state = 482;
            this.identifier();
            this.state = 483;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 487;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 16859136) !== 0)) {
                {
                {
                this.state = 484;
                this.conformanceItem();
                }
                }
                this.state = 489;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 490;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public conformanceItem(): ConformanceItemContext {
        let localContext = new ConformanceItemContext(this.context, this.state);
        this.enterRule(localContext, 66, QuixosCapabilityParser.RULE_conformanceItem);
        try {
            this.state = 496;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.PRIVATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 492;
                this.match(QuixosCapabilityParser.PRIVATE);
                this.state = 493;
                this.attachmentDecl();
                }
                break;
            case QuixosCapabilityParser.BIND:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 494;
                this.operationBindingDecl();
                }
                break;
            case QuixosCapabilityParser.MATERIALIZE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 495;
                this.relationshipMaterializationDecl();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relationshipMaterializationDecl(): RelationshipMaterializationDeclContext {
        let localContext = new RelationshipMaterializationDeclContext(this.context, this.state);
        this.enterRule(localContext, 68, QuixosCapabilityParser.RULE_relationshipMaterializationDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 498;
            this.match(QuixosCapabilityParser.MATERIALIZE);
            this.state = 499;
            this.identifier();
            this.state = 500;
            this.match(QuixosCapabilityParser.IF);
            this.state = 501;
            this.match(QuixosCapabilityParser.ABSENT);
            this.state = 502;
            this.match(QuixosCapabilityParser.USING);
            this.state = 503;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 504;
            this.identifier();
            this.state = 505;
            this.match(QuixosCapabilityParser.VIA);
            this.state = 506;
            this.match(QuixosCapabilityParser.EDGE);
            this.state = 507;
            this.identifier();
            this.state = 508;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 509;
            this.identifier();
            this.state = 510;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationBindingDecl(): OperationBindingDeclContext {
        let localContext = new OperationBindingDeclContext(this.context, this.state);
        this.enterRule(localContext, 70, QuixosCapabilityParser.RULE_operationBindingDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 512;
            this.match(QuixosCapabilityParser.BIND);
            this.state = 513;
            this.memberOperationRef();
            this.state = 514;
            this.match(QuixosCapabilityParser.TO);
            this.state = 515;
            this.operationProvider();
            this.state = 516;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public memberOperationRef(): MemberOperationRefContext {
        let localContext = new MemberOperationRefContext(this.context, this.state);
        this.enterRule(localContext, 72, QuixosCapabilityParser.RULE_memberOperationRef);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 518;
            this.identifier();
            this.state = 519;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 520;
            this.operationName();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationName(): OperationNameContext {
        let localContext = new OperationNameContext(this.context, this.state);
        this.enterRule(localContext, 74, QuixosCapabilityParser.RULE_operationName);
        try {
            this.state = 533;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.SOURCE:
            case QuixosCapabilityParser.IDENTIFIER:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 522;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.CALL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 523;
                this.match(QuixosCapabilityParser.CALL);
                }
                break;
            case QuixosCapabilityParser.GET:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 524;
                this.match(QuixosCapabilityParser.GET);
                }
                break;
            case QuixosCapabilityParser.SET:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 525;
                this.match(QuixosCapabilityParser.SET);
                }
                break;
            case QuixosCapabilityParser.RESOLVE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 526;
                this.match(QuixosCapabilityParser.RESOLVE);
                }
                break;
            case QuixosCapabilityParser.CONNECT:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 527;
                this.match(QuixosCapabilityParser.CONNECT);
                }
                break;
            case QuixosCapabilityParser.DISCONNECT:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 528;
                this.match(QuixosCapabilityParser.DISCONNECT);
                }
                break;
            case QuixosCapabilityParser.WATCH_START:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 529;
                this.match(QuixosCapabilityParser.WATCH_START);
                }
                break;
            case QuixosCapabilityParser.WATCH_STOP:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 530;
                this.match(QuixosCapabilityParser.WATCH_STOP);
                }
                break;
            case QuixosCapabilityParser.SUBSCRIBE:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 531;
                this.match(QuixosCapabilityParser.SUBSCRIBE);
                }
                break;
            case QuixosCapabilityParser.UNSUBSCRIBE:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 532;
                this.match(QuixosCapabilityParser.UNSUBSCRIBE);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationProvider(): OperationProviderContext {
        let localContext = new OperationProviderContext(this.context, this.state);
        this.enterRule(localContext, 76, QuixosCapabilityParser.RULE_operationProvider);
        let _la: number;
        try {
            this.state = 554;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 535;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 536;
                this.identifier();
                this.state = 537;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 538;
                this.statePrimitive();
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 540;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 541;
                this.identifier();
                this.state = 542;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 543;
                this.identifier();
                this.state = 544;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 545;
                this.edgePrimitive();
                }
                break;
            case QuixosCapabilityParser.PACKAGE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 547;
                this.match(QuixosCapabilityParser.PACKAGE);
                this.state = 548;
                this.identifier();
                this.state = 549;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 550;
                this.identifier();
                this.state = 552;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 21) {
                    {
                    this.state = 551;
                    this.dependencyBindingBlock();
                    }
                }

                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public statePrimitive(): StatePrimitiveContext {
        let localContext = new StatePrimitiveContext(this.context, this.state);
        this.enterRule(localContext, 78, QuixosCapabilityParser.RULE_statePrimitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 556;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 46)) & ~0x1F) === 0 && ((1 << (_la - 46)) & 195) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public edgePrimitive(): EdgePrimitiveContext {
        let localContext = new EdgePrimitiveContext(this.context, this.state);
        this.enterRule(localContext, 80, QuixosCapabilityParser.RULE_edgePrimitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 558;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 48)) & ~0x1F) === 0 && ((1 << (_la - 48)) & 55) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dependencyBindingBlock(): DependencyBindingBlockContext {
        let localContext = new DependencyBindingBlockContext(this.context, this.state);
        this.enterRule(localContext, 82, QuixosCapabilityParser.RULE_dependencyBindingBlock);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 560;
            this.match(QuixosCapabilityParser.WITH);
            this.state = 561;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 565;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 30 || _la === 96) {
                {
                {
                this.state = 562;
                this.dependencyBinding();
                }
                }
                this.state = 567;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 568;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dependencyBinding(): DependencyBindingContext {
        let localContext = new DependencyBindingContext(this.context, this.state);
        this.enterRule(localContext, 84, QuixosCapabilityParser.RULE_dependencyBinding);
        let _la: number;
        try {
            this.state = 612;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 35, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 570;
                this.identifier();
                this.state = 571;
                this.match(QuixosCapabilityParser.TO);
                this.state = 572;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 573;
                this.identifier();
                this.state = 580;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 23) {
                    {
                    this.state = 574;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 575;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 576;
                    this.identifier();
                    this.state = 577;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 578;
                    this.identifier();
                    }
                }

                this.state = 582;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 584;
                this.identifier();
                this.state = 585;
                this.match(QuixosCapabilityParser.TO);
                this.state = 586;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 587;
                this.identifier();
                this.state = 588;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 589;
                this.identifier();
                this.state = 596;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 23) {
                    {
                    this.state = 590;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 591;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 592;
                    this.identifier();
                    this.state = 593;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 594;
                    this.identifier();
                    }
                }

                this.state = 598;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 600;
                this.identifier();
                this.state = 601;
                this.match(QuixosCapabilityParser.TO);
                this.state = 602;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 603;
                this.identifier();
                this.state = 604;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 606;
                this.identifier();
                this.state = 607;
                this.match(QuixosCapabilityParser.TO);
                this.state = 608;
                this.match(QuixosCapabilityParser.CONSTRUCTOR);
                this.state = 609;
                this.identifier();
                this.state = 610;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public constructorBindingDecl(): ConstructorBindingDeclContext {
        let localContext = new ConstructorBindingDeclContext(this.context, this.state);
        this.enterRule(localContext, 86, QuixosCapabilityParser.RULE_constructorBindingDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 614;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 615;
            this.identifier();
            this.state = 616;
            this.match(QuixosCapabilityParser.TO);
            this.state = 617;
            this.identifier();
            this.state = 618;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 619;
            this.identifier();
            this.state = 621;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 21) {
                {
                this.state = 620;
                this.dependencyBindingBlock();
                }
            }

            this.state = 623;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public valueType(): ValueTypeContext {
        let localContext = new ValueTypeContext(this.context, this.state);
        this.enterRule(localContext, 88, QuixosCapabilityParser.RULE_valueType);
        try {
            this.state = 650;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.BOOL:
            case QuixosCapabilityParser.BYTES:
            case QuixosCapabilityParser.DOUBLE:
            case QuixosCapabilityParser.INT32:
            case QuixosCapabilityParser.INT64:
            case QuixosCapabilityParser.STRING:
            case QuixosCapabilityParser.UINT32:
            case QuixosCapabilityParser.UINT64:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 625;
                this.scalarType();
                }
                break;
            case QuixosCapabilityParser.UNIT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 626;
                this.match(QuixosCapabilityParser.UNIT);
                }
                break;
            case QuixosCapabilityParser.WATCH_HANDLE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 627;
                this.match(QuixosCapabilityParser.WATCH_HANDLE);
                }
                break;
            case QuixosCapabilityParser.MESSAGE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 628;
                this.match(QuixosCapabilityParser.MESSAGE);
                this.state = 629;
                this.stringLiteral();
                }
                break;
            case QuixosCapabilityParser.ATOM_REF:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 630;
                this.match(QuixosCapabilityParser.ATOM_REF);
                this.state = 631;
                this.match(QuixosCapabilityParser.LT);
                this.state = 632;
                this.identifier();
                this.state = 633;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.INTERFACE_REF:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 635;
                this.match(QuixosCapabilityParser.INTERFACE_REF);
                this.state = 636;
                this.match(QuixosCapabilityParser.LT);
                this.state = 637;
                this.identifier();
                this.state = 638;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.OPTIONAL:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 640;
                this.match(QuixosCapabilityParser.OPTIONAL);
                this.state = 641;
                this.match(QuixosCapabilityParser.LT);
                this.state = 642;
                this.valueType();
                this.state = 643;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.LIST:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 645;
                this.match(QuixosCapabilityParser.LIST);
                this.state = 646;
                this.match(QuixosCapabilityParser.LT);
                this.state = 647;
                this.valueType();
                this.state = 648;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public scalarType(): ScalarTypeContext {
        let localContext = new ScalarTypeContext(this.context, this.state);
        this.enterRule(localContext, 90, QuixosCapabilityParser.RULE_scalarType);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 652;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 70)) & ~0x1F) === 0 && ((1 << (_la - 70)) & 255) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public cardinality(): CardinalityContext {
        let localContext = new CardinalityContext(this.context, this.state);
        this.enterRule(localContext, 92, QuixosCapabilityParser.RULE_cardinality);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 654;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 58)) & ~0x1F) === 0 && ((1 << (_la - 58)) & 15) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public jsonLiteral(): JsonLiteralContext {
        let localContext = new JsonLiteralContext(this.context, this.state);
        this.enterRule(localContext, 94, QuixosCapabilityParser.RULE_jsonLiteral);
        try {
            this.state = 664;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STRING_LITERAL:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 656;
                this.stringLiteral();
                }
                break;
            case QuixosCapabilityParser.INTEGER:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 657;
                this.match(QuixosCapabilityParser.INTEGER);
                }
                break;
            case QuixosCapabilityParser.JSON_NUMBER:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 658;
                this.match(QuixosCapabilityParser.JSON_NUMBER);
                }
                break;
            case QuixosCapabilityParser.TRUE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 659;
                this.match(QuixosCapabilityParser.TRUE);
                }
                break;
            case QuixosCapabilityParser.FALSE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 660;
                this.match(QuixosCapabilityParser.FALSE);
                }
                break;
            case QuixosCapabilityParser.NULL:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 661;
                this.match(QuixosCapabilityParser.NULL);
                }
                break;
            case QuixosCapabilityParser.LBRACE:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 662;
                this.jsonObject();
                }
                break;
            case QuixosCapabilityParser.LBRACK:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 663;
                this.jsonArray();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public jsonObject(): JsonObjectContext {
        let localContext = new JsonObjectContext(this.context, this.state);
        this.enterRule(localContext, 96, QuixosCapabilityParser.RULE_jsonObject);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 666;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 675;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 97) {
                {
                this.state = 667;
                this.jsonMember();
                this.state = 672;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 84) {
                    {
                    {
                    this.state = 668;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 669;
                    this.jsonMember();
                    }
                    }
                    this.state = 674;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 677;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public jsonMember(): JsonMemberContext {
        let localContext = new JsonMemberContext(this.context, this.state);
        this.enterRule(localContext, 98, QuixosCapabilityParser.RULE_jsonMember);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 679;
            this.stringLiteral();
            this.state = 680;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 681;
            this.jsonLiteral();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public jsonArray(): JsonArrayContext {
        let localContext = new JsonArrayContext(this.context, this.state);
        this.enterRule(localContext, 100, QuixosCapabilityParser.RULE_jsonArray);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 683;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 692;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 722183) !== 0)) {
                {
                this.state = 684;
                this.jsonLiteral();
                this.state = 689;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 84) {
                    {
                    {
                    this.state = 685;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 686;
                    this.jsonLiteral();
                    }
                    }
                    this.state = 691;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 694;
            this.match(QuixosCapabilityParser.RBRACK);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifier(): IdentifierContext {
        let localContext = new IdentifierContext(this.context, this.state);
        this.enterRule(localContext, 102, QuixosCapabilityParser.RULE_identifier);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 696;
            _la = this.tokenStream.LA(1);
            if(!(_la === 30 || _la === 96)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringLiteral(): StringLiteralContext {
        let localContext = new StringLiteralContext(this.context, this.state);
        this.enterRule(localContext, 104, QuixosCapabilityParser.RULE_stringLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 698;
            this.match(QuixosCapabilityParser.STRING_LITERAL);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public static readonly _serializedATN: number[] = [
        4,1,100,701,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,120,8,
        1,10,1,12,1,123,9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,3,2,133,8,2,
        1,3,1,3,1,3,1,3,1,3,1,3,3,3,141,8,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,
        1,4,1,4,1,4,1,4,5,4,154,8,4,10,4,12,4,157,9,4,1,4,1,4,1,5,1,5,1,
        5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,6,1,6,1,6,3,6,174,8,6,1,7,1,7,1,
        7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,
        8,1,8,1,8,1,8,1,8,5,8,199,8,8,10,8,12,8,202,9,8,1,8,1,8,1,9,1,9,
        1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,
        1,9,3,9,225,8,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,3,10,235,
        8,10,1,10,1,10,5,10,239,8,10,10,10,12,10,242,9,10,1,10,1,10,1,11,
        1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,
        1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,3,11,270,8,11,
        1,12,1,12,1,12,1,12,3,12,276,8,12,1,13,1,13,1,13,1,13,1,13,1,13,
        1,13,1,13,1,13,5,13,287,8,13,10,13,12,13,290,9,13,1,13,1,13,1,14,
        1,14,1,14,3,14,297,8,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,
        1,15,1,15,1,15,3,15,310,8,15,1,15,1,15,1,15,3,15,315,8,15,1,15,1,
        15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,328,8,16,1,
        16,1,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,341,8,
        17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,
        20,3,20,356,8,20,1,20,3,20,359,8,20,1,21,1,21,1,21,5,21,364,8,21,
        10,21,12,21,367,9,21,1,22,1,22,1,22,5,22,372,8,22,10,22,12,22,375,
        9,22,1,22,1,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
        1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
        1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,
        414,8,23,1,24,1,24,1,24,1,24,5,24,420,8,24,10,24,12,24,423,9,24,
        1,24,1,24,1,25,1,25,1,26,1,26,1,26,1,27,1,27,3,27,434,8,27,1,28,
        1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,3,28,448,
        8,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,3,29,458,8,29,1,30,
        1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,
        1,31,1,31,3,31,476,8,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,
        5,32,486,8,32,10,32,12,32,489,9,32,1,32,1,32,1,33,1,33,1,33,1,33,
        3,33,497,8,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,
        1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,
        1,36,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,
        534,8,37,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,
        1,38,1,38,1,38,1,38,1,38,1,38,3,38,553,8,38,3,38,555,8,38,1,39,1,
        39,1,40,1,40,1,41,1,41,1,41,5,41,564,8,41,10,41,12,41,567,9,41,1,
        41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,581,
        8,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,
        1,42,1,42,3,42,597,8,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,
        1,42,1,42,1,42,1,42,1,42,1,42,3,42,613,8,42,1,43,1,43,1,43,1,43,
        1,43,1,43,1,43,3,43,622,8,43,1,43,1,43,1,44,1,44,1,44,1,44,1,44,
        1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
        1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,651,8,44,1,45,1,45,1,46,
        1,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,665,8,47,1,48,
        1,48,1,48,1,48,5,48,671,8,48,10,48,12,48,674,9,48,3,48,676,8,48,
        1,48,1,48,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,5,50,688,8,50,
        10,50,12,50,691,9,50,3,50,693,8,50,1,50,1,50,1,51,1,51,1,52,1,52,
        1,52,0,0,53,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,
        38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,
        82,84,86,88,90,92,94,96,98,100,102,104,0,7,1,0,51,55,2,0,46,50,52,
        53,2,0,46,47,52,53,2,0,48,50,52,53,1,0,70,77,1,0,58,61,2,0,30,30,
        96,96,727,0,106,1,0,0,0,2,109,1,0,0,0,4,132,1,0,0,0,6,134,1,0,0,
        0,8,144,1,0,0,0,10,160,1,0,0,0,12,173,1,0,0,0,14,175,1,0,0,0,16,
        190,1,0,0,0,18,224,1,0,0,0,20,226,1,0,0,0,22,269,1,0,0,0,24,275,
        1,0,0,0,26,277,1,0,0,0,28,296,1,0,0,0,30,298,1,0,0,0,32,318,1,0,
        0,0,34,331,1,0,0,0,36,344,1,0,0,0,38,347,1,0,0,0,40,358,1,0,0,0,
        42,360,1,0,0,0,44,368,1,0,0,0,46,413,1,0,0,0,48,415,1,0,0,0,50,426,
        1,0,0,0,52,428,1,0,0,0,54,433,1,0,0,0,56,435,1,0,0,0,58,457,1,0,
        0,0,60,459,1,0,0,0,62,468,1,0,0,0,64,479,1,0,0,0,66,496,1,0,0,0,
        68,498,1,0,0,0,70,512,1,0,0,0,72,518,1,0,0,0,74,533,1,0,0,0,76,554,
        1,0,0,0,78,556,1,0,0,0,80,558,1,0,0,0,82,560,1,0,0,0,84,612,1,0,
        0,0,86,614,1,0,0,0,88,650,1,0,0,0,90,652,1,0,0,0,92,654,1,0,0,0,
        94,664,1,0,0,0,96,666,1,0,0,0,98,679,1,0,0,0,100,683,1,0,0,0,102,
        696,1,0,0,0,104,698,1,0,0,0,106,107,3,2,1,0,107,108,5,0,0,1,108,
        1,1,0,0,0,109,110,5,1,0,0,110,111,3,102,51,0,111,112,5,34,0,0,112,
        113,3,104,52,0,113,114,5,33,0,0,114,115,3,104,52,0,115,116,5,32,
        0,0,116,117,3,104,52,0,117,121,5,86,0,0,118,120,3,4,2,0,119,118,
        1,0,0,0,120,123,1,0,0,0,121,119,1,0,0,0,121,122,1,0,0,0,122,124,
        1,0,0,0,123,121,1,0,0,0,124,125,5,87,0,0,125,3,1,0,0,0,126,133,3,
        6,3,0,127,133,3,8,4,0,128,133,3,26,13,0,129,133,3,52,26,0,130,133,
        3,64,32,0,131,133,3,86,43,0,132,126,1,0,0,0,132,127,1,0,0,0,132,
        128,1,0,0,0,132,129,1,0,0,0,132,130,1,0,0,0,132,131,1,0,0,0,133,
        5,1,0,0,0,134,135,5,2,0,0,135,136,3,102,51,0,136,137,5,34,0,0,137,
        140,3,104,52,0,138,139,5,35,0,0,139,141,3,104,52,0,140,138,1,0,0,
        0,140,141,1,0,0,0,141,142,1,0,0,0,142,143,5,83,0,0,143,7,1,0,0,0,
        144,145,5,3,0,0,145,146,3,102,51,0,146,147,5,34,0,0,147,148,3,104,
        52,0,148,149,5,33,0,0,149,150,3,104,52,0,150,151,3,10,5,0,151,155,
        5,86,0,0,152,154,3,12,6,0,153,152,1,0,0,0,154,157,1,0,0,0,155,153,
        1,0,0,0,155,156,1,0,0,0,156,158,1,0,0,0,157,155,1,0,0,0,158,159,
        5,87,0,0,159,9,1,0,0,0,160,161,5,30,0,0,161,162,5,86,0,0,162,163,
        5,31,0,0,163,164,3,104,52,0,164,165,5,83,0,0,165,166,5,32,0,0,166,
        167,3,104,52,0,167,168,5,83,0,0,168,169,5,87,0,0,169,11,1,0,0,0,
        170,174,3,16,8,0,171,174,3,20,10,0,172,174,3,14,7,0,173,170,1,0,
        0,0,173,171,1,0,0,0,173,172,1,0,0,0,174,13,1,0,0,0,175,176,5,8,0,
        0,176,177,3,102,51,0,177,178,5,34,0,0,178,179,3,104,52,0,179,180,
        5,82,0,0,180,181,3,88,44,0,181,182,5,81,0,0,182,183,3,88,44,0,183,
        184,5,86,0,0,184,185,5,51,0,0,185,186,5,34,0,0,186,187,3,104,52,
        0,187,188,5,83,0,0,188,189,5,87,0,0,189,15,1,0,0,0,190,191,5,6,0,
        0,191,192,3,102,51,0,192,193,5,34,0,0,193,194,3,104,52,0,194,195,
        5,82,0,0,195,196,3,88,44,0,196,200,5,86,0,0,197,199,3,18,9,0,198,
        197,1,0,0,0,199,202,1,0,0,0,200,198,1,0,0,0,200,201,1,0,0,0,201,
        203,1,0,0,0,202,200,1,0,0,0,203,204,5,87,0,0,204,17,1,0,0,0,205,
        206,5,41,0,0,206,207,5,34,0,0,207,208,3,104,52,0,208,209,5,83,0,
        0,209,225,1,0,0,0,210,211,5,42,0,0,211,212,5,34,0,0,212,213,3,104,
        52,0,213,214,5,83,0,0,214,225,1,0,0,0,215,216,5,43,0,0,216,217,5,
        44,0,0,217,218,5,34,0,0,218,219,3,104,52,0,219,220,5,45,0,0,220,
        221,5,34,0,0,221,222,3,104,52,0,222,223,5,83,0,0,223,225,1,0,0,0,
        224,205,1,0,0,0,224,210,1,0,0,0,224,215,1,0,0,0,225,19,1,0,0,0,226,
        227,5,7,0,0,227,228,3,102,51,0,228,229,5,34,0,0,229,230,3,104,52,
        0,230,231,5,82,0,0,231,232,3,92,46,0,232,234,3,24,12,0,233,235,5,
        62,0,0,234,233,1,0,0,0,234,235,1,0,0,0,235,236,1,0,0,0,236,240,5,
        86,0,0,237,239,3,22,11,0,238,237,1,0,0,0,239,242,1,0,0,0,240,238,
        1,0,0,0,240,241,1,0,0,0,241,243,1,0,0,0,242,240,1,0,0,0,243,244,
        5,87,0,0,244,21,1,0,0,0,245,246,5,48,0,0,246,247,5,34,0,0,247,248,
        3,104,52,0,248,249,5,83,0,0,249,270,1,0,0,0,250,251,5,49,0,0,251,
        252,5,34,0,0,252,253,3,104,52,0,253,254,5,83,0,0,254,270,1,0,0,0,
        255,256,5,50,0,0,256,257,5,34,0,0,257,258,3,104,52,0,258,259,5,83,
        0,0,259,270,1,0,0,0,260,261,5,43,0,0,261,262,5,44,0,0,262,263,5,
        34,0,0,263,264,3,104,52,0,264,265,5,45,0,0,265,266,5,34,0,0,266,
        267,3,104,52,0,267,268,5,83,0,0,268,270,1,0,0,0,269,245,1,0,0,0,
        269,250,1,0,0,0,269,255,1,0,0,0,269,260,1,0,0,0,270,23,1,0,0,0,271,
        272,5,2,0,0,272,276,3,102,51,0,273,274,5,3,0,0,274,276,3,102,51,
        0,275,271,1,0,0,0,275,273,1,0,0,0,276,25,1,0,0,0,277,278,5,5,0,0,
        278,279,3,102,51,0,279,280,5,34,0,0,280,281,3,104,52,0,281,282,5,
        33,0,0,282,283,3,104,52,0,283,284,3,10,5,0,284,288,5,86,0,0,285,
        287,3,28,14,0,286,285,1,0,0,0,287,290,1,0,0,0,288,286,1,0,0,0,288,
        289,1,0,0,0,289,291,1,0,0,0,290,288,1,0,0,0,291,292,5,87,0,0,292,
        27,1,0,0,0,293,297,3,30,15,0,294,297,3,32,16,0,295,297,3,34,17,0,
        296,293,1,0,0,0,296,294,1,0,0,0,296,295,1,0,0,0,297,29,1,0,0,0,298,
        299,5,8,0,0,299,300,3,102,51,0,300,301,5,34,0,0,301,302,3,104,52,
        0,302,303,5,82,0,0,303,304,3,88,44,0,304,305,5,81,0,0,305,306,3,
        88,44,0,306,307,5,36,0,0,307,309,3,38,19,0,308,310,3,36,18,0,309,
        308,1,0,0,0,309,310,1,0,0,0,310,311,1,0,0,0,311,312,5,38,0,0,312,
        314,3,40,20,0,313,315,3,44,22,0,314,313,1,0,0,0,314,315,1,0,0,0,
        315,316,1,0,0,0,316,317,5,83,0,0,317,31,1,0,0,0,318,319,5,9,0,0,
        319,320,3,102,51,0,320,321,5,34,0,0,321,322,3,104,52,0,322,323,5,
        82,0,0,323,324,3,88,44,0,324,325,5,81,0,0,325,327,3,88,44,0,326,
        328,3,44,22,0,327,326,1,0,0,0,327,328,1,0,0,0,328,329,1,0,0,0,329,
        330,5,83,0,0,330,33,1,0,0,0,331,332,5,10,0,0,332,333,3,102,51,0,
        333,334,5,34,0,0,334,335,3,104,52,0,335,336,5,11,0,0,336,337,3,102,
        51,0,337,338,5,82,0,0,338,340,3,88,44,0,339,341,3,44,22,0,340,339,
        1,0,0,0,340,341,1,0,0,0,341,342,1,0,0,0,342,343,5,83,0,0,343,35,
        1,0,0,0,344,345,5,37,0,0,345,346,3,88,44,0,346,37,1,0,0,0,347,348,
        7,0,0,0,348,39,1,0,0,0,349,359,5,40,0,0,350,351,5,2,0,0,351,359,
        3,102,51,0,352,353,5,4,0,0,353,355,5,88,0,0,354,356,3,42,21,0,355,
        354,1,0,0,0,355,356,1,0,0,0,356,357,1,0,0,0,357,359,5,89,0,0,358,
        349,1,0,0,0,358,350,1,0,0,0,358,352,1,0,0,0,359,41,1,0,0,0,360,365,
        3,102,51,0,361,362,5,84,0,0,362,364,3,102,51,0,363,361,1,0,0,0,364,
        367,1,0,0,0,365,363,1,0,0,0,365,366,1,0,0,0,366,43,1,0,0,0,367,365,
        1,0,0,0,368,369,5,39,0,0,369,373,5,86,0,0,370,372,3,46,23,0,371,
        370,1,0,0,0,372,375,1,0,0,0,373,371,1,0,0,0,373,374,1,0,0,0,374,
        376,1,0,0,0,375,373,1,0,0,0,376,377,5,87,0,0,377,45,1,0,0,0,378,
        379,5,18,0,0,379,380,3,102,51,0,380,381,5,34,0,0,381,382,3,104,52,
        0,382,383,5,82,0,0,383,384,3,88,44,0,384,385,3,48,24,0,385,386,5,
        83,0,0,386,414,1,0,0,0,387,388,5,19,0,0,388,389,3,102,51,0,389,390,
        5,34,0,0,390,391,3,104,52,0,391,392,5,82,0,0,392,393,3,92,46,0,393,
        394,3,24,12,0,394,395,3,48,24,0,395,396,5,83,0,0,396,414,1,0,0,0,
        397,398,5,3,0,0,398,399,3,102,51,0,399,400,5,34,0,0,400,401,3,104,
        52,0,401,402,5,82,0,0,402,403,3,102,51,0,403,404,5,83,0,0,404,414,
        1,0,0,0,405,406,5,10,0,0,406,407,3,102,51,0,407,408,5,34,0,0,408,
        409,3,104,52,0,409,410,5,82,0,0,410,411,3,102,51,0,411,412,5,83,
        0,0,412,414,1,0,0,0,413,378,1,0,0,0,413,387,1,0,0,0,413,397,1,0,
        0,0,413,405,1,0,0,0,414,47,1,0,0,0,415,416,5,88,0,0,416,421,3,50,
        25,0,417,418,5,84,0,0,418,420,3,50,25,0,419,417,1,0,0,0,420,423,
        1,0,0,0,421,419,1,0,0,0,421,422,1,0,0,0,422,424,1,0,0,0,423,421,
        1,0,0,0,424,425,5,89,0,0,425,49,1,0,0,0,426,427,7,1,0,0,427,51,1,
        0,0,0,428,429,5,17,0,0,429,430,3,54,27,0,430,53,1,0,0,0,431,434,
        3,56,28,0,432,434,3,60,30,0,433,431,1,0,0,0,433,432,1,0,0,0,434,
        55,1,0,0,0,435,436,5,18,0,0,436,437,3,102,51,0,437,438,5,34,0,0,
        438,439,3,104,52,0,439,440,5,27,0,0,440,441,3,102,51,0,441,442,5,
        82,0,0,442,443,3,88,44,0,443,444,5,28,0,0,444,447,3,58,29,0,445,
        446,5,29,0,0,446,448,3,94,47,0,447,445,1,0,0,0,447,448,1,0,0,0,448,
        449,1,0,0,0,449,450,5,83,0,0,450,57,1,0,0,0,451,458,5,56,0,0,452,
        453,5,57,0,0,453,454,5,90,0,0,454,455,3,88,44,0,455,456,5,91,0,0,
        456,458,1,0,0,0,457,451,1,0,0,0,457,452,1,0,0,0,458,59,1,0,0,0,459,
        460,5,19,0,0,460,461,3,102,51,0,461,462,5,34,0,0,462,463,3,104,52,
        0,463,464,5,86,0,0,464,465,3,62,31,0,465,466,3,62,31,0,466,467,5,
        87,0,0,467,61,1,0,0,0,468,469,3,24,12,0,469,470,5,20,0,0,470,471,
        3,102,51,0,471,472,5,34,0,0,472,473,3,104,52,0,473,475,3,92,46,0,
        474,476,5,62,0,0,475,474,1,0,0,0,475,476,1,0,0,0,476,477,1,0,0,0,
        477,478,5,83,0,0,478,63,1,0,0,0,479,480,5,12,0,0,480,481,3,102,51,
        0,481,482,5,13,0,0,482,483,3,102,51,0,483,487,5,86,0,0,484,486,3,
        66,33,0,485,484,1,0,0,0,486,489,1,0,0,0,487,485,1,0,0,0,487,488,
        1,0,0,0,488,490,1,0,0,0,489,487,1,0,0,0,490,491,5,87,0,0,491,65,
        1,0,0,0,492,493,5,16,0,0,493,497,3,54,27,0,494,497,3,70,35,0,495,
        497,3,68,34,0,496,492,1,0,0,0,496,494,1,0,0,0,496,495,1,0,0,0,497,
        67,1,0,0,0,498,499,5,24,0,0,499,500,3,102,51,0,500,501,5,25,0,0,
        501,502,5,26,0,0,502,503,5,22,0,0,503,504,5,10,0,0,504,505,3,102,
        51,0,505,506,5,23,0,0,506,507,5,19,0,0,507,508,3,102,51,0,508,509,
        5,85,0,0,509,510,3,102,51,0,510,511,5,83,0,0,511,69,1,0,0,0,512,
        513,5,14,0,0,513,514,3,72,36,0,514,515,5,15,0,0,515,516,3,76,38,
        0,516,517,5,83,0,0,517,71,1,0,0,0,518,519,3,102,51,0,519,520,5,85,
        0,0,520,521,3,74,37,0,521,73,1,0,0,0,522,534,3,102,51,0,523,534,
        5,51,0,0,524,534,5,41,0,0,525,534,5,42,0,0,526,534,5,48,0,0,527,
        534,5,49,0,0,528,534,5,50,0,0,529,534,5,52,0,0,530,534,5,53,0,0,
        531,534,5,54,0,0,532,534,5,55,0,0,533,522,1,0,0,0,533,523,1,0,0,
        0,533,524,1,0,0,0,533,525,1,0,0,0,533,526,1,0,0,0,533,527,1,0,0,
        0,533,528,1,0,0,0,533,529,1,0,0,0,533,530,1,0,0,0,533,531,1,0,0,
        0,533,532,1,0,0,0,534,75,1,0,0,0,535,536,5,18,0,0,536,537,3,102,
        51,0,537,538,5,85,0,0,538,539,3,78,39,0,539,555,1,0,0,0,540,541,
        5,19,0,0,541,542,3,102,51,0,542,543,5,85,0,0,543,544,3,102,51,0,
        544,545,5,85,0,0,545,546,3,80,40,0,546,555,1,0,0,0,547,548,5,5,0,
        0,548,549,3,102,51,0,549,550,5,85,0,0,550,552,3,102,51,0,551,553,
        3,82,41,0,552,551,1,0,0,0,552,553,1,0,0,0,553,555,1,0,0,0,554,535,
        1,0,0,0,554,540,1,0,0,0,554,547,1,0,0,0,555,77,1,0,0,0,556,557,7,
        2,0,0,557,79,1,0,0,0,558,559,7,3,0,0,559,81,1,0,0,0,560,561,5,21,
        0,0,561,565,5,86,0,0,562,564,3,84,42,0,563,562,1,0,0,0,564,567,1,
        0,0,0,565,563,1,0,0,0,565,566,1,0,0,0,566,568,1,0,0,0,567,565,1,
        0,0,0,568,569,5,87,0,0,569,83,1,0,0,0,570,571,3,102,51,0,571,572,
        5,15,0,0,572,573,5,18,0,0,573,580,3,102,51,0,574,575,5,23,0,0,575,
        576,5,19,0,0,576,577,3,102,51,0,577,578,5,85,0,0,578,579,3,102,51,
        0,579,581,1,0,0,0,580,574,1,0,0,0,580,581,1,0,0,0,581,582,1,0,0,
        0,582,583,5,83,0,0,583,613,1,0,0,0,584,585,3,102,51,0,585,586,5,
        15,0,0,586,587,5,19,0,0,587,588,3,102,51,0,588,589,5,85,0,0,589,
        596,3,102,51,0,590,591,5,23,0,0,591,592,5,19,0,0,592,593,3,102,51,
        0,593,594,5,85,0,0,594,595,3,102,51,0,595,597,1,0,0,0,596,590,1,
        0,0,0,596,597,1,0,0,0,597,598,1,0,0,0,598,599,5,83,0,0,599,613,1,
        0,0,0,600,601,3,102,51,0,601,602,5,15,0,0,602,603,5,3,0,0,603,604,
        3,102,51,0,604,605,5,83,0,0,605,613,1,0,0,0,606,607,3,102,51,0,607,
        608,5,15,0,0,608,609,5,10,0,0,609,610,3,102,51,0,610,611,5,83,0,
        0,611,613,1,0,0,0,612,570,1,0,0,0,612,584,1,0,0,0,612,600,1,0,0,
        0,612,606,1,0,0,0,613,85,1,0,0,0,614,615,5,10,0,0,615,616,3,102,
        51,0,616,617,5,15,0,0,617,618,3,102,51,0,618,619,5,85,0,0,619,621,
        3,102,51,0,620,622,3,82,41,0,621,620,1,0,0,0,621,622,1,0,0,0,622,
        623,1,0,0,0,623,624,5,83,0,0,624,87,1,0,0,0,625,651,3,90,45,0,626,
        651,5,63,0,0,627,651,5,64,0,0,628,629,5,65,0,0,629,651,3,104,52,
        0,630,631,5,66,0,0,631,632,5,92,0,0,632,633,3,102,51,0,633,634,5,
        93,0,0,634,651,1,0,0,0,635,636,5,67,0,0,636,637,5,92,0,0,637,638,
        3,102,51,0,638,639,5,93,0,0,639,651,1,0,0,0,640,641,5,68,0,0,641,
        642,5,92,0,0,642,643,3,88,44,0,643,644,5,93,0,0,644,651,1,0,0,0,
        645,646,5,69,0,0,646,647,5,92,0,0,647,648,3,88,44,0,648,649,5,93,
        0,0,649,651,1,0,0,0,650,625,1,0,0,0,650,626,1,0,0,0,650,627,1,0,
        0,0,650,628,1,0,0,0,650,630,1,0,0,0,650,635,1,0,0,0,650,640,1,0,
        0,0,650,645,1,0,0,0,651,89,1,0,0,0,652,653,7,4,0,0,653,91,1,0,0,
        0,654,655,7,5,0,0,655,93,1,0,0,0,656,665,3,104,52,0,657,665,5,94,
        0,0,658,665,5,95,0,0,659,665,5,78,0,0,660,665,5,79,0,0,661,665,5,
        80,0,0,662,665,3,96,48,0,663,665,3,100,50,0,664,656,1,0,0,0,664,
        657,1,0,0,0,664,658,1,0,0,0,664,659,1,0,0,0,664,660,1,0,0,0,664,
        661,1,0,0,0,664,662,1,0,0,0,664,663,1,0,0,0,665,95,1,0,0,0,666,675,
        5,86,0,0,667,672,3,98,49,0,668,669,5,84,0,0,669,671,3,98,49,0,670,
        668,1,0,0,0,671,674,1,0,0,0,672,670,1,0,0,0,672,673,1,0,0,0,673,
        676,1,0,0,0,674,672,1,0,0,0,675,667,1,0,0,0,675,676,1,0,0,0,676,
        677,1,0,0,0,677,678,5,87,0,0,678,97,1,0,0,0,679,680,3,104,52,0,680,
        681,5,82,0,0,681,682,3,94,47,0,682,99,1,0,0,0,683,692,5,88,0,0,684,
        689,3,94,47,0,685,686,5,84,0,0,686,688,3,94,47,0,687,685,1,0,0,0,
        688,691,1,0,0,0,689,687,1,0,0,0,689,690,1,0,0,0,690,693,1,0,0,0,
        691,689,1,0,0,0,692,684,1,0,0,0,692,693,1,0,0,0,693,694,1,0,0,0,
        694,695,5,89,0,0,695,101,1,0,0,0,696,697,7,6,0,0,697,103,1,0,0,0,
        698,699,5,97,0,0,699,105,1,0,0,0,43,121,132,140,155,173,200,224,
        234,240,269,275,288,296,309,314,327,340,355,358,365,373,413,421,
        433,447,457,475,487,496,533,552,554,565,580,596,612,621,650,664,
        672,675,689,692
    ];

    private static __ATN: antlr.ATN;
    public static get _ATN(): antlr.ATN {
        if (!QuixosCapabilityParser.__ATN) {
            QuixosCapabilityParser.__ATN = new antlr.ATNDeserializer().deserialize(QuixosCapabilityParser._serializedATN);
        }

        return QuixosCapabilityParser.__ATN;
    }


    private static readonly vocabulary = new antlr.Vocabulary(QuixosCapabilityParser.literalNames, QuixosCapabilityParser.symbolicNames, []);

    public override get vocabulary(): antlr.Vocabulary {
        return QuixosCapabilityParser.vocabulary;
    }

    private static readonly decisionsToDFA = QuixosCapabilityParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
}

export class DocumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public workspaceDecl(): WorkspaceDeclContext {
        return this.getRuleContext(0, WorkspaceDeclContext)!;
    }
    public EOF(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EOF, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_document;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitDocument) {
            return visitor.visitDocument(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class WorkspaceDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public WORKSPACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.WORKSPACE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public REVISION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
    }
    public COMMIT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COMMIT, 0)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public workspaceItem(): WorkspaceItemContext[];
    public workspaceItem(i: number): WorkspaceItemContext | null;
    public workspaceItem(i?: number): WorkspaceItemContext[] | WorkspaceItemContext | null {
        if (i === undefined) {
            return this.getRuleContexts(WorkspaceItemContext);
        }

        return this.getRuleContext(i, WorkspaceItemContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_workspaceDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitWorkspaceDecl) {
            return visitor.visitWorkspaceDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class WorkspaceItemContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public atomDecl(): AtomDeclContext | null {
        return this.getRuleContext(0, AtomDeclContext);
    }
    public interfaceDecl(): InterfaceDeclContext | null {
        return this.getRuleContext(0, InterfaceDeclContext);
    }
    public packageDecl(): PackageDeclContext | null {
        return this.getRuleContext(0, PackageDeclContext);
    }
    public sharedAttachmentDecl(): SharedAttachmentDeclContext | null {
        return this.getRuleContext(0, SharedAttachmentDeclContext);
    }
    public conformanceDecl(): ConformanceDeclContext | null {
        return this.getRuleContext(0, ConformanceDeclContext);
    }
    public constructorBindingDecl(): ConstructorBindingDeclContext | null {
        return this.getRuleContext(0, ConstructorBindingDeclContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_workspaceItem;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitWorkspaceItem) {
            return visitor.visitWorkspaceItem(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class AtomDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ATOM(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ATOM, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public DOC(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DOC, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_atomDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitAtomDecl) {
            return visitor.visitAtomDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class InterfaceDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public INTERFACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public REVISION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
    }
    public sourceBlock(): SourceBlockContext {
        return this.getRuleContext(0, SourceBlockContext)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public interfaceMember(): InterfaceMemberContext[];
    public interfaceMember(i: number): InterfaceMemberContext | null;
    public interfaceMember(i?: number): InterfaceMemberContext[] | InterfaceMemberContext | null {
        if (i === undefined) {
            return this.getRuleContexts(InterfaceMemberContext);
        }

        return this.getRuleContext(i, InterfaceMemberContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_interfaceDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitInterfaceDecl) {
            return visitor.visitInterfaceDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class SourceBlockContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public SOURCE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SOURCE, 0)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public REPOSITORY(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.REPOSITORY, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public SEMI(): antlr.TerminalNode[];
    public SEMI(i: number): antlr.TerminalNode | null;
    public SEMI(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.SEMI);
    	} else {
    		return this.getToken(QuixosCapabilityParser.SEMI, i);
    	}
    }
    public COMMIT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COMMIT, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_sourceBlock;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitSourceBlock) {
            return visitor.visitSourceBlock(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class InterfaceMemberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public valueMember(): ValueMemberContext | null {
        return this.getRuleContext(0, ValueMemberContext);
    }
    public relationshipMember(): RelationshipMemberContext | null {
        return this.getRuleContext(0, RelationshipMemberContext);
    }
    public operationMember(): OperationMemberContext | null {
        return this.getRuleContext(0, OperationMemberContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_interfaceMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitInterfaceMember) {
            return visitor.visitInterfaceMember(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class OperationMemberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public OPERATION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.OPERATION, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode[];
    public ID(i: number): antlr.TerminalNode | null;
    public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.ID);
    	} else {
    		return this.getToken(QuixosCapabilityParser.ID, i);
    	}
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext[];
    public valueType(i: number): ValueTypeContext | null;
    public valueType(i?: number): ValueTypeContext[] | ValueTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueTypeContext);
        }

        return this.getRuleContext(i, ValueTypeContext);
    }
    public ARROW(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ARROW, 0)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public CALL(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CALL, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_operationMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitOperationMember) {
            return visitor.visitOperationMember(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ValueMemberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public VALUE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.VALUE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext {
        return this.getRuleContext(0, ValueTypeContext)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public valueMemberOperation(): ValueMemberOperationContext[];
    public valueMemberOperation(i: number): ValueMemberOperationContext | null;
    public valueMemberOperation(i?: number): ValueMemberOperationContext[] | ValueMemberOperationContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueMemberOperationContext);
        }

        return this.getRuleContext(i, ValueMemberOperationContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_valueMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitValueMember) {
            return visitor.visitValueMember(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ValueMemberOperationContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public GET(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.GET, 0);
    }
    public ID(): antlr.TerminalNode[];
    public ID(i: number): antlr.TerminalNode | null;
    public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.ID);
    	} else {
    		return this.getToken(QuixosCapabilityParser.ID, i);
    	}
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public SET(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SET, 0);
    }
    public WATCH(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH, 0);
    }
    public START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.START, 0);
    }
    public STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STOP, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_valueMemberOperation;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitValueMemberOperation) {
            return visitor.visitValueMemberOperation(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class RelationshipMemberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public RELATION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RELATION, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public cardinality(): CardinalityContext {
        return this.getRuleContext(0, CardinalityContext)!;
    }
    public targetConstraint(): TargetConstraintContext {
        return this.getRuleContext(0, TargetConstraintContext)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public ORDERED(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ORDERED, 0);
    }
    public relationshipOperation(): RelationshipOperationContext[];
    public relationshipOperation(i: number): RelationshipOperationContext | null;
    public relationshipOperation(i?: number): RelationshipOperationContext[] | RelationshipOperationContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RelationshipOperationContext);
        }

        return this.getRuleContext(i, RelationshipOperationContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_relationshipMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitRelationshipMember) {
            return visitor.visitRelationshipMember(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class RelationshipOperationContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public RESOLVE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
    }
    public ID(): antlr.TerminalNode[];
    public ID(i: number): antlr.TerminalNode | null;
    public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.ID);
    	} else {
    		return this.getToken(QuixosCapabilityParser.ID, i);
    	}
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public CONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONNECT, 0);
    }
    public DISCONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
    }
    public WATCH(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH, 0);
    }
    public START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.START, 0);
    }
    public STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STOP, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_relationshipOperation;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitRelationshipOperation) {
            return visitor.visitRelationshipOperation(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class TargetConstraintContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ATOM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ATOM, 0);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public INTERFACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_targetConstraint;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitTargetConstraint) {
            return visitor.visitTargetConstraint(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PackageDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public PACKAGE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.PACKAGE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public REVISION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
    }
    public sourceBlock(): SourceBlockContext {
        return this.getRuleContext(0, SourceBlockContext)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public packageExport(): PackageExportContext[];
    public packageExport(i: number): PackageExportContext | null;
    public packageExport(i?: number): PackageExportContext[] | PackageExportContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PackageExportContext);
        }

        return this.getRuleContext(i, PackageExportContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_packageDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageDecl) {
            return visitor.visitPackageDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PackageExportContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public packageOperationExport(): PackageOperationExportContext | null {
        return this.getRuleContext(0, PackageOperationExportContext);
    }
    public packageFunctionExport(): PackageFunctionExportContext | null {
        return this.getRuleContext(0, PackageFunctionExportContext);
    }
    public packageConstructorExport(): PackageConstructorExportContext | null {
        return this.getRuleContext(0, PackageConstructorExportContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_packageExport;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageExport) {
            return visitor.visitPackageExport(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PackageOperationExportContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public OPERATION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.OPERATION, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext[];
    public valueType(i: number): ValueTypeContext | null;
    public valueType(i?: number): ValueTypeContext[] | ValueTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueTypeContext);
        }

        return this.getRuleContext(i, ValueTypeContext);
    }
    public ARROW(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ARROW, 0)!;
    }
    public MODE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.MODE, 0)!;
    }
    public operationMode(): OperationModeContext {
        return this.getRuleContext(0, OperationModeContext)!;
    }
    public RECEIVER(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RECEIVER, 0)!;
    }
    public receiverRequirement(): ReceiverRequirementContext {
        return this.getRuleContext(0, ReceiverRequirementContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public eventClause(): EventClauseContext | null {
        return this.getRuleContext(0, EventClauseContext);
    }
    public dependencyBlock(): DependencyBlockContext | null {
        return this.getRuleContext(0, DependencyBlockContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_packageOperationExport;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageOperationExport) {
            return visitor.visitPackageOperationExport(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PackageFunctionExportContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public FUNCTION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.FUNCTION, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext[];
    public valueType(i: number): ValueTypeContext | null;
    public valueType(i?: number): ValueTypeContext[] | ValueTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueTypeContext);
        }

        return this.getRuleContext(i, ValueTypeContext);
    }
    public ARROW(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ARROW, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public dependencyBlock(): DependencyBlockContext | null {
        return this.getRuleContext(0, DependencyBlockContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_packageFunctionExport;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageFunctionExport) {
            return visitor.visitPackageFunctionExport(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PackageConstructorExportContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public CONSTRUCTOR(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0)!;
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public CONSTRUCTS(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTS, 0)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext {
        return this.getRuleContext(0, ValueTypeContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public dependencyBlock(): DependencyBlockContext | null {
        return this.getRuleContext(0, DependencyBlockContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_packageConstructorExport;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageConstructorExport) {
            return visitor.visitPackageConstructorExport(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class EventClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EMITS(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EMITS, 0)!;
    }
    public valueType(): ValueTypeContext {
        return this.getRuleContext(0, ValueTypeContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_eventClause;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitEventClause) {
            return visitor.visitEventClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class OperationModeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public CALL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CALL, 0);
    }
    public WATCH_START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
    }
    public WATCH_STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
    }
    public SUBSCRIBE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SUBSCRIBE, 0);
    }
    public UNSUBSCRIBE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.UNSUBSCRIBE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_operationMode;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitOperationMode) {
            return visitor.visitOperationMode(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ReceiverRequirementContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ANY(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ANY, 0);
    }
    public ATOM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ATOM, 0);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public INTERFACES(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACES, 0);
    }
    public LBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACK, 0);
    }
    public RBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACK, 0);
    }
    public identifierList(): IdentifierListContext | null {
        return this.getRuleContext(0, IdentifierListContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_receiverRequirement;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitReceiverRequirement) {
            return visitor.visitReceiverRequirement(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class IdentifierListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.COMMA);
    	} else {
    		return this.getToken(QuixosCapabilityParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_identifierList;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitIdentifierList) {
            return visitor.visitIdentifierList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class DependencyBlockContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public REQUIRES(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.REQUIRES, 0)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public dependencyPort(): DependencyPortContext[];
    public dependencyPort(i: number): DependencyPortContext | null;
    public dependencyPort(i?: number): DependencyPortContext[] | DependencyPortContext | null {
        if (i === undefined) {
            return this.getRuleContexts(DependencyPortContext);
        }

        return this.getRuleContext(i, DependencyPortContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_dependencyBlock;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitDependencyBlock) {
            return visitor.visitDependencyBlock(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class DependencyPortContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 0);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext | null {
        return this.getRuleContext(0, ValueTypeContext);
    }
    public primitiveList(): PrimitiveListContext | null {
        return this.getRuleContext(0, PrimitiveListContext);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public EDGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDGE, 0);
    }
    public cardinality(): CardinalityContext | null {
        return this.getRuleContext(0, CardinalityContext);
    }
    public targetConstraint(): TargetConstraintContext | null {
        return this.getRuleContext(0, TargetConstraintContext);
    }
    public INTERFACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
    }
    public CONSTRUCTOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_dependencyPort;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitDependencyPort) {
            return visitor.visitDependencyPort(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PrimitiveListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LBRACK(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACK, 0)!;
    }
    public primitive(): PrimitiveContext[];
    public primitive(i: number): PrimitiveContext | null;
    public primitive(i?: number): PrimitiveContext[] | PrimitiveContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PrimitiveContext);
        }

        return this.getRuleContext(i, PrimitiveContext);
    }
    public RBRACK(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACK, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.COMMA);
    	} else {
    		return this.getToken(QuixosCapabilityParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_primitiveList;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPrimitiveList) {
            return visitor.visitPrimitiveList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PrimitiveContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public READ(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.READ, 0);
    }
    public WRITE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WRITE, 0);
    }
    public RESOLVE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
    }
    public CONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONNECT, 0);
    }
    public DISCONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
    }
    public WATCH_START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
    }
    public WATCH_STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_primitive;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPrimitive) {
            return visitor.visitPrimitive(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class SharedAttachmentDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public SHARED(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SHARED, 0)!;
    }
    public attachmentDecl(): AttachmentDeclContext {
        return this.getRuleContext(0, AttachmentDeclContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_sharedAttachmentDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitSharedAttachmentDecl) {
            return visitor.visitSharedAttachmentDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class AttachmentDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stateDecl(): StateDeclContext | null {
        return this.getRuleContext(0, StateDeclContext);
    }
    public edgeDecl(): EdgeDeclContext | null {
        return this.getRuleContext(0, EdgeDeclContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_attachmentDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitAttachmentDecl) {
            return visitor.visitAttachmentDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class StateDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public STATE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.STATE, 0)!;
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public ON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ON, 0)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public valueType(): ValueTypeContext {
        return this.getRuleContext(0, ValueTypeContext)!;
    }
    public POLICY(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.POLICY, 0)!;
    }
    public storagePolicy(): StoragePolicyContext {
        return this.getRuleContext(0, StoragePolicyContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public DEFAULT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DEFAULT, 0);
    }
    public jsonLiteral(): JsonLiteralContext | null {
        return this.getRuleContext(0, JsonLiteralContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_stateDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitStateDecl) {
            return visitor.visitStateDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class StoragePolicyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public OPTIMISTIC_REGISTER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OPTIMISTIC_REGISTER, 0);
    }
    public CRDT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CRDT, 0);
    }
    public LPAREN(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LPAREN, 0);
    }
    public valueType(): ValueTypeContext | null {
        return this.getRuleContext(0, ValueTypeContext);
    }
    public RPAREN(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RPAREN, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_storagePolicy;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitStoragePolicy) {
            return visitor.visitStoragePolicy(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class EdgeDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EDGE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EDGE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public edgeEndpoint(): EdgeEndpointContext[];
    public edgeEndpoint(i: number): EdgeEndpointContext | null;
    public edgeEndpoint(i?: number): EdgeEndpointContext[] | EdgeEndpointContext | null {
        if (i === undefined) {
            return this.getRuleContexts(EdgeEndpointContext);
        }

        return this.getRuleContext(i, EdgeEndpointContext);
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_edgeDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitEdgeDecl) {
            return visitor.visitEdgeDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class EdgeEndpointContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public targetConstraint(): TargetConstraintContext {
        return this.getRuleContext(0, TargetConstraintContext)!;
    }
    public PROJECTION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.PROJECTION, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public cardinality(): CardinalityContext {
        return this.getRuleContext(0, CardinalityContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public ORDERED(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ORDERED, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_edgeEndpoint;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitEdgeEndpoint) {
            return visitor.visitEdgeEndpoint(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ConformanceDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public CONFORM(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CONFORM, 0)!;
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public AS(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.AS, 0)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public conformanceItem(): ConformanceItemContext[];
    public conformanceItem(i: number): ConformanceItemContext | null;
    public conformanceItem(i?: number): ConformanceItemContext[] | ConformanceItemContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ConformanceItemContext);
        }

        return this.getRuleContext(i, ConformanceItemContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_conformanceDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitConformanceDecl) {
            return visitor.visitConformanceDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ConformanceItemContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public PRIVATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PRIVATE, 0);
    }
    public attachmentDecl(): AttachmentDeclContext | null {
        return this.getRuleContext(0, AttachmentDeclContext);
    }
    public operationBindingDecl(): OperationBindingDeclContext | null {
        return this.getRuleContext(0, OperationBindingDeclContext);
    }
    public relationshipMaterializationDecl(): RelationshipMaterializationDeclContext | null {
        return this.getRuleContext(0, RelationshipMaterializationDeclContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_conformanceItem;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitConformanceItem) {
            return visitor.visitConformanceItem(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class RelationshipMaterializationDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public MATERIALIZE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.MATERIALIZE, 0)!;
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public IF(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.IF, 0)!;
    }
    public ABSENT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ABSENT, 0)!;
    }
    public USING(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.USING, 0)!;
    }
    public CONSTRUCTOR(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0)!;
    }
    public VIA(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.VIA, 0)!;
    }
    public EDGE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EDGE, 0)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.DOT, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_relationshipMaterializationDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitRelationshipMaterializationDecl) {
            return visitor.visitRelationshipMaterializationDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class OperationBindingDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public BIND(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.BIND, 0)!;
    }
    public memberOperationRef(): MemberOperationRefContext {
        return this.getRuleContext(0, MemberOperationRefContext)!;
    }
    public TO(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.TO, 0)!;
    }
    public operationProvider(): OperationProviderContext {
        return this.getRuleContext(0, OperationProviderContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_operationBindingDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitOperationBindingDecl) {
            return visitor.visitOperationBindingDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class MemberOperationRefContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.DOT, 0)!;
    }
    public operationName(): OperationNameContext {
        return this.getRuleContext(0, OperationNameContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_memberOperationRef;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitMemberOperationRef) {
            return visitor.visitMemberOperationRef(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class OperationNameContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public CALL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CALL, 0);
    }
    public GET(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.GET, 0);
    }
    public SET(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SET, 0);
    }
    public RESOLVE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
    }
    public CONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONNECT, 0);
    }
    public DISCONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
    }
    public WATCH_START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
    }
    public WATCH_STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
    }
    public SUBSCRIBE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SUBSCRIBE, 0);
    }
    public UNSUBSCRIBE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.UNSUBSCRIBE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_operationName;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitOperationName) {
            return visitor.visitOperationName(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class OperationProviderContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 0);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.DOT);
    	} else {
    		return this.getToken(QuixosCapabilityParser.DOT, i);
    	}
    }
    public statePrimitive(): StatePrimitiveContext | null {
        return this.getRuleContext(0, StatePrimitiveContext);
    }
    public EDGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDGE, 0);
    }
    public edgePrimitive(): EdgePrimitiveContext | null {
        return this.getRuleContext(0, EdgePrimitiveContext);
    }
    public PACKAGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PACKAGE, 0);
    }
    public dependencyBindingBlock(): DependencyBindingBlockContext | null {
        return this.getRuleContext(0, DependencyBindingBlockContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_operationProvider;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitOperationProvider) {
            return visitor.visitOperationProvider(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class StatePrimitiveContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public READ(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.READ, 0);
    }
    public WRITE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WRITE, 0);
    }
    public WATCH_START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
    }
    public WATCH_STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_statePrimitive;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitStatePrimitive) {
            return visitor.visitStatePrimitive(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class EdgePrimitiveContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public RESOLVE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
    }
    public CONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONNECT, 0);
    }
    public DISCONNECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
    }
    public WATCH_START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
    }
    public WATCH_STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_edgePrimitive;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitEdgePrimitive) {
            return visitor.visitEdgePrimitive(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class DependencyBindingBlockContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public WITH(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.WITH, 0)!;
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public dependencyBinding(): DependencyBindingContext[];
    public dependencyBinding(i: number): DependencyBindingContext | null;
    public dependencyBinding(i?: number): DependencyBindingContext[] | DependencyBindingContext | null {
        if (i === undefined) {
            return this.getRuleContexts(DependencyBindingContext);
        }

        return this.getRuleContext(i, DependencyBindingContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_dependencyBindingBlock;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitDependencyBindingBlock) {
            return visitor.visitDependencyBindingBlock(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class DependencyBindingContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public TO(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.TO, 0)!;
    }
    public STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 0);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public VIA(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.VIA, 0);
    }
    public EDGE(): antlr.TerminalNode[];
    public EDGE(i: number): antlr.TerminalNode | null;
    public EDGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.EDGE);
    	} else {
    		return this.getToken(QuixosCapabilityParser.EDGE, i);
    	}
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.DOT);
    	} else {
    		return this.getToken(QuixosCapabilityParser.DOT, i);
    	}
    }
    public INTERFACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
    }
    public CONSTRUCTOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_dependencyBinding;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitDependencyBinding) {
            return visitor.visitDependencyBinding(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ConstructorBindingDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public CONSTRUCTOR(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0)!;
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public TO(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.TO, 0)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.DOT, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public dependencyBindingBlock(): DependencyBindingBlockContext | null {
        return this.getRuleContext(0, DependencyBindingBlockContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_constructorBindingDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitConstructorBindingDecl) {
            return visitor.visitConstructorBindingDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ValueTypeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public scalarType(): ScalarTypeContext | null {
        return this.getRuleContext(0, ScalarTypeContext);
    }
    public UNIT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.UNIT, 0);
    }
    public WATCH_HANDLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH_HANDLE, 0);
    }
    public MESSAGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.MESSAGE, 0);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public ATOM_REF(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ATOM_REF, 0);
    }
    public LT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LT, 0);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public GT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.GT, 0);
    }
    public INTERFACE_REF(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE_REF, 0);
    }
    public OPTIONAL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OPTIONAL, 0);
    }
    public valueType(): ValueTypeContext | null {
        return this.getRuleContext(0, ValueTypeContext);
    }
    public LIST(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LIST, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_valueType;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitValueType) {
            return visitor.visitValueType(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ScalarTypeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public BOOL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.BOOL, 0);
    }
    public BYTES(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.BYTES, 0);
    }
    public DOUBLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DOUBLE, 0);
    }
    public INT32(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INT32, 0);
    }
    public INT64(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INT64, 0);
    }
    public STRING(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STRING, 0);
    }
    public UINT32(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.UINT32, 0);
    }
    public UINT64(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.UINT64, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_scalarType;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitScalarType) {
            return visitor.visitScalarType(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class CardinalityContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public OPTIONAL_ONE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OPTIONAL_ONE, 0);
    }
    public EXACTLY_ONE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EXACTLY_ONE, 0);
    }
    public MANY(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.MANY, 0);
    }
    public MANY_UNIQUE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.MANY_UNIQUE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_cardinality;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitCardinality) {
            return visitor.visitCardinality(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class JsonLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public INTEGER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTEGER, 0);
    }
    public JSON_NUMBER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.JSON_NUMBER, 0);
    }
    public TRUE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.TRUE, 0);
    }
    public FALSE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FALSE, 0);
    }
    public NULL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.NULL, 0);
    }
    public jsonObject(): JsonObjectContext | null {
        return this.getRuleContext(0, JsonObjectContext);
    }
    public jsonArray(): JsonArrayContext | null {
        return this.getRuleContext(0, JsonArrayContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_jsonLiteral;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitJsonLiteral) {
            return visitor.visitJsonLiteral(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class JsonObjectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public jsonMember(): JsonMemberContext[];
    public jsonMember(i: number): JsonMemberContext | null;
    public jsonMember(i?: number): JsonMemberContext[] | JsonMemberContext | null {
        if (i === undefined) {
            return this.getRuleContexts(JsonMemberContext);
        }

        return this.getRuleContext(i, JsonMemberContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.COMMA);
    	} else {
    		return this.getToken(QuixosCapabilityParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_jsonObject;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitJsonObject) {
            return visitor.visitJsonObject(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class JsonMemberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.COLON, 0)!;
    }
    public jsonLiteral(): JsonLiteralContext {
        return this.getRuleContext(0, JsonLiteralContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_jsonMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitJsonMember) {
            return visitor.visitJsonMember(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class JsonArrayContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LBRACK(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACK, 0)!;
    }
    public RBRACK(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACK, 0)!;
    }
    public jsonLiteral(): JsonLiteralContext[];
    public jsonLiteral(i: number): JsonLiteralContext | null;
    public jsonLiteral(i?: number): JsonLiteralContext[] | JsonLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(JsonLiteralContext);
        }

        return this.getRuleContext(i, JsonLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.COMMA);
    	} else {
    		return this.getToken(QuixosCapabilityParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_jsonArray;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitJsonArray) {
            return visitor.visitJsonArray(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class IdentifierContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public IDENTIFIER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.IDENTIFIER, 0);
    }
    public SOURCE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SOURCE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_identifier;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitIdentifier) {
            return visitor.visitIdentifier(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class StringLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public STRING_LITERAL(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.STRING_LITERAL, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_stringLiteral;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitStringLiteral) {
            return visitor.visitStringLiteral(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}