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 EDIT = 1;
    public static readonly MODULE = 2;
    public static readonly CONTRACT = 3;
    public static readonly PRESENTATION = 4;
    public static readonly SUBJECT = 5;
    public static readonly FOR = 6;
    public static readonly CREATION = 7;
    public static readonly INITIALIZE = 8;
    public static readonly WORKSPACE = 9;
    public static readonly EXECUTION = 10;
    public static readonly SNAPSHOT = 11;
    public static readonly TRANSACTION = 12;
    public static readonly REMOTE = 13;
    public static readonly TARGETS = 14;
    public static readonly PORTABLE = 15;
    public static readonly REPLICA = 16;
    public static readonly LOCAL = 17;
    public static readonly FROM = 18;
    public static readonly RESULT_BYTES = 19;
    public static readonly RPC_CALLS = 20;
    public static readonly DEADLINE_MS = 21;
    public static readonly QUERY = 22;
    public static readonly REFLECTION = 23;
    public static readonly SPECIALIZE = 24;
    public static readonly ROOT = 25;
    public static readonly DOCUMENT = 26;
    public static readonly FRAGMENTS = 27;
    public static readonly VIEW = 28;
    public static readonly MAX = 29;
    public static readonly ALLOW = 30;
    public static readonly POLL = 31;
    public static readonly QUERYABLE = 32;
    public static readonly RPC = 33;
    public static readonly QUERY_REASON = 34;
    public static readonly TYPE = 35;
    public static readonly OBJECT = 36;
    public static readonly STORABLE = 37;
    public static readonly IMPLEMENTS = 38;
    public static readonly REF = 39;
    public static readonly FRAGMENT = 40;
    public static readonly IMPORT = 41;
    public static readonly EXTERNAL = 42;
    public static readonly ATOM = 43;
    public static readonly INTERFACE = 44;
    public static readonly INTERFACES = 45;
    public static readonly PACKAGE = 46;
    public static readonly VALUE = 47;
    public static readonly RELATION = 48;
    public static readonly OPERATION = 49;
    public static readonly FUNCTION = 50;
    public static readonly CONSTRUCTOR = 51;
    public static readonly CONSTRUCTS = 52;
    public static readonly INPUT = 53;
    public static readonly CONFORM = 54;
    public static readonly AS = 55;
    public static readonly BIND = 56;
    public static readonly STATIC = 57;
    public static readonly TO = 58;
    public static readonly PRIVATE = 59;
    public static readonly SHARED = 60;
    public static readonly STATE = 61;
    public static readonly EDGE = 62;
    public static readonly PROJECTION = 63;
    public static readonly WITH = 64;
    public static readonly USING = 65;
    public static readonly ACCEPT = 66;
    public static readonly VIA = 67;
    public static readonly MATERIALIZE = 68;
    public static readonly IF = 69;
    public static readonly ABSENT = 70;
    public static readonly ON = 71;
    public static readonly POLICY = 72;
    public static readonly DEFAULT = 73;
    public static readonly SOURCE = 74;
    public static readonly REPOSITORY = 75;
    public static readonly COMMIT = 76;
    public static readonly REVISION = 77;
    public static readonly SEMANTIC_MAJOR = 78;
    public static readonly ON_DELETE = 79;
    public static readonly LIFECYCLE = 80;
    public static readonly RETAIN_OTHER = 81;
    public static readonly KEYED = 82;
    public static readonly PUBLIC_TRAVERSAL = 83;
    public static readonly ID = 84;
    public static readonly DOC = 85;
    public static readonly MODE = 86;
    public static readonly EMITS = 87;
    public static readonly RECEIVER = 88;
    public static readonly REQUIRES = 89;
    public static readonly ANY = 90;
    public static readonly GET = 91;
    public static readonly SET = 92;
    public static readonly WATCH = 93;
    public static readonly START = 94;
    public static readonly STOP = 95;
    public static readonly READ = 96;
    public static readonly WRITE = 97;
    public static readonly RESOLVE = 98;
    public static readonly CONNECT = 99;
    public static readonly DISCONNECT = 100;
    public static readonly CALL = 101;
    public static readonly WATCH_START = 102;
    public static readonly WATCH_STOP = 103;
    public static readonly SUBSCRIBE = 104;
    public static readonly UNSUBSCRIBE = 105;
    public static readonly REGISTER = 106;
    public static readonly CRDT = 107;
    public static readonly OPTIONAL_ONE = 108;
    public static readonly EXACTLY_ONE = 109;
    public static readonly MANY_UNIQUE = 110;
    public static readonly MANY = 111;
    public static readonly ORDERED = 112;
    public static readonly UNIT = 113;
    public static readonly WATCH_HANDLE = 114;
    public static readonly MESSAGE = 115;
    public static readonly ATOM_REF = 116;
    public static readonly INTERFACE_REF = 117;
    public static readonly OPTIONAL = 118;
    public static readonly LIST = 119;
    public static readonly RECORD = 120;
    public static readonly BOOL = 121;
    public static readonly BYTES = 122;
    public static readonly DOUBLE = 123;
    public static readonly INT32 = 124;
    public static readonly INT64 = 125;
    public static readonly STRING = 126;
    public static readonly UINT32 = 127;
    public static readonly UINT64 = 128;
    public static readonly TRUE = 129;
    public static readonly FALSE = 130;
    public static readonly NULL = 131;
    public static readonly ARROW = 132;
    public static readonly COLON = 133;
    public static readonly SEMI = 134;
    public static readonly COMMA = 135;
    public static readonly DOT = 136;
    public static readonly LBRACE = 137;
    public static readonly RBRACE = 138;
    public static readonly LBRACK = 139;
    public static readonly RBRACK = 140;
    public static readonly LPAREN = 141;
    public static readonly RPAREN = 142;
    public static readonly LT = 143;
    public static readonly GT = 144;
    public static readonly AMP = 145;
    public static readonly EQUAL = 146;
    public static readonly INTEGER = 147;
    public static readonly JSON_NUMBER = 148;
    public static readonly IDENTIFIER = 149;
    public static readonly STRING_LITERAL = 150;
    public static readonly LINE_COMMENT = 151;
    public static readonly BLOCK_COMMENT = 152;
    public static readonly WS = 153;
    public static readonly RULE_document = 0;
    public static readonly RULE_fragmentDecl = 1;
    public static readonly RULE_sourceImportDecl = 2;
    public static readonly RULE_workspaceDecl = 3;
    public static readonly RULE_workspaceItem = 4;
    public static readonly RULE_resourceImportDecl = 5;
    public static readonly RULE_externalAtomDecl = 6;
    public static readonly RULE_externalInterfaceDecl = 7;
    public static readonly RULE_resourcePreamble = 8;
    public static readonly RULE_atomDecl = 9;
    public static readonly RULE_interfaceResourceDecl = 10;
    public static readonly RULE_typeParameters = 11;
    public static readonly RULE_typeParameter = 12;
    public static readonly RULE_interfaceType = 13;
    public static readonly RULE_typeArguments = 14;
    public static readonly RULE_typeArgument = 15;
    public static readonly RULE_typeAliasDecl = 16;
    public static readonly RULE_interfaceMember = 17;
    public static readonly RULE_moduleMember = 18;
    public static readonly RULE_operationMember = 19;
    public static readonly RULE_valueMember = 20;
    public static readonly RULE_valueMemberOperation = 21;
    public static readonly RULE_relationshipMember = 22;
    public static readonly RULE_queryReadContract = 23;
    public static readonly RULE_relationshipOperation = 24;
    public static readonly RULE_targetConstraint = 25;
    public static readonly RULE_packageResourceDecl = 26;
    public static readonly RULE_packageExport = 27;
    public static readonly RULE_moduleExport = 28;
    public static readonly RULE_presentationDecl = 29;
    public static readonly RULE_packageQuery = 30;
    public static readonly RULE_packageQuerySpecialization = 31;
    public static readonly RULE_queryClause = 32;
    public static readonly RULE_fragmentVariable = 33;
    public static readonly RULE_packageOperationExport = 34;
    public static readonly RULE_packageFunctionExport = 35;
    public static readonly RULE_acceptanceClause = 36;
    public static readonly RULE_executionClause = 37;
    public static readonly RULE_selectedOperations = 38;
    public static readonly RULE_packageConstructorExport = 39;
    public static readonly RULE_eventClause = 40;
    public static readonly RULE_operationMode = 41;
    public static readonly RULE_receiverRequirement = 42;
    public static readonly RULE_identifierList = 43;
    public static readonly RULE_dependencyBlock = 44;
    public static readonly RULE_dependencyPort = 45;
    public static readonly RULE_primitiveList = 46;
    public static readonly RULE_primitive = 47;
    public static readonly RULE_sharedAttachmentDecl = 48;
    public static readonly RULE_attachmentDecl = 49;
    public static readonly RULE_stateDecl = 50;
    public static readonly RULE_storagePolicy = 51;
    public static readonly RULE_edgeDecl = 52;
    public static readonly RULE_edgeEndpoint = 53;
    public static readonly RULE_conformanceDecl = 54;
    public static readonly RULE_conformanceSourceArguments = 55;
    public static readonly RULE_conformanceItem = 56;
    public static readonly RULE_moduleBindingDecl = 57;
    public static readonly RULE_initializationDecl = 58;
    public static readonly RULE_initializationField = 59;
    public static readonly RULE_creationOwnerMapping = 60;
    public static readonly RULE_stateFieldBindingDecl = 61;
    public static readonly RULE_relationshipMaterializationDecl = 62;
    public static readonly RULE_operationBindingDecl = 63;
    public static readonly RULE_memberOperationRef = 64;
    public static readonly RULE_operationName = 65;
    public static readonly RULE_operationProvider = 66;
    public static readonly RULE_acceptanceBinding = 67;
    public static readonly RULE_statePrimitive = 68;
    public static readonly RULE_edgePrimitive = 69;
    public static readonly RULE_dependencyBindingBlock = 70;
    public static readonly RULE_dependencyBinding = 71;
    public static readonly RULE_constructorBindingDecl = 72;
    public static readonly RULE_valueType = 73;
    public static readonly RULE_recordField = 74;
    public static readonly RULE_scalarType = 75;
    public static readonly RULE_cardinality = 76;
    public static readonly RULE_jsonLiteral = 77;
    public static readonly RULE_jsonObject = 78;
    public static readonly RULE_jsonMember = 79;
    public static readonly RULE_jsonArray = 80;
    public static readonly RULE_identifier = 81;
    public static readonly RULE_stringLiteral = 82;

    public static readonly literalNames = [
        null, "'edit'", "'module'", "'contract'", "'presentation'", "'subject'", 
        "'for'", "'creation'", "'initialize'", "'workspace'", "'execution'", 
        "'snapshot'", "'transaction'", "'remote'", "'targets'", "'portable'", 
        "'replica'", "'local'", "'from'", "'result-bytes'", "'rpc-calls'", 
        "'deadline-ms'", "'query'", "'reflection'", "'specialize'", "'root'", 
        "'document'", "'fragments'", "'view'", "'max'", "'allow'", "'poll'", 
        "'queryable'", "'rpc'", "'query-reason'", "'type'", "'object'", 
        "'storable'", "'implements'", "'ref'", "'fragment'", "'import'", 
        "'external'", "'atom'", "'interface'", "'interfaces'", "'package'", 
        "'value'", "'relation'", "'operation'", "'function'", "'constructor'", 
        "'constructs'", "'input'", "'conform'", "'as'", "'bind'", "'static'", 
        "'to'", "'private'", "'shared'", "'state'", "'edge'", "'projection'", 
        "'with'", "'using'", "'accept'", "'via'", "'materialize'", "'if'", 
        "'absent'", "'on'", "'policy'", "'default'", "'source'", "'repository'", 
        "'commit'", "'revision'", "'semantic-major'", "'on-delete'", "'lifecycle'", 
        "'retain-other'", "'keyed'", "'public-traversal'", "'id'", "'doc'", 
        "'mode'", "'emits'", "'receiver'", "'requires'", "'any'", "'get'", 
        "'set'", "'watch'", "'start'", "'stop'", "'read'", "'write'", "'resolve'", 
        "'connect'", "'disconnect'", "'call'", "'watch-start'", "'watch-stop'", 
        "'subscribe'", "'unsubscribe'", "'register'", "'crdt'", "'optional-one'", 
        "'exactly-one'", "'many-unique'", "'many'", "'ordered'", "'unit'", 
        "'watch-handle'", "'message'", "'atom-ref'", "'interface-ref'", 
        "'optional'", "'list'", "'record'", "'bool'", "'bytes'", "'double'", 
        "'int32'", "'int64'", "'string'", "'uint32'", "'uint64'", "'true'", 
        "'false'", "'null'", "'->'", "':'", "';'", "','", "'.'", "'{'", 
        "'}'", "'['", "']'", "'('", "')'", "'<'", "'>'", "'&'", "'='"
    ];

    public static readonly symbolicNames = [
        null, "EDIT", "MODULE", "CONTRACT", "PRESENTATION", "SUBJECT", "FOR", 
        "CREATION", "INITIALIZE", "WORKSPACE", "EXECUTION", "SNAPSHOT", 
        "TRANSACTION", "REMOTE", "TARGETS", "PORTABLE", "REPLICA", "LOCAL", 
        "FROM", "RESULT_BYTES", "RPC_CALLS", "DEADLINE_MS", "QUERY", "REFLECTION", 
        "SPECIALIZE", "ROOT", "DOCUMENT", "FRAGMENTS", "VIEW", "MAX", "ALLOW", 
        "POLL", "QUERYABLE", "RPC", "QUERY_REASON", "TYPE", "OBJECT", "STORABLE", 
        "IMPLEMENTS", "REF", "FRAGMENT", "IMPORT", "EXTERNAL", "ATOM", "INTERFACE", 
        "INTERFACES", "PACKAGE", "VALUE", "RELATION", "OPERATION", "FUNCTION", 
        "CONSTRUCTOR", "CONSTRUCTS", "INPUT", "CONFORM", "AS", "BIND", "STATIC", 
        "TO", "PRIVATE", "SHARED", "STATE", "EDGE", "PROJECTION", "WITH", 
        "USING", "ACCEPT", "VIA", "MATERIALIZE", "IF", "ABSENT", "ON", "POLICY", 
        "DEFAULT", "SOURCE", "REPOSITORY", "COMMIT", "REVISION", "SEMANTIC_MAJOR", 
        "ON_DELETE", "LIFECYCLE", "RETAIN_OTHER", "KEYED", "PUBLIC_TRAVERSAL", 
        "ID", "DOC", "MODE", "EMITS", "RECEIVER", "REQUIRES", "ANY", "GET", 
        "SET", "WATCH", "START", "STOP", "READ", "WRITE", "RESOLVE", "CONNECT", 
        "DISCONNECT", "CALL", "WATCH_START", "WATCH_STOP", "SUBSCRIBE", 
        "UNSUBSCRIBE", "REGISTER", "CRDT", "OPTIONAL_ONE", "EXACTLY_ONE", 
        "MANY_UNIQUE", "MANY", "ORDERED", "UNIT", "WATCH_HANDLE", "MESSAGE", 
        "ATOM_REF", "INTERFACE_REF", "OPTIONAL", "LIST", "RECORD", "BOOL", 
        "BYTES", "DOUBLE", "INT32", "INT64", "STRING", "UINT32", "UINT64", 
        "TRUE", "FALSE", "NULL", "ARROW", "COLON", "SEMI", "COMMA", "DOT", 
        "LBRACE", "RBRACE", "LBRACK", "RBRACK", "LPAREN", "RPAREN", "LT", 
        "GT", "AMP", "EQUAL", "INTEGER", "JSON_NUMBER", "IDENTIFIER", "STRING_LITERAL", 
        "LINE_COMMENT", "BLOCK_COMMENT", "WS"
    ];
    public static readonly ruleNames = [
        "document", "fragmentDecl", "sourceImportDecl", "workspaceDecl", 
        "workspaceItem", "resourceImportDecl", "externalAtomDecl", "externalInterfaceDecl", 
        "resourcePreamble", "atomDecl", "interfaceResourceDecl", "typeParameters", 
        "typeParameter", "interfaceType", "typeArguments", "typeArgument", 
        "typeAliasDecl", "interfaceMember", "moduleMember", "operationMember", 
        "valueMember", "valueMemberOperation", "relationshipMember", "queryReadContract", 
        "relationshipOperation", "targetConstraint", "packageResourceDecl", 
        "packageExport", "moduleExport", "presentationDecl", "packageQuery", 
        "packageQuerySpecialization", "queryClause", "fragmentVariable", 
        "packageOperationExport", "packageFunctionExport", "acceptanceClause", 
        "executionClause", "selectedOperations", "packageConstructorExport", 
        "eventClause", "operationMode", "receiverRequirement", "identifierList", 
        "dependencyBlock", "dependencyPort", "primitiveList", "primitive", 
        "sharedAttachmentDecl", "attachmentDecl", "stateDecl", "storagePolicy", 
        "edgeDecl", "edgeEndpoint", "conformanceDecl", "conformanceSourceArguments", 
        "conformanceItem", "moduleBindingDecl", "initializationDecl", "initializationField", 
        "creationOwnerMapping", "stateFieldBindingDecl", "relationshipMaterializationDecl", 
        "operationBindingDecl", "memberOperationRef", "operationName", "operationProvider", 
        "acceptanceBinding", "statePrimitive", "edgePrimitive", "dependencyBindingBlock", 
        "dependencyBinding", "constructorBindingDecl", "valueType", "recordField", 
        "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.state = 178;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 0, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 166;
                this.workspaceDecl();
                this.state = 167;
                this.match(QuixosCapabilityParser.EOF);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 169;
                this.interfaceResourceDecl();
                this.state = 170;
                this.match(QuixosCapabilityParser.EOF);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 172;
                this.packageResourceDecl();
                this.state = 173;
                this.match(QuixosCapabilityParser.EOF);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 175;
                this.fragmentDecl();
                this.state = 176;
                this.match(QuixosCapabilityParser.EOF);
                }
                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 fragmentDecl(): FragmentDeclContext {
        let localContext = new FragmentDeclContext(this.context, this.state);
        this.enterRule(localContext, 2, QuixosCapabilityParser.RULE_fragmentDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 180;
            this.match(QuixosCapabilityParser.FRAGMENT);
            this.state = 181;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 185;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4 || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 34144577) !== 0)) {
                {
                {
                this.state = 182;
                this.workspaceItem();
                }
                }
                this.state = 187;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            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 sourceImportDecl(): SourceImportDeclContext {
        let localContext = new SourceImportDeclContext(this.context, this.state);
        this.enterRule(localContext, 4, QuixosCapabilityParser.RULE_sourceImportDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 190;
            this.match(QuixosCapabilityParser.IMPORT);
            this.state = 191;
            this.stringLiteral();
            this.state = 192;
            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 workspaceDecl(): WorkspaceDeclContext {
        let localContext = new WorkspaceDeclContext(this.context, this.state);
        this.enterRule(localContext, 6, QuixosCapabilityParser.RULE_workspaceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 194;
            this.match(QuixosCapabilityParser.WORKSPACE);
            this.state = 195;
            this.identifier();
            this.state = 196;
            this.match(QuixosCapabilityParser.ID);
            this.state = 197;
            this.stringLiteral();
            this.state = 198;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 199;
            this.stringLiteral();
            this.state = 200;
            this.match(QuixosCapabilityParser.COMMIT);
            this.state = 201;
            this.stringLiteral();
            this.state = 202;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 206;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4 || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 34144577) !== 0)) {
                {
                {
                this.state = 203;
                this.workspaceItem();
                }
                }
                this.state = 208;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 209;
            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, 8, QuixosCapabilityParser.RULE_workspaceItem);
        try {
            this.state = 219;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 211;
                this.sourceImportDecl();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 212;
                this.atomDecl();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 213;
                this.resourceImportDecl();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 214;
                this.sharedAttachmentDecl();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 215;
                this.conformanceDecl();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 216;
                this.constructorBindingDecl();
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 217;
                this.presentationDecl();
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 218;
                this.typeAliasDecl();
                }
                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 resourceImportDecl(): ResourceImportDeclContext {
        let localContext = new ResourceImportDeclContext(this.context, this.state);
        this.enterRule(localContext, 10, QuixosCapabilityParser.RULE_resourceImportDecl);
        try {
            this.state = 231;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 221;
                this.match(QuixosCapabilityParser.IMPORT);
                this.state = 222;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 223;
                this.identifier();
                this.state = 224;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 226;
                this.match(QuixosCapabilityParser.IMPORT);
                this.state = 227;
                this.match(QuixosCapabilityParser.PACKAGE);
                this.state = 228;
                this.identifier();
                this.state = 229;
                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 externalAtomDecl(): ExternalAtomDeclContext {
        let localContext = new ExternalAtomDeclContext(this.context, this.state);
        this.enterRule(localContext, 12, QuixosCapabilityParser.RULE_externalAtomDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 233;
            this.match(QuixosCapabilityParser.EXTERNAL);
            this.state = 234;
            this.match(QuixosCapabilityParser.ATOM);
            this.state = 235;
            this.identifier();
            this.state = 236;
            this.match(QuixosCapabilityParser.ID);
            this.state = 237;
            this.stringLiteral();
            this.state = 238;
            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 externalInterfaceDecl(): ExternalInterfaceDeclContext {
        let localContext = new ExternalInterfaceDeclContext(this.context, this.state);
        this.enterRule(localContext, 14, QuixosCapabilityParser.RULE_externalInterfaceDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 240;
            this.match(QuixosCapabilityParser.EXTERNAL);
            this.state = 241;
            this.match(QuixosCapabilityParser.INTERFACE);
            this.state = 242;
            this.identifier();
            this.state = 243;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 244;
            this.stringLiteral();
            this.state = 245;
            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 resourcePreamble(): ResourcePreambleContext {
        let localContext = new ResourcePreambleContext(this.context, this.state);
        this.enterRule(localContext, 16, QuixosCapabilityParser.RULE_resourcePreamble);
        try {
            this.state = 251;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 247;
                this.resourceImportDecl();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 248;
                this.externalAtomDecl();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 249;
                this.externalInterfaceDecl();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 250;
                this.typeAliasDecl();
                }
                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 atomDecl(): AtomDeclContext {
        let localContext = new AtomDeclContext(this.context, this.state);
        this.enterRule(localContext, 18, QuixosCapabilityParser.RULE_atomDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 253;
            this.match(QuixosCapabilityParser.ATOM);
            this.state = 254;
            this.identifier();
            this.state = 255;
            this.match(QuixosCapabilityParser.ID);
            this.state = 256;
            this.stringLiteral();
            this.state = 259;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 85) {
                {
                this.state = 257;
                this.match(QuixosCapabilityParser.DOC);
                this.state = 258;
                this.stringLiteral();
                }
            }

            this.state = 261;
            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 interfaceResourceDecl(): InterfaceResourceDeclContext {
        let localContext = new InterfaceResourceDeclContext(this.context, this.state);
        this.enterRule(localContext, 20, QuixosCapabilityParser.RULE_interfaceResourceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 266;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 193) !== 0)) {
                {
                {
                this.state = 263;
                this.resourcePreamble();
                }
                }
                this.state = 268;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 269;
            this.match(QuixosCapabilityParser.INTERFACE);
            this.state = 270;
            this.identifier();
            this.state = 272;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 271;
                this.typeParameters();
                }
            }

            this.state = 274;
            this.match(QuixosCapabilityParser.ID);
            this.state = 275;
            this.stringLiteral();
            this.state = 276;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 277;
            this.stringLiteral();
            this.state = 287;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 89) {
                {
                this.state = 278;
                this.match(QuixosCapabilityParser.REQUIRES);
                this.state = 279;
                this.interfaceType();
                this.state = 284;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 135) {
                    {
                    {
                    this.state = 280;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 281;
                    this.interfaceType();
                    }
                    }
                    this.state = 286;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 289;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 293;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 2 || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 33783809) !== 0)) {
                {
                {
                this.state = 290;
                this.interfaceMember();
                }
                }
                this.state = 295;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 296;
            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 typeParameters(): TypeParametersContext {
        let localContext = new TypeParametersContext(this.context, this.state);
        this.enterRule(localContext, 22, QuixosCapabilityParser.RULE_typeParameters);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 298;
            this.match(QuixosCapabilityParser.LT);
            this.state = 299;
            this.typeParameter();
            this.state = 304;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 135) {
                {
                {
                this.state = 300;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 301;
                this.typeParameter();
                }
                }
                this.state = 306;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 307;
            this.match(QuixosCapabilityParser.GT);
            }
        }
        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 typeParameter(): TypeParameterContext {
        let localContext = new TypeParameterContext(this.context, this.state);
        this.enterRule(localContext, 24, QuixosCapabilityParser.RULE_typeParameter);
        let _la: number;
        try {
            this.state = 328;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 309;
                this.match(QuixosCapabilityParser.VALUE);
                this.state = 310;
                this.identifier();
                this.state = 313;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 133) {
                    {
                    this.state = 311;
                    this.match(QuixosCapabilityParser.COLON);
                    this.state = 312;
                    this.match(QuixosCapabilityParser.STORABLE);
                    }
                }

                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 315;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 316;
                this.identifier();
                this.state = 326;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 38) {
                    {
                    this.state = 317;
                    this.match(QuixosCapabilityParser.IMPLEMENTS);
                    this.state = 318;
                    this.interfaceType();
                    this.state = 323;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 145) {
                        {
                        {
                        this.state = 319;
                        this.match(QuixosCapabilityParser.AMP);
                        this.state = 320;
                        this.interfaceType();
                        }
                        }
                        this.state = 325;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                }

                }
                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 interfaceType(): InterfaceTypeContext {
        let localContext = new InterfaceTypeContext(this.context, this.state);
        this.enterRule(localContext, 26, QuixosCapabilityParser.RULE_interfaceType);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 330;
            this.identifier();
            this.state = 332;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 331;
                this.typeArguments();
                }
            }

            }
        }
        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 typeArguments(): TypeArgumentsContext {
        let localContext = new TypeArgumentsContext(this.context, this.state);
        this.enterRule(localContext, 28, QuixosCapabilityParser.RULE_typeArguments);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 334;
            this.match(QuixosCapabilityParser.LT);
            this.state = 335;
            this.typeArgument();
            this.state = 340;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 135) {
                {
                {
                this.state = 336;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 337;
                this.typeArgument();
                }
                }
                this.state = 342;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 343;
            this.match(QuixosCapabilityParser.GT);
            }
        }
        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 typeArgument(): TypeArgumentContext {
        let localContext = new TypeArgumentContext(this.context, this.state);
        this.enterRule(localContext, 30, QuixosCapabilityParser.RULE_typeArgument);
        try {
            this.state = 352;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 345;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 346;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 347;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 348;
                this.interfaceType();
                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 349;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 350;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.EDIT:
            case QuixosCapabilityParser.PRESENTATION:
            case QuixosCapabilityParser.SUBJECT:
            case QuixosCapabilityParser.FOR:
            case QuixosCapabilityParser.CREATION:
            case QuixosCapabilityParser.INITIALIZE:
            case QuixosCapabilityParser.EXECUTION:
            case QuixosCapabilityParser.SNAPSHOT:
            case QuixosCapabilityParser.TRANSACTION:
            case QuixosCapabilityParser.REMOTE:
            case QuixosCapabilityParser.TARGETS:
            case QuixosCapabilityParser.PORTABLE:
            case QuixosCapabilityParser.REPLICA:
            case QuixosCapabilityParser.LOCAL:
            case QuixosCapabilityParser.FROM:
            case QuixosCapabilityParser.RESULT_BYTES:
            case QuixosCapabilityParser.RPC_CALLS:
            case QuixosCapabilityParser.DEADLINE_MS:
            case QuixosCapabilityParser.QUERY:
            case QuixosCapabilityParser.REFLECTION:
            case QuixosCapabilityParser.SPECIALIZE:
            case QuixosCapabilityParser.ROOT:
            case QuixosCapabilityParser.DOCUMENT:
            case QuixosCapabilityParser.FRAGMENTS:
            case QuixosCapabilityParser.VIEW:
            case QuixosCapabilityParser.MAX:
            case QuixosCapabilityParser.ALLOW:
            case QuixosCapabilityParser.POLL:
            case QuixosCapabilityParser.QUERYABLE:
            case QuixosCapabilityParser.RPC:
            case QuixosCapabilityParser.REF:
            case QuixosCapabilityParser.FRAGMENT:
            case QuixosCapabilityParser.INTERFACES:
            case QuixosCapabilityParser.SOURCE:
            case QuixosCapabilityParser.START:
            case QuixosCapabilityParser.STOP:
            case QuixosCapabilityParser.REGISTER:
            case QuixosCapabilityParser.UNIT:
            case QuixosCapabilityParser.WATCH_HANDLE:
            case QuixosCapabilityParser.MESSAGE:
            case QuixosCapabilityParser.ATOM_REF:
            case QuixosCapabilityParser.INTERFACE_REF:
            case QuixosCapabilityParser.OPTIONAL:
            case QuixosCapabilityParser.LIST:
            case QuixosCapabilityParser.RECORD:
            case QuixosCapabilityParser.BOOL:
            case QuixosCapabilityParser.BYTES:
            case QuixosCapabilityParser.DOUBLE:
            case QuixosCapabilityParser.INT32:
            case QuixosCapabilityParser.INT64:
            case QuixosCapabilityParser.STRING:
            case QuixosCapabilityParser.UINT32:
            case QuixosCapabilityParser.UINT64:
            case QuixosCapabilityParser.IDENTIFIER:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 351;
                this.valueType();
                }
                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 typeAliasDecl(): TypeAliasDeclContext {
        let localContext = new TypeAliasDeclContext(this.context, this.state);
        this.enterRule(localContext, 32, QuixosCapabilityParser.RULE_typeAliasDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 354;
            this.match(QuixosCapabilityParser.TYPE);
            this.state = 355;
            this.identifier();
            this.state = 357;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 356;
                this.typeParameters();
                }
            }

            this.state = 359;
            this.match(QuixosCapabilityParser.EQUAL);
            this.state = 360;
            this.valueType();
            this.state = 361;
            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 interfaceMember(): InterfaceMemberContext {
        let localContext = new InterfaceMemberContext(this.context, this.state);
        this.enterRule(localContext, 34, QuixosCapabilityParser.RULE_interfaceMember);
        try {
            this.state = 367;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 21, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 363;
                this.valueMember();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 364;
                this.relationshipMember();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 365;
                this.operationMember();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 366;
                this.moduleMember();
                }
                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 moduleMember(): ModuleMemberContext {
        let localContext = new ModuleMemberContext(this.context, this.state);
        this.enterRule(localContext, 36, QuixosCapabilityParser.RULE_moduleMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 369;
            this.match(QuixosCapabilityParser.MODULE);
            this.state = 370;
            this.identifier();
            this.state = 371;
            this.match(QuixosCapabilityParser.ID);
            this.state = 372;
            this.stringLiteral();
            this.state = 373;
            this.match(QuixosCapabilityParser.CONTRACT);
            this.state = 374;
            this.stringLiteral();
            this.state = 377;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 5) {
                {
                this.state = 375;
                this.match(QuixosCapabilityParser.SUBJECT);
                this.state = 376;
                this.targetConstraint();
                }
            }

            this.state = 379;
            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 operationMember(): OperationMemberContext {
        let localContext = new OperationMemberContext(this.context, this.state);
        this.enterRule(localContext, 38, QuixosCapabilityParser.RULE_operationMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 382;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 57) {
                {
                this.state = 381;
                this.match(QuixosCapabilityParser.STATIC);
                }
            }

            this.state = 384;
            this.match(QuixosCapabilityParser.OPERATION);
            this.state = 385;
            this.identifier();
            this.state = 386;
            this.match(QuixosCapabilityParser.ID);
            this.state = 387;
            this.stringLiteral();
            this.state = 388;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 389;
            this.valueType();
            this.state = 390;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 391;
            this.valueType();
            this.state = 392;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 393;
            this.match(QuixosCapabilityParser.CALL);
            this.state = 394;
            this.match(QuixosCapabilityParser.ID);
            this.state = 395;
            this.stringLiteral();
            this.state = 397;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 10) {
                {
                this.state = 396;
                this.executionClause();
                }
            }

            this.state = 399;
            this.match(QuixosCapabilityParser.SEMI);
            this.state = 400;
            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, 40, QuixosCapabilityParser.RULE_valueMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 403;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 32) {
                {
                this.state = 402;
                this.queryReadContract();
                }
            }

            this.state = 405;
            this.match(QuixosCapabilityParser.VALUE);
            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.valueType();
            this.state = 411;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 415;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 1 || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 7) !== 0)) {
                {
                {
                this.state = 412;
                this.valueMemberOperation();
                }
                }
                this.state = 417;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 418;
            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, 42, QuixosCapabilityParser.RULE_valueMemberOperation);
        let _la: number;
        try {
            this.state = 453;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.GET:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 420;
                this.match(QuixosCapabilityParser.GET);
                this.state = 421;
                this.match(QuixosCapabilityParser.ID);
                this.state = 422;
                this.stringLiteral();
                this.state = 424;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10) {
                    {
                    this.state = 423;
                    this.executionClause();
                    }
                }

                this.state = 426;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.SET:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 428;
                this.match(QuixosCapabilityParser.SET);
                this.state = 429;
                this.match(QuixosCapabilityParser.ID);
                this.state = 430;
                this.stringLiteral();
                this.state = 432;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10) {
                    {
                    this.state = 431;
                    this.executionClause();
                    }
                }

                this.state = 434;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.EDIT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 436;
                this.match(QuixosCapabilityParser.EDIT);
                this.state = 437;
                this.match(QuixosCapabilityParser.ID);
                this.state = 438;
                this.stringLiteral();
                this.state = 440;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10) {
                    {
                    this.state = 439;
                    this.executionClause();
                    }
                }

                this.state = 442;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.WATCH:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 444;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 445;
                this.match(QuixosCapabilityParser.START);
                this.state = 446;
                this.match(QuixosCapabilityParser.ID);
                this.state = 447;
                this.stringLiteral();
                this.state = 448;
                this.match(QuixosCapabilityParser.STOP);
                this.state = 449;
                this.match(QuixosCapabilityParser.ID);
                this.state = 450;
                this.stringLiteral();
                this.state = 451;
                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, 44, QuixosCapabilityParser.RULE_relationshipMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 456;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 32) {
                {
                this.state = 455;
                this.queryReadContract();
                }
            }

            this.state = 458;
            this.match(QuixosCapabilityParser.RELATION);
            this.state = 459;
            this.identifier();
            this.state = 460;
            this.match(QuixosCapabilityParser.ID);
            this.state = 461;
            this.stringLiteral();
            this.state = 462;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 463;
            this.cardinality();
            this.state = 464;
            this.targetConstraint();
            this.state = 466;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 112) {
                {
                this.state = 465;
                this.match(QuixosCapabilityParser.ORDERED);
                }
            }

            this.state = 470;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 82) {
                {
                this.state = 468;
                this.match(QuixosCapabilityParser.KEYED);
                this.state = 469;
                this.stringLiteral();
                }
            }

            this.state = 472;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 476;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 93)) & ~0x1F) === 0 && ((1 << (_la - 93)) & 225) !== 0)) {
                {
                {
                this.state = 473;
                this.relationshipOperation();
                }
                }
                this.state = 478;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 479;
            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 queryReadContract(): QueryReadContractContext {
        let localContext = new QueryReadContractContext(this.context, this.state);
        this.enterRule(localContext, 46, QuixosCapabilityParser.RULE_queryReadContract);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 481;
            this.match(QuixosCapabilityParser.QUERYABLE);
            this.state = 483;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 15 || _la === 33) {
                {
                this.state = 482;
                _la = this.tokenStream.LA(1);
                if(!(_la === 15 || _la === 33)) {
                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 relationshipOperation(): RelationshipOperationContext {
        let localContext = new RelationshipOperationContext(this.context, this.state);
        this.enterRule(localContext, 48, QuixosCapabilityParser.RULE_relationshipOperation);
        let _la: number;
        try {
            this.state = 518;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.RESOLVE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 485;
                this.match(QuixosCapabilityParser.RESOLVE);
                this.state = 486;
                this.match(QuixosCapabilityParser.ID);
                this.state = 487;
                this.stringLiteral();
                this.state = 489;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10) {
                    {
                    this.state = 488;
                    this.executionClause();
                    }
                }

                this.state = 491;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CONNECT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 493;
                this.match(QuixosCapabilityParser.CONNECT);
                this.state = 494;
                this.match(QuixosCapabilityParser.ID);
                this.state = 495;
                this.stringLiteral();
                this.state = 497;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10) {
                    {
                    this.state = 496;
                    this.executionClause();
                    }
                }

                this.state = 499;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.DISCONNECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 501;
                this.match(QuixosCapabilityParser.DISCONNECT);
                this.state = 502;
                this.match(QuixosCapabilityParser.ID);
                this.state = 503;
                this.stringLiteral();
                this.state = 505;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10) {
                    {
                    this.state = 504;
                    this.executionClause();
                    }
                }

                this.state = 507;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.WATCH:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 509;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 510;
                this.match(QuixosCapabilityParser.START);
                this.state = 511;
                this.match(QuixosCapabilityParser.ID);
                this.state = 512;
                this.stringLiteral();
                this.state = 513;
                this.match(QuixosCapabilityParser.STOP);
                this.state = 514;
                this.match(QuixosCapabilityParser.ID);
                this.state = 515;
                this.stringLiteral();
                this.state = 516;
                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, 50, QuixosCapabilityParser.RULE_targetConstraint);
        let _la: number;
        try {
            this.state = 529;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 520;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 521;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 522;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 523;
                this.identifier();
                this.state = 525;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 524;
                    this.typeArguments();
                    }
                }

                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 527;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 528;
                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 packageResourceDecl(): PackageResourceDeclContext {
        let localContext = new PackageResourceDeclContext(this.context, this.state);
        this.enterRule(localContext, 52, QuixosCapabilityParser.RULE_packageResourceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 534;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 193) !== 0)) {
                {
                {
                this.state = 531;
                this.resourcePreamble();
                }
                }
                this.state = 536;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 537;
            this.match(QuixosCapabilityParser.PACKAGE);
            this.state = 538;
            this.identifier();
            this.state = 539;
            this.match(QuixosCapabilityParser.ID);
            this.state = 540;
            this.stringLiteral();
            this.state = 541;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 542;
            this.stringLiteral();
            this.state = 545;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 78) {
                {
                this.state = 543;
                this.match(QuixosCapabilityParser.SEMANTIC_MAJOR);
                this.state = 544;
                this.match(QuixosCapabilityParser.INTEGER);
                }
            }

            this.state = 547;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 551;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 2 || _la === 22 || ((((_la - 49)) & ~0x1F) === 0 && ((1 << (_la - 49)) & 7) !== 0)) {
                {
                {
                this.state = 548;
                this.packageExport();
                }
                }
                this.state = 553;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 554;
            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, 54, QuixosCapabilityParser.RULE_packageExport);
        try {
            this.state = 562;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 45, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 556;
                this.packageOperationExport();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 557;
                this.packageFunctionExport();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 558;
                this.packageConstructorExport();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 559;
                this.packageQuery();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 560;
                this.packageQuerySpecialization();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 561;
                this.moduleExport();
                }
                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 moduleExport(): ModuleExportContext {
        let localContext = new ModuleExportContext(this.context, this.state);
        this.enterRule(localContext, 56, QuixosCapabilityParser.RULE_moduleExport);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 564;
            this.match(QuixosCapabilityParser.MODULE);
            this.state = 565;
            this.identifier();
            this.state = 566;
            this.match(QuixosCapabilityParser.ID);
            this.state = 567;
            this.stringLiteral();
            this.state = 568;
            this.match(QuixosCapabilityParser.IMPLEMENTS);
            this.state = 569;
            this.interfaceType();
            this.state = 570;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 571;
            this.identifier();
            this.state = 572;
            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 presentationDecl(): PresentationDeclContext {
        let localContext = new PresentationDeclContext(this.context, this.state);
        this.enterRule(localContext, 58, QuixosCapabilityParser.RULE_presentationDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 574;
            this.match(QuixosCapabilityParser.PRESENTATION);
            this.state = 575;
            this.identifier();
            this.state = 576;
            this.match(QuixosCapabilityParser.ID);
            this.state = 577;
            this.stringLiteral();
            this.state = 578;
            this.match(QuixosCapabilityParser.FOR);
            this.state = 579;
            this.interfaceType();
            this.state = 580;
            this.match(QuixosCapabilityParser.USING);
            this.state = 581;
            this.identifier();
            this.state = 582;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 583;
            this.identifier();
            this.state = 584;
            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 packageQuery(): PackageQueryContext {
        let localContext = new PackageQueryContext(this.context, this.state);
        this.enterRule(localContext, 60, QuixosCapabilityParser.RULE_packageQuery);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 586;
            this.match(QuixosCapabilityParser.QUERY);
            this.state = 588;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context) ) {
            case 1:
                {
                this.state = 587;
                this.match(QuixosCapabilityParser.FRAGMENT);
                }
                break;
            }
            this.state = 590;
            this.identifier();
            this.state = 592;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 591;
                this.typeParameters();
                }
            }

            this.state = 594;
            this.match(QuixosCapabilityParser.ID);
            this.state = 595;
            this.stringLiteral();
            this.state = 596;
            this.match(QuixosCapabilityParser.ROOT);
            this.state = 598;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 9) {
                {
                this.state = 597;
                this.match(QuixosCapabilityParser.WORKSPACE);
                }
            }

            this.state = 600;
            this.interfaceType();
            this.state = 601;
            this.match(QuixosCapabilityParser.DOCUMENT);
            this.state = 602;
            this.stringLiteral();
            this.state = 631;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.OPERATION:
                {
                this.state = 603;
                this.match(QuixosCapabilityParser.OPERATION);
                this.state = 604;
                this.stringLiteral();
                this.state = 605;
                this.match(QuixosCapabilityParser.LBRACE);
                this.state = 609;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4160946176) !== 0) || _la === 93) {
                    {
                    {
                    this.state = 606;
                    this.queryClause();
                    }
                    }
                    this.state = 611;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 612;
                this.match(QuixosCapabilityParser.RBRACE);
                }
                break;
            case QuixosCapabilityParser.FRAGMENT:
                {
                this.state = 614;
                this.match(QuixosCapabilityParser.FRAGMENT);
                this.state = 615;
                this.stringLiteral();
                this.state = 618;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 49) {
                    {
                    this.state = 616;
                    this.match(QuixosCapabilityParser.OPERATION);
                    this.state = 617;
                    this.stringLiteral();
                    }
                }

                this.state = 629;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case QuixosCapabilityParser.LBRACE:
                    {
                    this.state = 620;
                    this.match(QuixosCapabilityParser.LBRACE);
                    this.state = 624;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4160946176) !== 0) || _la === 93) {
                        {
                        {
                        this.state = 621;
                        this.queryClause();
                        }
                        }
                        this.state = 626;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 627;
                    this.match(QuixosCapabilityParser.RBRACE);
                    }
                    break;
                case QuixosCapabilityParser.SEMI:
                    {
                    this.state = 628;
                    this.match(QuixosCapabilityParser.SEMI);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                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 packageQuerySpecialization(): PackageQuerySpecializationContext {
        let localContext = new PackageQuerySpecializationContext(this.context, this.state);
        this.enterRule(localContext, 62, QuixosCapabilityParser.RULE_packageQuerySpecialization);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 633;
            this.match(QuixosCapabilityParser.QUERY);
            this.state = 634;
            this.identifier();
            this.state = 635;
            this.match(QuixosCapabilityParser.ID);
            this.state = 636;
            this.stringLiteral();
            this.state = 637;
            this.match(QuixosCapabilityParser.SPECIALIZE);
            this.state = 638;
            this.identifier();
            this.state = 639;
            this.typeArguments();
            this.state = 640;
            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 queryClause(): QueryClauseContext {
        let localContext = new QueryClauseContext(this.context, this.state);
        this.enterRule(localContext, 64, QuixosCapabilityParser.RULE_queryClause);
        let _la: number;
        try {
            this.state = 699;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 57, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 642;
                this.match(QuixosCapabilityParser.REPLICA);
                this.state = 643;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 644;
                this.match(QuixosCapabilityParser.LOCAL);
                this.state = 645;
                this.match(QuixosCapabilityParser.FROM);
                this.state = 646;
                this.identifier();
                this.state = 647;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 649;
                this.match(QuixosCapabilityParser.FRAGMENTS);
                this.state = 650;
                this.stringLiteral();
                this.state = 651;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 653;
                this.match(QuixosCapabilityParser.FRAGMENTS);
                this.state = 654;
                this.identifier();
                this.state = 655;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 656;
                this.identifier();
                this.state = 666;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 64) {
                    {
                    this.state = 657;
                    this.match(QuixosCapabilityParser.WITH);
                    this.state = 658;
                    this.match(QuixosCapabilityParser.LBRACE);
                    this.state = 662;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149) {
                        {
                        {
                        this.state = 659;
                        this.fragmentVariable();
                        }
                        }
                        this.state = 664;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 665;
                    this.match(QuixosCapabilityParser.RBRACE);
                    }
                }

                this.state = 668;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 670;
                this.match(QuixosCapabilityParser.VIEW);
                this.state = 672;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 36) {
                    {
                    this.state = 671;
                    this.match(QuixosCapabilityParser.OBJECT);
                    }
                }

                this.state = 674;
                this.identifier();
                this.state = 675;
                this.match(QuixosCapabilityParser.AS);
                this.state = 676;
                this.interfaceType();
                this.state = 677;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 679;
                this.match(QuixosCapabilityParser.MAX);
                this.state = 680;
                this.identifier();
                this.state = 681;
                this.match(QuixosCapabilityParser.INTEGER);
                this.state = 682;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 684;
                this.match(QuixosCapabilityParser.ALLOW);
                this.state = 685;
                this.interfaceType();
                this.state = 686;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 687;
                this.identifier();
                this.state = 688;
                this.identifier();
                this.state = 689;
                this.stringLiteral();
                this.state = 690;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 692;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 693;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 694;
                this.match(QuixosCapabilityParser.POLL);
                this.state = 695;
                this.match(QuixosCapabilityParser.INTEGER);
                this.state = 696;
                this.stringLiteral();
                this.state = 697;
                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 fragmentVariable(): FragmentVariableContext {
        let localContext = new FragmentVariableContext(this.context, this.state);
        this.enterRule(localContext, 66, QuixosCapabilityParser.RULE_fragmentVariable);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 701;
            this.identifier();
            this.state = 702;
            this.match(QuixosCapabilityParser.TO);
            this.state = 703;
            this.identifier();
            this.state = 704;
            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 packageOperationExport(): PackageOperationExportContext {
        let localContext = new PackageOperationExportContext(this.context, this.state);
        this.enterRule(localContext, 68, QuixosCapabilityParser.RULE_packageOperationExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 706;
            this.match(QuixosCapabilityParser.OPERATION);
            this.state = 707;
            this.identifier();
            this.state = 709;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 708;
                this.typeParameters();
                }
            }

            this.state = 711;
            this.match(QuixosCapabilityParser.ID);
            this.state = 712;
            this.stringLiteral();
            this.state = 713;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 714;
            this.valueType();
            this.state = 715;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 716;
            this.valueType();
            this.state = 717;
            this.match(QuixosCapabilityParser.MODE);
            this.state = 718;
            this.operationMode();
            this.state = 720;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 10) {
                {
                this.state = 719;
                this.executionClause();
                }
            }

            this.state = 723;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 87) {
                {
                this.state = 722;
                this.eventClause();
                }
            }

            this.state = 725;
            this.match(QuixosCapabilityParser.RECEIVER);
            this.state = 726;
            this.receiverRequirement();
            this.state = 728;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 89) {
                {
                this.state = 727;
                this.dependencyBlock();
                }
            }

            this.state = 731;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 66) {
                {
                this.state = 730;
                this.acceptanceClause();
                }
            }

            this.state = 733;
            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, 70, QuixosCapabilityParser.RULE_packageFunctionExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 735;
            this.match(QuixosCapabilityParser.FUNCTION);
            this.state = 736;
            this.identifier();
            this.state = 738;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 737;
                this.typeParameters();
                }
            }

            this.state = 740;
            this.match(QuixosCapabilityParser.ID);
            this.state = 741;
            this.stringLiteral();
            this.state = 742;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 743;
            this.valueType();
            this.state = 744;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 745;
            this.valueType();
            this.state = 747;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 10) {
                {
                this.state = 746;
                this.executionClause();
                }
            }

            this.state = 750;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 89) {
                {
                this.state = 749;
                this.dependencyBlock();
                }
            }

            this.state = 753;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 66) {
                {
                this.state = 752;
                this.acceptanceClause();
                }
            }

            this.state = 755;
            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 acceptanceClause(): AcceptanceClauseContext {
        let localContext = new AcceptanceClauseContext(this.context, this.state);
        this.enterRule(localContext, 72, QuixosCapabilityParser.RULE_acceptanceClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 757;
            this.match(QuixosCapabilityParser.ACCEPT);
            this.state = 758;
            this.match(QuixosCapabilityParser.USING);
            this.state = 759;
            this.identifier();
            }
        }
        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 executionClause(): ExecutionClauseContext {
        let localContext = new ExecutionClauseContext(this.context, this.state);
        this.enterRule(localContext, 74, QuixosCapabilityParser.RULE_executionClause);
        let _la: number;
        try {
            this.state = 770;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 67, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 761;
                this.match(QuixosCapabilityParser.EXECUTION);
                this.state = 762;
                this.match(QuixosCapabilityParser.REMOTE);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 763;
                this.match(QuixosCapabilityParser.EXECUTION);
                this.state = 764;
                _la = this.tokenStream.LA(1);
                if(!(_la === 11 || _la === 12)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 765;
                this.match(QuixosCapabilityParser.TARGETS);
                this.state = 766;
                this.match(QuixosCapabilityParser.LBRACK);
                this.state = 767;
                this.identifierList();
                this.state = 768;
                this.match(QuixosCapabilityParser.RBRACK);
                }
                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 selectedOperations(): SelectedOperationsContext {
        let localContext = new SelectedOperationsContext(this.context, this.state);
        this.enterRule(localContext, 76, QuixosCapabilityParser.RULE_selectedOperations);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 772;
            this.match(QuixosCapabilityParser.USING);
            this.state = 773;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 774;
            this.memberOperationRef();
            this.state = 779;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 135) {
                {
                {
                this.state = 775;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 776;
                this.memberOperationRef();
                }
                }
                this.state = 781;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 782;
            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 packageConstructorExport(): PackageConstructorExportContext {
        let localContext = new PackageConstructorExportContext(this.context, this.state);
        this.enterRule(localContext, 78, QuixosCapabilityParser.RULE_packageConstructorExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 784;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 785;
            this.identifier();
            this.state = 786;
            this.match(QuixosCapabilityParser.ID);
            this.state = 787;
            this.stringLiteral();
            this.state = 788;
            this.match(QuixosCapabilityParser.CONSTRUCTS);
            this.state = 789;
            this.identifier();
            this.state = 790;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 791;
            this.valueType();
            this.state = 793;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 89) {
                {
                this.state = 792;
                this.dependencyBlock();
                }
            }

            this.state = 795;
            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, 80, QuixosCapabilityParser.RULE_eventClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 797;
            this.match(QuixosCapabilityParser.EMITS);
            this.state = 798;
            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, 82, QuixosCapabilityParser.RULE_operationMode);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 800;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 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, 84, QuixosCapabilityParser.RULE_receiverRequirement);
        let _la: number;
        try {
            this.state = 820;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ANY:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 802;
                this.match(QuixosCapabilityParser.ANY);
                }
                break;
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 803;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 804;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 805;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 806;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACES:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 807;
                this.match(QuixosCapabilityParser.INTERFACES);
                this.state = 808;
                this.match(QuixosCapabilityParser.LBRACK);
                this.state = 817;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149) {
                    {
                    this.state = 809;
                    this.interfaceType();
                    this.state = 814;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 135) {
                        {
                        {
                        this.state = 810;
                        this.match(QuixosCapabilityParser.COMMA);
                        this.state = 811;
                        this.interfaceType();
                        }
                        }
                        this.state = 816;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                }

                this.state = 819;
                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, 86, QuixosCapabilityParser.RULE_identifierList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 822;
            this.identifier();
            this.state = 827;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 135) {
                {
                {
                this.state = 823;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 824;
                this.identifier();
                }
                }
                this.state = 829;
                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, 88, QuixosCapabilityParser.RULE_dependencyBlock);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 830;
            this.match(QuixosCapabilityParser.REQUIRES);
            this.state = 831;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 835;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 12583040) !== 0) || ((((_la - 44)) & ~0x1F) === 0 && ((1 << (_la - 44)) & 393345) !== 0)) {
                {
                {
                this.state = 832;
                this.dependencyPort();
                }
                }
                this.state = 837;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 838;
            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, 90, QuixosCapabilityParser.RULE_dependencyPort);
        let _la: number;
        try {
            this.state = 918;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.REFLECTION:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 840;
                this.match(QuixosCapabilityParser.REFLECTION);
                this.state = 841;
                this.identifier();
                this.state = 842;
                this.match(QuixosCapabilityParser.ID);
                this.state = 843;
                this.stringLiteral();
                this.state = 844;
                this.match(QuixosCapabilityParser.LBRACK);
                this.state = 845;
                this.identifierList();
                this.state = 846;
                this.match(QuixosCapabilityParser.RBRACK);
                this.state = 847;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 849;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 850;
                this.identifier();
                this.state = 851;
                this.match(QuixosCapabilityParser.ID);
                this.state = 852;
                this.stringLiteral();
                this.state = 853;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 854;
                this.valueType();
                this.state = 855;
                this.primitiveList();
                this.state = 856;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 858;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 859;
                this.identifier();
                this.state = 860;
                this.match(QuixosCapabilityParser.ID);
                this.state = 861;
                this.stringLiteral();
                this.state = 862;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 863;
                this.cardinality();
                this.state = 864;
                this.targetConstraint();
                this.state = 865;
                this.primitiveList();
                this.state = 866;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 868;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 869;
                this.identifier();
                this.state = 870;
                this.match(QuixosCapabilityParser.ID);
                this.state = 871;
                this.stringLiteral();
                this.state = 872;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 873;
                this.identifier();
                this.state = 875;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 874;
                    this.typeArguments();
                    }
                }

                this.state = 878;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 65) {
                    {
                    this.state = 877;
                    this.selectedOperations();
                    }
                }

                this.state = 882;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 18) {
                    {
                    this.state = 880;
                    this.match(QuixosCapabilityParser.FROM);
                    this.state = 881;
                    this.match(QuixosCapabilityParser.INPUT);
                    }
                }

                this.state = 884;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CREATION:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 886;
                this.match(QuixosCapabilityParser.CREATION);
                this.state = 887;
                this.identifier();
                this.state = 888;
                this.match(QuixosCapabilityParser.ID);
                this.state = 889;
                this.stringLiteral();
                this.state = 890;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 891;
                this.identifier();
                this.state = 892;
                this.match(QuixosCapabilityParser.INPUT);
                this.state = 893;
                this.valueType();
                this.state = 894;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CONSTRUCTOR:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 896;
                this.match(QuixosCapabilityParser.CONSTRUCTOR);
                this.state = 897;
                this.identifier();
                this.state = 898;
                this.match(QuixosCapabilityParser.ID);
                this.state = 899;
                this.stringLiteral();
                this.state = 900;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 901;
                this.identifier();
                this.state = 904;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 53) {
                    {
                    this.state = 902;
                    this.match(QuixosCapabilityParser.INPUT);
                    this.state = 903;
                    this.valueType();
                    }
                }

                this.state = 906;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.QUERY:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 908;
                this.match(QuixosCapabilityParser.QUERY);
                this.state = 909;
                this.identifier();
                this.state = 910;
                this.match(QuixosCapabilityParser.ID);
                this.state = 911;
                this.stringLiteral();
                this.state = 912;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 913;
                this.identifier();
                this.state = 914;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 915;
                this.identifier();
                this.state = 916;
                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, 92, QuixosCapabilityParser.RULE_primitiveList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 920;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 921;
            this.primitive();
            this.state = 926;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 135) {
                {
                {
                this.state = 922;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 923;
                this.primitive();
                }
                }
                this.state = 928;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 929;
            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, 94, QuixosCapabilityParser.RULE_primitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 931;
            _la = this.tokenStream.LA(1);
            if(!(_la === 1 || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 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, 96, QuixosCapabilityParser.RULE_sharedAttachmentDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 933;
            this.match(QuixosCapabilityParser.SHARED);
            this.state = 934;
            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, 98, QuixosCapabilityParser.RULE_attachmentDecl);
        try {
            this.state = 938;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 936;
                this.stateDecl();
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 937;
                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, 100, QuixosCapabilityParser.RULE_stateDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 940;
            this.match(QuixosCapabilityParser.STATE);
            this.state = 941;
            this.identifier();
            this.state = 942;
            this.match(QuixosCapabilityParser.ID);
            this.state = 943;
            this.stringLiteral();
            this.state = 944;
            this.match(QuixosCapabilityParser.ON);
            this.state = 945;
            this.identifier();
            this.state = 946;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 947;
            this.valueType();
            this.state = 948;
            this.match(QuixosCapabilityParser.POLICY);
            this.state = 949;
            this.storagePolicy();
            this.state = 952;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 73) {
                {
                this.state = 950;
                this.match(QuixosCapabilityParser.DEFAULT);
                this.state = 951;
                this.jsonLiteral();
                }
            }

            this.state = 954;
            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, 102, QuixosCapabilityParser.RULE_storagePolicy);
        try {
            this.state = 962;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.REGISTER:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 956;
                this.match(QuixosCapabilityParser.REGISTER);
                }
                break;
            case QuixosCapabilityParser.CRDT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 957;
                this.match(QuixosCapabilityParser.CRDT);
                this.state = 958;
                this.match(QuixosCapabilityParser.LPAREN);
                this.state = 959;
                this.valueType();
                this.state = 960;
                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, 104, QuixosCapabilityParser.RULE_edgeDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 964;
            this.match(QuixosCapabilityParser.EDGE);
            this.state = 965;
            this.identifier();
            this.state = 966;
            this.match(QuixosCapabilityParser.ID);
            this.state = 967;
            this.stringLiteral();
            this.state = 968;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 969;
            this.edgeEndpoint();
            this.state = 970;
            this.edgeEndpoint();
            this.state = 971;
            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, 106, QuixosCapabilityParser.RULE_edgeEndpoint);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 973;
            this.targetConstraint();
            this.state = 974;
            this.match(QuixosCapabilityParser.PROJECTION);
            this.state = 975;
            this.identifier();
            this.state = 976;
            this.match(QuixosCapabilityParser.ID);
            this.state = 977;
            this.stringLiteral();
            this.state = 978;
            this.cardinality();
            this.state = 980;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 112) {
                {
                this.state = 979;
                this.match(QuixosCapabilityParser.ORDERED);
                }
            }

            this.state = 984;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 79) {
                {
                this.state = 982;
                this.match(QuixosCapabilityParser.ON_DELETE);
                this.state = 983;
                this.stringLiteral();
                }
            }

            this.state = 987;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 81) {
                {
                this.state = 986;
                this.match(QuixosCapabilityParser.RETAIN_OTHER);
                }
            }

            this.state = 991;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 82) {
                {
                this.state = 989;
                this.match(QuixosCapabilityParser.KEYED);
                this.state = 990;
                this.stringLiteral();
                }
            }

            this.state = 994;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 83) {
                {
                this.state = 993;
                this.match(QuixosCapabilityParser.PUBLIC_TRAVERSAL);
                }
            }

            this.state = 996;
            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, 108, QuixosCapabilityParser.RULE_conformanceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 998;
            this.match(QuixosCapabilityParser.CONFORM);
            this.state = 1000;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 999;
                this.typeParameters();
                }
            }

            this.state = 1002;
            this.identifier();
            this.state = 1004;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 1003;
                this.conformanceSourceArguments();
                }
            }

            this.state = 1006;
            this.match(QuixosCapabilityParser.AS);
            this.state = 1007;
            this.identifier();
            this.state = 1009;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 143) {
                {
                this.state = 1008;
                this.typeArguments();
                }
            }

            this.state = 1013;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 84) {
                {
                this.state = 1011;
                this.match(QuixosCapabilityParser.ID);
                this.state = 1012;
                this.stringLiteral();
                }
            }

            this.state = 1017;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 78) {
                {
                this.state = 1015;
                this.match(QuixosCapabilityParser.SEMANTIC_MAJOR);
                this.state = 1016;
                this.match(QuixosCapabilityParser.INTEGER);
                }
            }

            this.state = 1019;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 1023;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 8 || ((((_la - 56)) & ~0x1F) === 0 && ((1 << (_la - 56)) & 4105) !== 0)) {
                {
                {
                this.state = 1020;
                this.conformanceItem();
                }
                }
                this.state = 1025;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1026;
            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 conformanceSourceArguments(): ConformanceSourceArgumentsContext {
        let localContext = new ConformanceSourceArgumentsContext(this.context, this.state);
        this.enterRule(localContext, 110, QuixosCapabilityParser.RULE_conformanceSourceArguments);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1028;
            this.typeArguments();
            }
        }
        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, 112, QuixosCapabilityParser.RULE_conformanceItem);
        try {
            this.state = 1037;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 95, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1030;
                this.match(QuixosCapabilityParser.PRIVATE);
                this.state = 1031;
                this.attachmentDecl();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1032;
                this.operationBindingDecl();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1033;
                this.stateFieldBindingDecl();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1034;
                this.initializationDecl();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1035;
                this.relationshipMaterializationDecl();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1036;
                this.moduleBindingDecl();
                }
                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 moduleBindingDecl(): ModuleBindingDeclContext {
        let localContext = new ModuleBindingDeclContext(this.context, this.state);
        this.enterRule(localContext, 114, QuixosCapabilityParser.RULE_moduleBindingDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1039;
            this.match(QuixosCapabilityParser.BIND);
            this.state = 1040;
            this.identifier();
            this.state = 1041;
            this.match(QuixosCapabilityParser.TO);
            this.state = 1042;
            this.identifier();
            this.state = 1043;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 1044;
            this.identifier();
            this.state = 1045;
            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 initializationDecl(): InitializationDeclContext {
        let localContext = new InitializationDeclContext(this.context, this.state);
        this.enterRule(localContext, 116, QuixosCapabilityParser.RULE_initializationDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1047;
            this.match(QuixosCapabilityParser.INITIALIZE);
            this.state = 1048;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 1052;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149) {
                {
                {
                this.state = 1049;
                this.initializationField();
                }
                }
                this.state = 1054;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1055;
            this.match(QuixosCapabilityParser.RBRACE);
            this.state = 1056;
            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 initializationField(): InitializationFieldContext {
        let localContext = new InitializationFieldContext(this.context, this.state);
        this.enterRule(localContext, 118, QuixosCapabilityParser.RULE_initializationField);
        try {
            this.state = 1072;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1058;
                this.identifier();
                this.state = 1059;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1060;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 1061;
                this.identifier();
                this.state = 1062;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1064;
                this.identifier();
                this.state = 1065;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1066;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 1067;
                this.identifier();
                this.state = 1068;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1069;
                this.identifier();
                this.state = 1070;
                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 creationOwnerMapping(): CreationOwnerMappingContext {
        let localContext = new CreationOwnerMappingContext(this.context, this.state);
        this.enterRule(localContext, 120, QuixosCapabilityParser.RULE_creationOwnerMapping);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1074;
            this.interfaceType();
            this.state = 1075;
            this.match(QuixosCapabilityParser.FROM);
            this.state = 1076;
            this.match(QuixosCapabilityParser.INPUT);
            this.state = 1081;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 136) {
                {
                {
                this.state = 1077;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1078;
                this.identifier();
                }
                }
                this.state = 1083;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1084;
            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 stateFieldBindingDecl(): StateFieldBindingDeclContext {
        let localContext = new StateFieldBindingDeclContext(this.context, this.state);
        this.enterRule(localContext, 122, QuixosCapabilityParser.RULE_stateFieldBindingDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1086;
            this.match(QuixosCapabilityParser.BIND);
            this.state = 1087;
            this.identifier();
            this.state = 1088;
            this.match(QuixosCapabilityParser.TO);
            this.state = 1089;
            this.match(QuixosCapabilityParser.STATE);
            this.state = 1090;
            this.identifier();
            this.state = 1091;
            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 relationshipMaterializationDecl(): RelationshipMaterializationDeclContext {
        let localContext = new RelationshipMaterializationDeclContext(this.context, this.state);
        this.enterRule(localContext, 124, QuixosCapabilityParser.RULE_relationshipMaterializationDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1093;
            this.match(QuixosCapabilityParser.MATERIALIZE);
            this.state = 1094;
            this.identifier();
            this.state = 1095;
            this.match(QuixosCapabilityParser.IF);
            this.state = 1096;
            this.match(QuixosCapabilityParser.ABSENT);
            this.state = 1097;
            this.match(QuixosCapabilityParser.USING);
            this.state = 1098;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 1099;
            this.identifier();
            this.state = 1100;
            this.match(QuixosCapabilityParser.VIA);
            this.state = 1101;
            this.match(QuixosCapabilityParser.EDGE);
            this.state = 1102;
            this.identifier();
            this.state = 1103;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 1104;
            this.identifier();
            this.state = 1105;
            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, 126, QuixosCapabilityParser.RULE_operationBindingDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1107;
            this.match(QuixosCapabilityParser.BIND);
            this.state = 1108;
            this.memberOperationRef();
            this.state = 1109;
            this.match(QuixosCapabilityParser.TO);
            this.state = 1110;
            this.operationProvider();
            this.state = 1113;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 34) {
                {
                this.state = 1111;
                this.match(QuixosCapabilityParser.QUERY_REASON);
                this.state = 1112;
                this.stringLiteral();
                }
            }

            this.state = 1115;
            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, 128, QuixosCapabilityParser.RULE_memberOperationRef);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1117;
            this.identifier();
            this.state = 1118;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 1119;
            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, 130, QuixosCapabilityParser.RULE_operationName);
        try {
            this.state = 1133;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 100, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1121;
                this.identifier();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1122;
                this.match(QuixosCapabilityParser.CALL);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1123;
                this.match(QuixosCapabilityParser.GET);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1124;
                this.match(QuixosCapabilityParser.SET);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1125;
                this.match(QuixosCapabilityParser.EDIT);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1126;
                this.match(QuixosCapabilityParser.RESOLVE);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1127;
                this.match(QuixosCapabilityParser.CONNECT);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 1128;
                this.match(QuixosCapabilityParser.DISCONNECT);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 1129;
                this.match(QuixosCapabilityParser.WATCH_START);
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 1130;
                this.match(QuixosCapabilityParser.WATCH_STOP);
                }
                break;
            case 11:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 1131;
                this.match(QuixosCapabilityParser.SUBSCRIBE);
                }
                break;
            case 12:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 1132;
                this.match(QuixosCapabilityParser.UNSUBSCRIBE);
                }
                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 operationProvider(): OperationProviderContext {
        let localContext = new OperationProviderContext(this.context, this.state);
        this.enterRule(localContext, 132, QuixosCapabilityParser.RULE_operationProvider);
        let _la: number;
        try {
            this.state = 1171;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.LIFECYCLE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1135;
                this.match(QuixosCapabilityParser.LIFECYCLE);
                this.state = 1136;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1137;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1138;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 1139;
                this.identifier();
                this.state = 1140;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1141;
                this.statePrimitive();
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1143;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 1144;
                this.identifier();
                this.state = 1145;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1146;
                this.identifier();
                this.state = 1147;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1148;
                this.edgePrimitive();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1150;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 1151;
                this.identifier();
                this.state = 1153;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 1152;
                    this.typeArguments();
                    }
                }

                this.state = 1155;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1156;
                this.memberOperationRef();
                }
                break;
            case QuixosCapabilityParser.PACKAGE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1158;
                this.match(QuixosCapabilityParser.PACKAGE);
                this.state = 1159;
                this.identifier();
                this.state = 1160;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1161;
                this.identifier();
                this.state = 1163;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 1162;
                    this.typeArguments();
                    }
                }

                this.state = 1166;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 64) {
                    {
                    this.state = 1165;
                    this.dependencyBindingBlock();
                    }
                }

                this.state = 1169;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 66) {
                    {
                    this.state = 1168;
                    this.acceptanceBinding();
                    }
                }

                }
                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 acceptanceBinding(): AcceptanceBindingContext {
        let localContext = new AcceptanceBindingContext(this.context, this.state);
        this.enterRule(localContext, 134, QuixosCapabilityParser.RULE_acceptanceBinding);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1173;
            this.match(QuixosCapabilityParser.ACCEPT);
            this.state = 1174;
            this.dependencyBindingBlock();
            }
        }
        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, 136, QuixosCapabilityParser.RULE_statePrimitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1176;
            _la = this.tokenStream.LA(1);
            if(!(_la === 1 || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 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, 138, QuixosCapabilityParser.RULE_edgePrimitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1178;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 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, 140, QuixosCapabilityParser.RULE_dependencyBindingBlock);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1180;
            this.match(QuixosCapabilityParser.WITH);
            this.state = 1181;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 1185;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149) {
                {
                {
                this.state = 1182;
                this.dependencyBinding();
                }
                }
                this.state = 1187;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1188;
            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, 142, QuixosCapabilityParser.RULE_dependencyBinding);
        let _la: number;
        try {
            this.state = 1288;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 114, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1190;
                this.identifier();
                this.state = 1191;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1192;
                this.match(QuixosCapabilityParser.WORKSPACE);
                this.state = 1193;
                this.match(QuixosCapabilityParser.REFLECTION);
                this.state = 1194;
                this.match(QuixosCapabilityParser.LBRACK);
                this.state = 1195;
                this.identifierList();
                this.state = 1196;
                this.match(QuixosCapabilityParser.RBRACK);
                this.state = 1197;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1199;
                this.identifier();
                this.state = 1200;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1201;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 1202;
                this.identifier();
                this.state = 1209;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 67) {
                    {
                    this.state = 1203;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 1204;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 1205;
                    this.identifier();
                    this.state = 1206;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 1207;
                    this.identifier();
                    }
                }

                this.state = 1211;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1213;
                this.identifier();
                this.state = 1214;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1215;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 1216;
                this.identifier();
                this.state = 1217;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1218;
                this.identifier();
                this.state = 1225;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 67) {
                    {
                    this.state = 1219;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 1220;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 1221;
                    this.identifier();
                    this.state = 1222;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 1223;
                    this.identifier();
                    }
                }

                this.state = 1227;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1229;
                this.identifier();
                this.state = 1230;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1231;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 1232;
                this.identifier();
                this.state = 1234;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 1233;
                    this.typeArguments();
                    }
                }

                this.state = 1244;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case QuixosCapabilityParser.VIA:
                    {
                    {
                    this.state = 1236;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 1237;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 1238;
                    this.identifier();
                    this.state = 1239;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 1240;
                    this.identifier();
                    }
                    }
                    break;
                case QuixosCapabilityParser.FROM:
                    {
                    {
                    this.state = 1242;
                    this.match(QuixosCapabilityParser.FROM);
                    this.state = 1243;
                    this.match(QuixosCapabilityParser.INPUT);
                    }
                    }
                    break;
                case QuixosCapabilityParser.SEMI:
                    break;
                default:
                    break;
                }
                this.state = 1246;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1248;
                this.identifier();
                this.state = 1249;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1250;
                this.match(QuixosCapabilityParser.CREATION);
                this.state = 1251;
                this.identifier();
                this.state = 1252;
                this.match(QuixosCapabilityParser.WITH);
                this.state = 1253;
                this.match(QuixosCapabilityParser.LBRACE);
                this.state = 1257;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149) {
                    {
                    {
                    this.state = 1254;
                    this.creationOwnerMapping();
                    }
                    }
                    this.state = 1259;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 1260;
                this.match(QuixosCapabilityParser.RBRACE);
                this.state = 1261;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1263;
                this.identifier();
                this.state = 1264;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1265;
                this.match(QuixosCapabilityParser.CONSTRUCTOR);
                this.state = 1266;
                this.identifier();
                this.state = 1267;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1269;
                this.identifier();
                this.state = 1270;
                this.match(QuixosCapabilityParser.TO);
                this.state = 1272;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 9) {
                    {
                    this.state = 1271;
                    this.match(QuixosCapabilityParser.WORKSPACE);
                    }
                }

                this.state = 1274;
                this.match(QuixosCapabilityParser.QUERY);
                this.state = 1275;
                this.identifier();
                this.state = 1276;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 1277;
                this.identifier();
                this.state = 1284;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 67) {
                    {
                    this.state = 1278;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 1279;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 1280;
                    this.identifier();
                    this.state = 1281;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 1282;
                    this.identifier();
                    }
                }

                this.state = 1286;
                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, 144, QuixosCapabilityParser.RULE_constructorBindingDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1290;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 1291;
            this.identifier();
            this.state = 1292;
            this.match(QuixosCapabilityParser.TO);
            this.state = 1293;
            this.identifier();
            this.state = 1294;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 1295;
            this.identifier();
            this.state = 1297;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 64) {
                {
                this.state = 1296;
                this.dependencyBindingBlock();
                }
            }

            this.state = 1299;
            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, 146, QuixosCapabilityParser.RULE_valueType);
        let _la: number;
        try {
            this.state = 1347;
            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 = 1301;
                this.scalarType();
                }
                break;
            case QuixosCapabilityParser.UNIT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1302;
                this.match(QuixosCapabilityParser.UNIT);
                }
                break;
            case QuixosCapabilityParser.WATCH_HANDLE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1303;
                this.match(QuixosCapabilityParser.WATCH_HANDLE);
                }
                break;
            case QuixosCapabilityParser.MESSAGE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1304;
                this.match(QuixosCapabilityParser.MESSAGE);
                this.state = 1305;
                this.stringLiteral();
                }
                break;
            case QuixosCapabilityParser.ATOM_REF:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1306;
                this.match(QuixosCapabilityParser.ATOM_REF);
                this.state = 1307;
                this.match(QuixosCapabilityParser.LT);
                this.state = 1308;
                this.identifier();
                this.state = 1309;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.INTERFACE_REF:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1311;
                this.match(QuixosCapabilityParser.INTERFACE_REF);
                this.state = 1312;
                this.match(QuixosCapabilityParser.LT);
                this.state = 1313;
                this.identifier();
                this.state = 1315;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 1314;
                    this.typeArguments();
                    }
                }

                this.state = 1317;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.REF:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1319;
                this.match(QuixosCapabilityParser.REF);
                this.state = 1320;
                this.match(QuixosCapabilityParser.LT);
                this.state = 1321;
                this.identifier();
                this.state = 1322;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.OPTIONAL:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 1324;
                this.match(QuixosCapabilityParser.OPTIONAL);
                this.state = 1325;
                this.match(QuixosCapabilityParser.LT);
                this.state = 1326;
                this.valueType();
                this.state = 1327;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.LIST:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 1329;
                this.match(QuixosCapabilityParser.LIST);
                this.state = 1330;
                this.match(QuixosCapabilityParser.LT);
                this.state = 1331;
                this.valueType();
                this.state = 1332;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.RECORD:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 1334;
                this.match(QuixosCapabilityParser.RECORD);
                this.state = 1335;
                this.match(QuixosCapabilityParser.LBRACE);
                this.state = 1339;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149) {
                    {
                    {
                    this.state = 1336;
                    this.recordField();
                    }
                    }
                    this.state = 1341;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 1342;
                this.match(QuixosCapabilityParser.RBRACE);
                }
                break;
            case QuixosCapabilityParser.EDIT:
            case QuixosCapabilityParser.PRESENTATION:
            case QuixosCapabilityParser.SUBJECT:
            case QuixosCapabilityParser.FOR:
            case QuixosCapabilityParser.CREATION:
            case QuixosCapabilityParser.INITIALIZE:
            case QuixosCapabilityParser.EXECUTION:
            case QuixosCapabilityParser.SNAPSHOT:
            case QuixosCapabilityParser.TRANSACTION:
            case QuixosCapabilityParser.REMOTE:
            case QuixosCapabilityParser.TARGETS:
            case QuixosCapabilityParser.PORTABLE:
            case QuixosCapabilityParser.REPLICA:
            case QuixosCapabilityParser.LOCAL:
            case QuixosCapabilityParser.FROM:
            case QuixosCapabilityParser.RESULT_BYTES:
            case QuixosCapabilityParser.RPC_CALLS:
            case QuixosCapabilityParser.DEADLINE_MS:
            case QuixosCapabilityParser.QUERY:
            case QuixosCapabilityParser.REFLECTION:
            case QuixosCapabilityParser.SPECIALIZE:
            case QuixosCapabilityParser.ROOT:
            case QuixosCapabilityParser.DOCUMENT:
            case QuixosCapabilityParser.FRAGMENTS:
            case QuixosCapabilityParser.VIEW:
            case QuixosCapabilityParser.MAX:
            case QuixosCapabilityParser.ALLOW:
            case QuixosCapabilityParser.POLL:
            case QuixosCapabilityParser.QUERYABLE:
            case QuixosCapabilityParser.RPC:
            case QuixosCapabilityParser.FRAGMENT:
            case QuixosCapabilityParser.INTERFACES:
            case QuixosCapabilityParser.SOURCE:
            case QuixosCapabilityParser.START:
            case QuixosCapabilityParser.STOP:
            case QuixosCapabilityParser.REGISTER:
            case QuixosCapabilityParser.IDENTIFIER:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 1343;
                this.identifier();
                this.state = 1345;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 143) {
                    {
                    this.state = 1344;
                    this.typeArguments();
                    }
                }

                }
                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 recordField(): RecordFieldContext {
        let localContext = new RecordFieldContext(this.context, this.state);
        this.enterRule(localContext, 148, QuixosCapabilityParser.RULE_recordField);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1349;
            this.identifier();
            this.state = 1350;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 1351;
            this.valueType();
            this.state = 1352;
            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 scalarType(): ScalarTypeContext {
        let localContext = new ScalarTypeContext(this.context, this.state);
        this.enterRule(localContext, 150, QuixosCapabilityParser.RULE_scalarType);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1354;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 121)) & ~0x1F) === 0 && ((1 << (_la - 121)) & 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, 152, QuixosCapabilityParser.RULE_cardinality);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1356;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 108)) & ~0x1F) === 0 && ((1 << (_la - 108)) & 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, 154, QuixosCapabilityParser.RULE_jsonLiteral);
        try {
            this.state = 1366;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STRING_LITERAL:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1358;
                this.stringLiteral();
                }
                break;
            case QuixosCapabilityParser.INTEGER:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1359;
                this.match(QuixosCapabilityParser.INTEGER);
                }
                break;
            case QuixosCapabilityParser.JSON_NUMBER:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1360;
                this.match(QuixosCapabilityParser.JSON_NUMBER);
                }
                break;
            case QuixosCapabilityParser.TRUE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1361;
                this.match(QuixosCapabilityParser.TRUE);
                }
                break;
            case QuixosCapabilityParser.FALSE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1362;
                this.match(QuixosCapabilityParser.FALSE);
                }
                break;
            case QuixosCapabilityParser.NULL:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1363;
                this.match(QuixosCapabilityParser.NULL);
                }
                break;
            case QuixosCapabilityParser.LBRACE:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1364;
                this.jsonObject();
                }
                break;
            case QuixosCapabilityParser.LBRACK:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 1365;
                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, 156, QuixosCapabilityParser.RULE_jsonObject);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1368;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 1377;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 150) {
                {
                this.state = 1369;
                this.jsonMember();
                this.state = 1374;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 135) {
                    {
                    {
                    this.state = 1370;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 1371;
                    this.jsonMember();
                    }
                    }
                    this.state = 1376;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 1379;
            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, 158, QuixosCapabilityParser.RULE_jsonMember);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1381;
            this.stringLiteral();
            this.state = 1382;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 1383;
            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, 160, QuixosCapabilityParser.RULE_jsonArray);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1385;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 1394;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (((((_la - 129)) & ~0x1F) === 0 && ((1 << (_la - 129)) & 2884871) !== 0)) {
                {
                this.state = 1386;
                this.jsonLiteral();
                this.state = 1391;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 135) {
                    {
                    {
                    this.state = 1387;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 1388;
                    this.jsonLiteral();
                    }
                    }
                    this.state = 1393;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 1396;
            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, 162, QuixosCapabilityParser.RULE_identifier);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1398;
            _la = this.tokenStream.LA(1);
            if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294966770) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 8451) !== 0) || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 3145729) !== 0) || _la === 106 || _la === 149)) {
            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, 164, QuixosCapabilityParser.RULE_stringLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1400;
            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,153,1403,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,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,1,0,1,0,1,0,1,0,1,0,1,
        0,1,0,1,0,1,0,1,0,1,0,1,0,3,0,179,8,0,1,1,1,1,1,1,5,1,184,8,1,10,
        1,12,1,187,9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,
        3,1,3,1,3,1,3,5,3,205,8,3,10,3,12,3,208,9,3,1,3,1,3,1,4,1,4,1,4,
        1,4,1,4,1,4,1,4,1,4,3,4,220,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,
        1,5,1,5,3,5,232,8,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,
        1,7,1,7,1,7,1,8,1,8,1,8,1,8,3,8,252,8,8,1,9,1,9,1,9,1,9,1,9,1,9,
        3,9,260,8,9,1,9,1,9,1,10,5,10,265,8,10,10,10,12,10,268,9,10,1,10,
        1,10,1,10,3,10,273,8,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,
        5,10,283,8,10,10,10,12,10,286,9,10,3,10,288,8,10,1,10,1,10,5,10,
        292,8,10,10,10,12,10,295,9,10,1,10,1,10,1,11,1,11,1,11,1,11,5,11,
        303,8,11,10,11,12,11,306,9,11,1,11,1,11,1,12,1,12,1,12,1,12,3,12,
        314,8,12,1,12,1,12,1,12,1,12,1,12,1,12,5,12,322,8,12,10,12,12,12,
        325,9,12,3,12,327,8,12,3,12,329,8,12,1,13,1,13,3,13,333,8,13,1,14,
        1,14,1,14,1,14,5,14,339,8,14,10,14,12,14,342,9,14,1,14,1,14,1,15,
        1,15,1,15,1,15,1,15,1,15,1,15,3,15,353,8,15,1,16,1,16,1,16,3,16,
        358,8,16,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,3,17,368,8,17,1,
        18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,378,8,18,1,18,1,18,1,
        19,3,19,383,8,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,
        19,1,19,1,19,1,19,3,19,398,8,19,1,19,1,19,1,19,1,20,3,20,404,8,20,
        1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,5,20,414,8,20,10,20,12,20,
        417,9,20,1,20,1,20,1,21,1,21,1,21,1,21,3,21,425,8,21,1,21,1,21,1,
        21,1,21,1,21,1,21,3,21,433,8,21,1,21,1,21,1,21,1,21,1,21,1,21,3,
        21,441,8,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
        21,3,21,454,8,21,1,22,3,22,457,8,22,1,22,1,22,1,22,1,22,1,22,1,22,
        1,22,1,22,3,22,467,8,22,1,22,1,22,3,22,471,8,22,1,22,1,22,5,22,475,
        8,22,10,22,12,22,478,9,22,1,22,1,22,1,23,1,23,3,23,484,8,23,1,24,
        1,24,1,24,1,24,3,24,490,8,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,
        498,8,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,506,8,24,1,24,1,24,1,
        24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,519,8,24,1,25,1,
        25,1,25,1,25,1,25,3,25,526,8,25,1,25,1,25,3,25,530,8,25,1,26,5,26,
        533,8,26,10,26,12,26,536,9,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,
        1,26,3,26,546,8,26,1,26,1,26,5,26,550,8,26,10,26,12,26,553,9,26,
        1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,3,27,563,8,27,1,28,1,28,
        1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,30,1,30,3,30,589,8,30,1,30,
        1,30,3,30,593,8,30,1,30,1,30,1,30,1,30,3,30,599,8,30,1,30,1,30,1,
        30,1,30,1,30,1,30,1,30,5,30,608,8,30,10,30,12,30,611,9,30,1,30,1,
        30,1,30,1,30,1,30,1,30,3,30,619,8,30,1,30,1,30,5,30,623,8,30,10,
        30,12,30,626,9,30,1,30,1,30,3,30,630,8,30,3,30,632,8,30,1,31,1,31,
        1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,5,32,
        661,8,32,10,32,12,32,664,9,32,1,32,3,32,667,8,32,1,32,1,32,1,32,
        1,32,3,32,673,8,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,3,32,700,8,32,1,33,1,33,1,33,1,33,1,33,1,34,1,34,
        1,34,3,34,710,8,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,
        3,34,721,8,34,1,34,3,34,724,8,34,1,34,1,34,1,34,3,34,729,8,34,1,
        34,3,34,732,8,34,1,34,1,34,1,35,1,35,1,35,3,35,739,8,35,1,35,1,35,
        1,35,1,35,1,35,1,35,1,35,3,35,748,8,35,1,35,3,35,751,8,35,1,35,3,
        35,754,8,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,3,37,771,8,37,1,38,1,38,1,38,1,38,1,38,5,
        38,778,8,38,10,38,12,38,781,9,38,1,38,1,38,1,39,1,39,1,39,1,39,1,
        39,1,39,1,39,1,39,1,39,3,39,794,8,39,1,39,1,39,1,40,1,40,1,40,1,
        41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,5,42,813,
        8,42,10,42,12,42,816,9,42,3,42,818,8,42,1,42,3,42,821,8,42,1,43,
        1,43,1,43,5,43,826,8,43,10,43,12,43,829,9,43,1,44,1,44,1,44,5,44,
        834,8,44,10,44,12,44,837,9,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,
        1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,
        1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,
        1,45,1,45,1,45,1,45,3,45,876,8,45,1,45,3,45,879,8,45,1,45,1,45,3,
        45,883,8,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,
        45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,905,8,45,1,
        45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,919,
        8,45,1,46,1,46,1,46,1,46,5,46,925,8,46,10,46,12,46,928,9,46,1,46,
        1,46,1,47,1,47,1,48,1,48,1,48,1,49,1,49,3,49,939,8,49,1,50,1,50,
        1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,953,8,50,
        1,50,1,50,1,51,1,51,1,51,1,51,1,51,1,51,3,51,963,8,51,1,52,1,52,
        1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,
        1,53,3,53,981,8,53,1,53,1,53,3,53,985,8,53,1,53,3,53,988,8,53,1,
        53,1,53,3,53,992,8,53,1,53,3,53,995,8,53,1,53,1,53,1,54,1,54,3,54,
        1001,8,54,1,54,1,54,3,54,1005,8,54,1,54,1,54,1,54,3,54,1010,8,54,
        1,54,1,54,3,54,1014,8,54,1,54,1,54,3,54,1018,8,54,1,54,1,54,5,54,
        1022,8,54,10,54,12,54,1025,9,54,1,54,1,54,1,55,1,55,1,56,1,56,1,
        56,1,56,1,56,1,56,1,56,3,56,1038,8,56,1,57,1,57,1,57,1,57,1,57,1,
        57,1,57,1,57,1,58,1,58,1,58,5,58,1051,8,58,10,58,12,58,1054,9,58,
        1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,
        1,59,1,59,1,59,1,59,3,59,1073,8,59,1,60,1,60,1,60,1,60,1,60,5,60,
        1080,8,60,10,60,12,60,1083,9,60,1,60,1,60,1,61,1,61,1,61,1,61,1,
        61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,
        62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,3,63,1114,8,63,1,
        63,1,63,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,
        65,1,65,1,65,1,65,1,65,3,65,1134,8,65,1,66,1,66,1,66,1,66,1,66,1,
        66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,
        66,1154,8,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1164,8,
        66,1,66,3,66,1167,8,66,1,66,3,66,1170,8,66,3,66,1172,8,66,1,67,1,
        67,1,67,1,68,1,68,1,69,1,69,1,70,1,70,1,70,5,70,1184,8,70,10,70,
        12,70,1187,9,70,1,70,1,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,
        1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1210,
        8,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,
        1,71,1,71,3,71,1226,8,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,
        1235,8,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1245,8,71,
        1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,5,71,1256,8,71,10,71,
        12,71,1259,9,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,
        1,71,1,71,3,71,1273,8,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,
        1,71,1,71,3,71,1285,8,71,1,71,1,71,3,71,1289,8,71,1,72,1,72,1,72,
        1,72,1,72,1,72,1,72,3,72,1298,8,72,1,72,1,72,1,73,1,73,1,73,1,73,
        1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1316,8,73,
        1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,
        1,73,1,73,1,73,1,73,1,73,1,73,1,73,5,73,1338,8,73,10,73,12,73,1341,
        9,73,1,73,1,73,1,73,3,73,1346,8,73,3,73,1348,8,73,1,74,1,74,1,74,
        1,74,1,74,1,75,1,75,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,
        1,77,3,77,1367,8,77,1,78,1,78,1,78,1,78,5,78,1373,8,78,10,78,12,
        78,1376,9,78,3,78,1378,8,78,1,78,1,78,1,79,1,79,1,79,1,79,1,80,1,
        80,1,80,1,80,5,80,1390,8,80,10,80,12,80,1393,9,80,3,80,1395,8,80,
        1,80,1,80,1,81,1,81,1,82,1,82,1,82,0,0,83,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,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,
        136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,0,9,
        2,0,15,15,33,33,1,0,11,12,1,0,101,105,3,0,1,1,96,100,102,103,3,0,
        1,1,96,97,102,103,2,0,98,100,102,103,1,0,121,128,1,0,108,111,9,0,
        1,1,4,8,10,33,40,40,45,45,74,74,94,95,106,106,149,149,1519,0,178,
        1,0,0,0,2,180,1,0,0,0,4,190,1,0,0,0,6,194,1,0,0,0,8,219,1,0,0,0,
        10,231,1,0,0,0,12,233,1,0,0,0,14,240,1,0,0,0,16,251,1,0,0,0,18,253,
        1,0,0,0,20,266,1,0,0,0,22,298,1,0,0,0,24,328,1,0,0,0,26,330,1,0,
        0,0,28,334,1,0,0,0,30,352,1,0,0,0,32,354,1,0,0,0,34,367,1,0,0,0,
        36,369,1,0,0,0,38,382,1,0,0,0,40,403,1,0,0,0,42,453,1,0,0,0,44,456,
        1,0,0,0,46,481,1,0,0,0,48,518,1,0,0,0,50,529,1,0,0,0,52,534,1,0,
        0,0,54,562,1,0,0,0,56,564,1,0,0,0,58,574,1,0,0,0,60,586,1,0,0,0,
        62,633,1,0,0,0,64,699,1,0,0,0,66,701,1,0,0,0,68,706,1,0,0,0,70,735,
        1,0,0,0,72,757,1,0,0,0,74,770,1,0,0,0,76,772,1,0,0,0,78,784,1,0,
        0,0,80,797,1,0,0,0,82,800,1,0,0,0,84,820,1,0,0,0,86,822,1,0,0,0,
        88,830,1,0,0,0,90,918,1,0,0,0,92,920,1,0,0,0,94,931,1,0,0,0,96,933,
        1,0,0,0,98,938,1,0,0,0,100,940,1,0,0,0,102,962,1,0,0,0,104,964,1,
        0,0,0,106,973,1,0,0,0,108,998,1,0,0,0,110,1028,1,0,0,0,112,1037,
        1,0,0,0,114,1039,1,0,0,0,116,1047,1,0,0,0,118,1072,1,0,0,0,120,1074,
        1,0,0,0,122,1086,1,0,0,0,124,1093,1,0,0,0,126,1107,1,0,0,0,128,1117,
        1,0,0,0,130,1133,1,0,0,0,132,1171,1,0,0,0,134,1173,1,0,0,0,136,1176,
        1,0,0,0,138,1178,1,0,0,0,140,1180,1,0,0,0,142,1288,1,0,0,0,144,1290,
        1,0,0,0,146,1347,1,0,0,0,148,1349,1,0,0,0,150,1354,1,0,0,0,152,1356,
        1,0,0,0,154,1366,1,0,0,0,156,1368,1,0,0,0,158,1381,1,0,0,0,160,1385,
        1,0,0,0,162,1398,1,0,0,0,164,1400,1,0,0,0,166,167,3,6,3,0,167,168,
        5,0,0,1,168,179,1,0,0,0,169,170,3,20,10,0,170,171,5,0,0,1,171,179,
        1,0,0,0,172,173,3,52,26,0,173,174,5,0,0,1,174,179,1,0,0,0,175,176,
        3,2,1,0,176,177,5,0,0,1,177,179,1,0,0,0,178,166,1,0,0,0,178,169,
        1,0,0,0,178,172,1,0,0,0,178,175,1,0,0,0,179,1,1,0,0,0,180,181,5,
        40,0,0,181,185,5,137,0,0,182,184,3,8,4,0,183,182,1,0,0,0,184,187,
        1,0,0,0,185,183,1,0,0,0,185,186,1,0,0,0,186,188,1,0,0,0,187,185,
        1,0,0,0,188,189,5,138,0,0,189,3,1,0,0,0,190,191,5,41,0,0,191,192,
        3,164,82,0,192,193,5,134,0,0,193,5,1,0,0,0,194,195,5,9,0,0,195,196,
        3,162,81,0,196,197,5,84,0,0,197,198,3,164,82,0,198,199,5,77,0,0,
        199,200,3,164,82,0,200,201,5,76,0,0,201,202,3,164,82,0,202,206,5,
        137,0,0,203,205,3,8,4,0,204,203,1,0,0,0,205,208,1,0,0,0,206,204,
        1,0,0,0,206,207,1,0,0,0,207,209,1,0,0,0,208,206,1,0,0,0,209,210,
        5,138,0,0,210,7,1,0,0,0,211,220,3,4,2,0,212,220,3,18,9,0,213,220,
        3,10,5,0,214,220,3,96,48,0,215,220,3,108,54,0,216,220,3,144,72,0,
        217,220,3,58,29,0,218,220,3,32,16,0,219,211,1,0,0,0,219,212,1,0,
        0,0,219,213,1,0,0,0,219,214,1,0,0,0,219,215,1,0,0,0,219,216,1,0,
        0,0,219,217,1,0,0,0,219,218,1,0,0,0,220,9,1,0,0,0,221,222,5,41,0,
        0,222,223,5,44,0,0,223,224,3,162,81,0,224,225,5,134,0,0,225,232,
        1,0,0,0,226,227,5,41,0,0,227,228,5,46,0,0,228,229,3,162,81,0,229,
        230,5,134,0,0,230,232,1,0,0,0,231,221,1,0,0,0,231,226,1,0,0,0,232,
        11,1,0,0,0,233,234,5,42,0,0,234,235,5,43,0,0,235,236,3,162,81,0,
        236,237,5,84,0,0,237,238,3,164,82,0,238,239,5,134,0,0,239,13,1,0,
        0,0,240,241,5,42,0,0,241,242,5,44,0,0,242,243,3,162,81,0,243,244,
        5,77,0,0,244,245,3,164,82,0,245,246,5,134,0,0,246,15,1,0,0,0,247,
        252,3,10,5,0,248,252,3,12,6,0,249,252,3,14,7,0,250,252,3,32,16,0,
        251,247,1,0,0,0,251,248,1,0,0,0,251,249,1,0,0,0,251,250,1,0,0,0,
        252,17,1,0,0,0,253,254,5,43,0,0,254,255,3,162,81,0,255,256,5,84,
        0,0,256,259,3,164,82,0,257,258,5,85,0,0,258,260,3,164,82,0,259,257,
        1,0,0,0,259,260,1,0,0,0,260,261,1,0,0,0,261,262,5,134,0,0,262,19,
        1,0,0,0,263,265,3,16,8,0,264,263,1,0,0,0,265,268,1,0,0,0,266,264,
        1,0,0,0,266,267,1,0,0,0,267,269,1,0,0,0,268,266,1,0,0,0,269,270,
        5,44,0,0,270,272,3,162,81,0,271,273,3,22,11,0,272,271,1,0,0,0,272,
        273,1,0,0,0,273,274,1,0,0,0,274,275,5,84,0,0,275,276,3,164,82,0,
        276,277,5,77,0,0,277,287,3,164,82,0,278,279,5,89,0,0,279,284,3,26,
        13,0,280,281,5,135,0,0,281,283,3,26,13,0,282,280,1,0,0,0,283,286,
        1,0,0,0,284,282,1,0,0,0,284,285,1,0,0,0,285,288,1,0,0,0,286,284,
        1,0,0,0,287,278,1,0,0,0,287,288,1,0,0,0,288,289,1,0,0,0,289,293,
        5,137,0,0,290,292,3,34,17,0,291,290,1,0,0,0,292,295,1,0,0,0,293,
        291,1,0,0,0,293,294,1,0,0,0,294,296,1,0,0,0,295,293,1,0,0,0,296,
        297,5,138,0,0,297,21,1,0,0,0,298,299,5,143,0,0,299,304,3,24,12,0,
        300,301,5,135,0,0,301,303,3,24,12,0,302,300,1,0,0,0,303,306,1,0,
        0,0,304,302,1,0,0,0,304,305,1,0,0,0,305,307,1,0,0,0,306,304,1,0,
        0,0,307,308,5,144,0,0,308,23,1,0,0,0,309,310,5,47,0,0,310,313,3,
        162,81,0,311,312,5,133,0,0,312,314,5,37,0,0,313,311,1,0,0,0,313,
        314,1,0,0,0,314,329,1,0,0,0,315,316,5,36,0,0,316,326,3,162,81,0,
        317,318,5,38,0,0,318,323,3,26,13,0,319,320,5,145,0,0,320,322,3,26,
        13,0,321,319,1,0,0,0,322,325,1,0,0,0,323,321,1,0,0,0,323,324,1,0,
        0,0,324,327,1,0,0,0,325,323,1,0,0,0,326,317,1,0,0,0,326,327,1,0,
        0,0,327,329,1,0,0,0,328,309,1,0,0,0,328,315,1,0,0,0,329,25,1,0,0,
        0,330,332,3,162,81,0,331,333,3,28,14,0,332,331,1,0,0,0,332,333,1,
        0,0,0,333,27,1,0,0,0,334,335,5,143,0,0,335,340,3,30,15,0,336,337,
        5,135,0,0,337,339,3,30,15,0,338,336,1,0,0,0,339,342,1,0,0,0,340,
        338,1,0,0,0,340,341,1,0,0,0,341,343,1,0,0,0,342,340,1,0,0,0,343,
        344,5,144,0,0,344,29,1,0,0,0,345,346,5,43,0,0,346,353,3,162,81,0,
        347,348,5,44,0,0,348,353,3,26,13,0,349,350,5,36,0,0,350,353,3,162,
        81,0,351,353,3,146,73,0,352,345,1,0,0,0,352,347,1,0,0,0,352,349,
        1,0,0,0,352,351,1,0,0,0,353,31,1,0,0,0,354,355,5,35,0,0,355,357,
        3,162,81,0,356,358,3,22,11,0,357,356,1,0,0,0,357,358,1,0,0,0,358,
        359,1,0,0,0,359,360,5,146,0,0,360,361,3,146,73,0,361,362,5,134,0,
        0,362,33,1,0,0,0,363,368,3,40,20,0,364,368,3,44,22,0,365,368,3,38,
        19,0,366,368,3,36,18,0,367,363,1,0,0,0,367,364,1,0,0,0,367,365,1,
        0,0,0,367,366,1,0,0,0,368,35,1,0,0,0,369,370,5,2,0,0,370,371,3,162,
        81,0,371,372,5,84,0,0,372,373,3,164,82,0,373,374,5,3,0,0,374,377,
        3,164,82,0,375,376,5,5,0,0,376,378,3,50,25,0,377,375,1,0,0,0,377,
        378,1,0,0,0,378,379,1,0,0,0,379,380,5,134,0,0,380,37,1,0,0,0,381,
        383,5,57,0,0,382,381,1,0,0,0,382,383,1,0,0,0,383,384,1,0,0,0,384,
        385,5,49,0,0,385,386,3,162,81,0,386,387,5,84,0,0,387,388,3,164,82,
        0,388,389,5,133,0,0,389,390,3,146,73,0,390,391,5,132,0,0,391,392,
        3,146,73,0,392,393,5,137,0,0,393,394,5,101,0,0,394,395,5,84,0,0,
        395,397,3,164,82,0,396,398,3,74,37,0,397,396,1,0,0,0,397,398,1,0,
        0,0,398,399,1,0,0,0,399,400,5,134,0,0,400,401,5,138,0,0,401,39,1,
        0,0,0,402,404,3,46,23,0,403,402,1,0,0,0,403,404,1,0,0,0,404,405,
        1,0,0,0,405,406,5,47,0,0,406,407,3,162,81,0,407,408,5,84,0,0,408,
        409,3,164,82,0,409,410,5,133,0,0,410,411,3,146,73,0,411,415,5,137,
        0,0,412,414,3,42,21,0,413,412,1,0,0,0,414,417,1,0,0,0,415,413,1,
        0,0,0,415,416,1,0,0,0,416,418,1,0,0,0,417,415,1,0,0,0,418,419,5,
        138,0,0,419,41,1,0,0,0,420,421,5,91,0,0,421,422,5,84,0,0,422,424,
        3,164,82,0,423,425,3,74,37,0,424,423,1,0,0,0,424,425,1,0,0,0,425,
        426,1,0,0,0,426,427,5,134,0,0,427,454,1,0,0,0,428,429,5,92,0,0,429,
        430,5,84,0,0,430,432,3,164,82,0,431,433,3,74,37,0,432,431,1,0,0,
        0,432,433,1,0,0,0,433,434,1,0,0,0,434,435,5,134,0,0,435,454,1,0,
        0,0,436,437,5,1,0,0,437,438,5,84,0,0,438,440,3,164,82,0,439,441,
        3,74,37,0,440,439,1,0,0,0,440,441,1,0,0,0,441,442,1,0,0,0,442,443,
        5,134,0,0,443,454,1,0,0,0,444,445,5,93,0,0,445,446,5,94,0,0,446,
        447,5,84,0,0,447,448,3,164,82,0,448,449,5,95,0,0,449,450,5,84,0,
        0,450,451,3,164,82,0,451,452,5,134,0,0,452,454,1,0,0,0,453,420,1,
        0,0,0,453,428,1,0,0,0,453,436,1,0,0,0,453,444,1,0,0,0,454,43,1,0,
        0,0,455,457,3,46,23,0,456,455,1,0,0,0,456,457,1,0,0,0,457,458,1,
        0,0,0,458,459,5,48,0,0,459,460,3,162,81,0,460,461,5,84,0,0,461,462,
        3,164,82,0,462,463,5,133,0,0,463,464,3,152,76,0,464,466,3,50,25,
        0,465,467,5,112,0,0,466,465,1,0,0,0,466,467,1,0,0,0,467,470,1,0,
        0,0,468,469,5,82,0,0,469,471,3,164,82,0,470,468,1,0,0,0,470,471,
        1,0,0,0,471,472,1,0,0,0,472,476,5,137,0,0,473,475,3,48,24,0,474,
        473,1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,476,477,1,0,0,0,477,
        479,1,0,0,0,478,476,1,0,0,0,479,480,5,138,0,0,480,45,1,0,0,0,481,
        483,5,32,0,0,482,484,7,0,0,0,483,482,1,0,0,0,483,484,1,0,0,0,484,
        47,1,0,0,0,485,486,5,98,0,0,486,487,5,84,0,0,487,489,3,164,82,0,
        488,490,3,74,37,0,489,488,1,0,0,0,489,490,1,0,0,0,490,491,1,0,0,
        0,491,492,5,134,0,0,492,519,1,0,0,0,493,494,5,99,0,0,494,495,5,84,
        0,0,495,497,3,164,82,0,496,498,3,74,37,0,497,496,1,0,0,0,497,498,
        1,0,0,0,498,499,1,0,0,0,499,500,5,134,0,0,500,519,1,0,0,0,501,502,
        5,100,0,0,502,503,5,84,0,0,503,505,3,164,82,0,504,506,3,74,37,0,
        505,504,1,0,0,0,505,506,1,0,0,0,506,507,1,0,0,0,507,508,5,134,0,
        0,508,519,1,0,0,0,509,510,5,93,0,0,510,511,5,94,0,0,511,512,5,84,
        0,0,512,513,3,164,82,0,513,514,5,95,0,0,514,515,5,84,0,0,515,516,
        3,164,82,0,516,517,5,134,0,0,517,519,1,0,0,0,518,485,1,0,0,0,518,
        493,1,0,0,0,518,501,1,0,0,0,518,509,1,0,0,0,519,49,1,0,0,0,520,521,
        5,43,0,0,521,530,3,162,81,0,522,523,5,44,0,0,523,525,3,162,81,0,
        524,526,3,28,14,0,525,524,1,0,0,0,525,526,1,0,0,0,526,530,1,0,0,
        0,527,528,5,36,0,0,528,530,3,162,81,0,529,520,1,0,0,0,529,522,1,
        0,0,0,529,527,1,0,0,0,530,51,1,0,0,0,531,533,3,16,8,0,532,531,1,
        0,0,0,533,536,1,0,0,0,534,532,1,0,0,0,534,535,1,0,0,0,535,537,1,
        0,0,0,536,534,1,0,0,0,537,538,5,46,0,0,538,539,3,162,81,0,539,540,
        5,84,0,0,540,541,3,164,82,0,541,542,5,77,0,0,542,545,3,164,82,0,
        543,544,5,78,0,0,544,546,5,147,0,0,545,543,1,0,0,0,545,546,1,0,0,
        0,546,547,1,0,0,0,547,551,5,137,0,0,548,550,3,54,27,0,549,548,1,
        0,0,0,550,553,1,0,0,0,551,549,1,0,0,0,551,552,1,0,0,0,552,554,1,
        0,0,0,553,551,1,0,0,0,554,555,5,138,0,0,555,53,1,0,0,0,556,563,3,
        68,34,0,557,563,3,70,35,0,558,563,3,78,39,0,559,563,3,60,30,0,560,
        563,3,62,31,0,561,563,3,56,28,0,562,556,1,0,0,0,562,557,1,0,0,0,
        562,558,1,0,0,0,562,559,1,0,0,0,562,560,1,0,0,0,562,561,1,0,0,0,
        563,55,1,0,0,0,564,565,5,2,0,0,565,566,3,162,81,0,566,567,5,84,0,
        0,567,568,3,164,82,0,568,569,5,38,0,0,569,570,3,26,13,0,570,571,
        5,136,0,0,571,572,3,162,81,0,572,573,5,134,0,0,573,57,1,0,0,0,574,
        575,5,4,0,0,575,576,3,162,81,0,576,577,5,84,0,0,577,578,3,164,82,
        0,578,579,5,6,0,0,579,580,3,26,13,0,580,581,5,65,0,0,581,582,3,162,
        81,0,582,583,5,136,0,0,583,584,3,162,81,0,584,585,5,134,0,0,585,
        59,1,0,0,0,586,588,5,22,0,0,587,589,5,40,0,0,588,587,1,0,0,0,588,
        589,1,0,0,0,589,590,1,0,0,0,590,592,3,162,81,0,591,593,3,22,11,0,
        592,591,1,0,0,0,592,593,1,0,0,0,593,594,1,0,0,0,594,595,5,84,0,0,
        595,596,3,164,82,0,596,598,5,25,0,0,597,599,5,9,0,0,598,597,1,0,
        0,0,598,599,1,0,0,0,599,600,1,0,0,0,600,601,3,26,13,0,601,602,5,
        26,0,0,602,631,3,164,82,0,603,604,5,49,0,0,604,605,3,164,82,0,605,
        609,5,137,0,0,606,608,3,64,32,0,607,606,1,0,0,0,608,611,1,0,0,0,
        609,607,1,0,0,0,609,610,1,0,0,0,610,612,1,0,0,0,611,609,1,0,0,0,
        612,613,5,138,0,0,613,632,1,0,0,0,614,615,5,40,0,0,615,618,3,164,
        82,0,616,617,5,49,0,0,617,619,3,164,82,0,618,616,1,0,0,0,618,619,
        1,0,0,0,619,629,1,0,0,0,620,624,5,137,0,0,621,623,3,64,32,0,622,
        621,1,0,0,0,623,626,1,0,0,0,624,622,1,0,0,0,624,625,1,0,0,0,625,
        627,1,0,0,0,626,624,1,0,0,0,627,630,5,138,0,0,628,630,5,134,0,0,
        629,620,1,0,0,0,629,628,1,0,0,0,630,632,1,0,0,0,631,603,1,0,0,0,
        631,614,1,0,0,0,632,61,1,0,0,0,633,634,5,22,0,0,634,635,3,162,81,
        0,635,636,5,84,0,0,636,637,3,164,82,0,637,638,5,24,0,0,638,639,3,
        162,81,0,639,640,3,28,14,0,640,641,5,134,0,0,641,63,1,0,0,0,642,
        643,5,16,0,0,643,700,5,134,0,0,644,645,5,17,0,0,645,646,5,18,0,0,
        646,647,3,162,81,0,647,648,5,134,0,0,648,700,1,0,0,0,649,650,5,27,
        0,0,650,651,3,164,82,0,651,652,5,134,0,0,652,700,1,0,0,0,653,654,
        5,27,0,0,654,655,3,162,81,0,655,656,5,136,0,0,656,666,3,162,81,0,
        657,658,5,64,0,0,658,662,5,137,0,0,659,661,3,66,33,0,660,659,1,0,
        0,0,661,664,1,0,0,0,662,660,1,0,0,0,662,663,1,0,0,0,663,665,1,0,
        0,0,664,662,1,0,0,0,665,667,5,138,0,0,666,657,1,0,0,0,666,667,1,
        0,0,0,667,668,1,0,0,0,668,669,5,134,0,0,669,700,1,0,0,0,670,672,
        5,28,0,0,671,673,5,36,0,0,672,671,1,0,0,0,672,673,1,0,0,0,673,674,
        1,0,0,0,674,675,3,162,81,0,675,676,5,55,0,0,676,677,3,26,13,0,677,
        678,5,134,0,0,678,700,1,0,0,0,679,680,5,29,0,0,680,681,3,162,81,
        0,681,682,5,147,0,0,682,683,5,134,0,0,683,700,1,0,0,0,684,685,5,
        30,0,0,685,686,3,26,13,0,686,687,5,136,0,0,687,688,3,162,81,0,688,
        689,3,162,81,0,689,690,3,164,82,0,690,691,5,134,0,0,691,700,1,0,
        0,0,692,693,5,93,0,0,693,700,5,134,0,0,694,695,5,31,0,0,695,696,
        5,147,0,0,696,697,3,164,82,0,697,698,5,134,0,0,698,700,1,0,0,0,699,
        642,1,0,0,0,699,644,1,0,0,0,699,649,1,0,0,0,699,653,1,0,0,0,699,
        670,1,0,0,0,699,679,1,0,0,0,699,684,1,0,0,0,699,692,1,0,0,0,699,
        694,1,0,0,0,700,65,1,0,0,0,701,702,3,162,81,0,702,703,5,58,0,0,703,
        704,3,162,81,0,704,705,5,134,0,0,705,67,1,0,0,0,706,707,5,49,0,0,
        707,709,3,162,81,0,708,710,3,22,11,0,709,708,1,0,0,0,709,710,1,0,
        0,0,710,711,1,0,0,0,711,712,5,84,0,0,712,713,3,164,82,0,713,714,
        5,133,0,0,714,715,3,146,73,0,715,716,5,132,0,0,716,717,3,146,73,
        0,717,718,5,86,0,0,718,720,3,82,41,0,719,721,3,74,37,0,720,719,1,
        0,0,0,720,721,1,0,0,0,721,723,1,0,0,0,722,724,3,80,40,0,723,722,
        1,0,0,0,723,724,1,0,0,0,724,725,1,0,0,0,725,726,5,88,0,0,726,728,
        3,84,42,0,727,729,3,88,44,0,728,727,1,0,0,0,728,729,1,0,0,0,729,
        731,1,0,0,0,730,732,3,72,36,0,731,730,1,0,0,0,731,732,1,0,0,0,732,
        733,1,0,0,0,733,734,5,134,0,0,734,69,1,0,0,0,735,736,5,50,0,0,736,
        738,3,162,81,0,737,739,3,22,11,0,738,737,1,0,0,0,738,739,1,0,0,0,
        739,740,1,0,0,0,740,741,5,84,0,0,741,742,3,164,82,0,742,743,5,133,
        0,0,743,744,3,146,73,0,744,745,5,132,0,0,745,747,3,146,73,0,746,
        748,3,74,37,0,747,746,1,0,0,0,747,748,1,0,0,0,748,750,1,0,0,0,749,
        751,3,88,44,0,750,749,1,0,0,0,750,751,1,0,0,0,751,753,1,0,0,0,752,
        754,3,72,36,0,753,752,1,0,0,0,753,754,1,0,0,0,754,755,1,0,0,0,755,
        756,5,134,0,0,756,71,1,0,0,0,757,758,5,66,0,0,758,759,5,65,0,0,759,
        760,3,162,81,0,760,73,1,0,0,0,761,762,5,10,0,0,762,771,5,13,0,0,
        763,764,5,10,0,0,764,765,7,1,0,0,765,766,5,14,0,0,766,767,5,139,
        0,0,767,768,3,86,43,0,768,769,5,140,0,0,769,771,1,0,0,0,770,761,
        1,0,0,0,770,763,1,0,0,0,771,75,1,0,0,0,772,773,5,65,0,0,773,774,
        5,139,0,0,774,779,3,128,64,0,775,776,5,135,0,0,776,778,3,128,64,
        0,777,775,1,0,0,0,778,781,1,0,0,0,779,777,1,0,0,0,779,780,1,0,0,
        0,780,782,1,0,0,0,781,779,1,0,0,0,782,783,5,140,0,0,783,77,1,0,0,
        0,784,785,5,51,0,0,785,786,3,162,81,0,786,787,5,84,0,0,787,788,3,
        164,82,0,788,789,5,52,0,0,789,790,3,162,81,0,790,791,5,133,0,0,791,
        793,3,146,73,0,792,794,3,88,44,0,793,792,1,0,0,0,793,794,1,0,0,0,
        794,795,1,0,0,0,795,796,5,134,0,0,796,79,1,0,0,0,797,798,5,87,0,
        0,798,799,3,146,73,0,799,81,1,0,0,0,800,801,7,2,0,0,801,83,1,0,0,
        0,802,821,5,90,0,0,803,804,5,43,0,0,804,821,3,162,81,0,805,806,5,
        36,0,0,806,821,3,162,81,0,807,808,5,45,0,0,808,817,5,139,0,0,809,
        814,3,26,13,0,810,811,5,135,0,0,811,813,3,26,13,0,812,810,1,0,0,
        0,813,816,1,0,0,0,814,812,1,0,0,0,814,815,1,0,0,0,815,818,1,0,0,
        0,816,814,1,0,0,0,817,809,1,0,0,0,817,818,1,0,0,0,818,819,1,0,0,
        0,819,821,5,140,0,0,820,802,1,0,0,0,820,803,1,0,0,0,820,805,1,0,
        0,0,820,807,1,0,0,0,821,85,1,0,0,0,822,827,3,162,81,0,823,824,5,
        135,0,0,824,826,3,162,81,0,825,823,1,0,0,0,826,829,1,0,0,0,827,825,
        1,0,0,0,827,828,1,0,0,0,828,87,1,0,0,0,829,827,1,0,0,0,830,831,5,
        89,0,0,831,835,5,137,0,0,832,834,3,90,45,0,833,832,1,0,0,0,834,837,
        1,0,0,0,835,833,1,0,0,0,835,836,1,0,0,0,836,838,1,0,0,0,837,835,
        1,0,0,0,838,839,5,138,0,0,839,89,1,0,0,0,840,841,5,23,0,0,841,842,
        3,162,81,0,842,843,5,84,0,0,843,844,3,164,82,0,844,845,5,139,0,0,
        845,846,3,86,43,0,846,847,5,140,0,0,847,848,5,134,0,0,848,919,1,
        0,0,0,849,850,5,61,0,0,850,851,3,162,81,0,851,852,5,84,0,0,852,853,
        3,164,82,0,853,854,5,133,0,0,854,855,3,146,73,0,855,856,3,92,46,
        0,856,857,5,134,0,0,857,919,1,0,0,0,858,859,5,62,0,0,859,860,3,162,
        81,0,860,861,5,84,0,0,861,862,3,164,82,0,862,863,5,133,0,0,863,864,
        3,152,76,0,864,865,3,50,25,0,865,866,3,92,46,0,866,867,5,134,0,0,
        867,919,1,0,0,0,868,869,5,44,0,0,869,870,3,162,81,0,870,871,5,84,
        0,0,871,872,3,164,82,0,872,873,5,133,0,0,873,875,3,162,81,0,874,
        876,3,28,14,0,875,874,1,0,0,0,875,876,1,0,0,0,876,878,1,0,0,0,877,
        879,3,76,38,0,878,877,1,0,0,0,878,879,1,0,0,0,879,882,1,0,0,0,880,
        881,5,18,0,0,881,883,5,53,0,0,882,880,1,0,0,0,882,883,1,0,0,0,883,
        884,1,0,0,0,884,885,5,134,0,0,885,919,1,0,0,0,886,887,5,7,0,0,887,
        888,3,162,81,0,888,889,5,84,0,0,889,890,3,164,82,0,890,891,5,133,
        0,0,891,892,3,162,81,0,892,893,5,53,0,0,893,894,3,146,73,0,894,895,
        5,134,0,0,895,919,1,0,0,0,896,897,5,51,0,0,897,898,3,162,81,0,898,
        899,5,84,0,0,899,900,3,164,82,0,900,901,5,133,0,0,901,904,3,162,
        81,0,902,903,5,53,0,0,903,905,3,146,73,0,904,902,1,0,0,0,904,905,
        1,0,0,0,905,906,1,0,0,0,906,907,5,134,0,0,907,919,1,0,0,0,908,909,
        5,22,0,0,909,910,3,162,81,0,910,911,5,84,0,0,911,912,3,164,82,0,
        912,913,5,133,0,0,913,914,3,162,81,0,914,915,5,136,0,0,915,916,3,
        162,81,0,916,917,5,134,0,0,917,919,1,0,0,0,918,840,1,0,0,0,918,849,
        1,0,0,0,918,858,1,0,0,0,918,868,1,0,0,0,918,886,1,0,0,0,918,896,
        1,0,0,0,918,908,1,0,0,0,919,91,1,0,0,0,920,921,5,139,0,0,921,926,
        3,94,47,0,922,923,5,135,0,0,923,925,3,94,47,0,924,922,1,0,0,0,925,
        928,1,0,0,0,926,924,1,0,0,0,926,927,1,0,0,0,927,929,1,0,0,0,928,
        926,1,0,0,0,929,930,5,140,0,0,930,93,1,0,0,0,931,932,7,3,0,0,932,
        95,1,0,0,0,933,934,5,60,0,0,934,935,3,98,49,0,935,97,1,0,0,0,936,
        939,3,100,50,0,937,939,3,104,52,0,938,936,1,0,0,0,938,937,1,0,0,
        0,939,99,1,0,0,0,940,941,5,61,0,0,941,942,3,162,81,0,942,943,5,84,
        0,0,943,944,3,164,82,0,944,945,5,71,0,0,945,946,3,162,81,0,946,947,
        5,133,0,0,947,948,3,146,73,0,948,949,5,72,0,0,949,952,3,102,51,0,
        950,951,5,73,0,0,951,953,3,154,77,0,952,950,1,0,0,0,952,953,1,0,
        0,0,953,954,1,0,0,0,954,955,5,134,0,0,955,101,1,0,0,0,956,963,5,
        106,0,0,957,958,5,107,0,0,958,959,5,141,0,0,959,960,3,146,73,0,960,
        961,5,142,0,0,961,963,1,0,0,0,962,956,1,0,0,0,962,957,1,0,0,0,963,
        103,1,0,0,0,964,965,5,62,0,0,965,966,3,162,81,0,966,967,5,84,0,0,
        967,968,3,164,82,0,968,969,5,137,0,0,969,970,3,106,53,0,970,971,
        3,106,53,0,971,972,5,138,0,0,972,105,1,0,0,0,973,974,3,50,25,0,974,
        975,5,63,0,0,975,976,3,162,81,0,976,977,5,84,0,0,977,978,3,164,82,
        0,978,980,3,152,76,0,979,981,5,112,0,0,980,979,1,0,0,0,980,981,1,
        0,0,0,981,984,1,0,0,0,982,983,5,79,0,0,983,985,3,164,82,0,984,982,
        1,0,0,0,984,985,1,0,0,0,985,987,1,0,0,0,986,988,5,81,0,0,987,986,
        1,0,0,0,987,988,1,0,0,0,988,991,1,0,0,0,989,990,5,82,0,0,990,992,
        3,164,82,0,991,989,1,0,0,0,991,992,1,0,0,0,992,994,1,0,0,0,993,995,
        5,83,0,0,994,993,1,0,0,0,994,995,1,0,0,0,995,996,1,0,0,0,996,997,
        5,134,0,0,997,107,1,0,0,0,998,1000,5,54,0,0,999,1001,3,22,11,0,1000,
        999,1,0,0,0,1000,1001,1,0,0,0,1001,1002,1,0,0,0,1002,1004,3,162,
        81,0,1003,1005,3,110,55,0,1004,1003,1,0,0,0,1004,1005,1,0,0,0,1005,
        1006,1,0,0,0,1006,1007,5,55,0,0,1007,1009,3,162,81,0,1008,1010,3,
        28,14,0,1009,1008,1,0,0,0,1009,1010,1,0,0,0,1010,1013,1,0,0,0,1011,
        1012,5,84,0,0,1012,1014,3,164,82,0,1013,1011,1,0,0,0,1013,1014,1,
        0,0,0,1014,1017,1,0,0,0,1015,1016,5,78,0,0,1016,1018,5,147,0,0,1017,
        1015,1,0,0,0,1017,1018,1,0,0,0,1018,1019,1,0,0,0,1019,1023,5,137,
        0,0,1020,1022,3,112,56,0,1021,1020,1,0,0,0,1022,1025,1,0,0,0,1023,
        1021,1,0,0,0,1023,1024,1,0,0,0,1024,1026,1,0,0,0,1025,1023,1,0,0,
        0,1026,1027,5,138,0,0,1027,109,1,0,0,0,1028,1029,3,28,14,0,1029,
        111,1,0,0,0,1030,1031,5,59,0,0,1031,1038,3,98,49,0,1032,1038,3,126,
        63,0,1033,1038,3,122,61,0,1034,1038,3,116,58,0,1035,1038,3,124,62,
        0,1036,1038,3,114,57,0,1037,1030,1,0,0,0,1037,1032,1,0,0,0,1037,
        1033,1,0,0,0,1037,1034,1,0,0,0,1037,1035,1,0,0,0,1037,1036,1,0,0,
        0,1038,113,1,0,0,0,1039,1040,5,56,0,0,1040,1041,3,162,81,0,1041,
        1042,5,58,0,0,1042,1043,3,162,81,0,1043,1044,5,136,0,0,1044,1045,
        3,162,81,0,1045,1046,5,134,0,0,1046,115,1,0,0,0,1047,1048,5,8,0,
        0,1048,1052,5,137,0,0,1049,1051,3,118,59,0,1050,1049,1,0,0,0,1051,
        1054,1,0,0,0,1052,1050,1,0,0,0,1052,1053,1,0,0,0,1053,1055,1,0,0,
        0,1054,1052,1,0,0,0,1055,1056,5,138,0,0,1056,1057,5,134,0,0,1057,
        117,1,0,0,0,1058,1059,3,162,81,0,1059,1060,5,58,0,0,1060,1061,5,
        61,0,0,1061,1062,3,162,81,0,1062,1063,5,134,0,0,1063,1073,1,0,0,
        0,1064,1065,3,162,81,0,1065,1066,5,58,0,0,1066,1067,5,62,0,0,1067,
        1068,3,162,81,0,1068,1069,5,136,0,0,1069,1070,3,162,81,0,1070,1071,
        5,134,0,0,1071,1073,1,0,0,0,1072,1058,1,0,0,0,1072,1064,1,0,0,0,
        1073,119,1,0,0,0,1074,1075,3,26,13,0,1075,1076,5,18,0,0,1076,1081,
        5,53,0,0,1077,1078,5,136,0,0,1078,1080,3,162,81,0,1079,1077,1,0,
        0,0,1080,1083,1,0,0,0,1081,1079,1,0,0,0,1081,1082,1,0,0,0,1082,1084,
        1,0,0,0,1083,1081,1,0,0,0,1084,1085,5,134,0,0,1085,121,1,0,0,0,1086,
        1087,5,56,0,0,1087,1088,3,162,81,0,1088,1089,5,58,0,0,1089,1090,
        5,61,0,0,1090,1091,3,162,81,0,1091,1092,5,134,0,0,1092,123,1,0,0,
        0,1093,1094,5,68,0,0,1094,1095,3,162,81,0,1095,1096,5,69,0,0,1096,
        1097,5,70,0,0,1097,1098,5,65,0,0,1098,1099,5,51,0,0,1099,1100,3,
        162,81,0,1100,1101,5,67,0,0,1101,1102,5,62,0,0,1102,1103,3,162,81,
        0,1103,1104,5,136,0,0,1104,1105,3,162,81,0,1105,1106,5,134,0,0,1106,
        125,1,0,0,0,1107,1108,5,56,0,0,1108,1109,3,128,64,0,1109,1110,5,
        58,0,0,1110,1113,3,132,66,0,1111,1112,5,34,0,0,1112,1114,3,164,82,
        0,1113,1111,1,0,0,0,1113,1114,1,0,0,0,1114,1115,1,0,0,0,1115,1116,
        5,134,0,0,1116,127,1,0,0,0,1117,1118,3,162,81,0,1118,1119,5,136,
        0,0,1119,1120,3,130,65,0,1120,129,1,0,0,0,1121,1134,3,162,81,0,1122,
        1134,5,101,0,0,1123,1134,5,91,0,0,1124,1134,5,92,0,0,1125,1134,5,
        1,0,0,1126,1134,5,98,0,0,1127,1134,5,99,0,0,1128,1134,5,100,0,0,
        1129,1134,5,102,0,0,1130,1134,5,103,0,0,1131,1134,5,104,0,0,1132,
        1134,5,105,0,0,1133,1121,1,0,0,0,1133,1122,1,0,0,0,1133,1123,1,0,
        0,0,1133,1124,1,0,0,0,1133,1125,1,0,0,0,1133,1126,1,0,0,0,1133,1127,
        1,0,0,0,1133,1128,1,0,0,0,1133,1129,1,0,0,0,1133,1130,1,0,0,0,1133,
        1131,1,0,0,0,1133,1132,1,0,0,0,1134,131,1,0,0,0,1135,1136,5,80,0,
        0,1136,1137,5,136,0,0,1137,1172,3,162,81,0,1138,1139,5,61,0,0,1139,
        1140,3,162,81,0,1140,1141,5,136,0,0,1141,1142,3,136,68,0,1142,1172,
        1,0,0,0,1143,1144,5,62,0,0,1144,1145,3,162,81,0,1145,1146,5,136,
        0,0,1146,1147,3,162,81,0,1147,1148,5,136,0,0,1148,1149,3,138,69,
        0,1149,1172,1,0,0,0,1150,1151,5,44,0,0,1151,1153,3,162,81,0,1152,
        1154,3,28,14,0,1153,1152,1,0,0,0,1153,1154,1,0,0,0,1154,1155,1,0,
        0,0,1155,1156,5,136,0,0,1156,1157,3,128,64,0,1157,1172,1,0,0,0,1158,
        1159,5,46,0,0,1159,1160,3,162,81,0,1160,1161,5,136,0,0,1161,1163,
        3,162,81,0,1162,1164,3,28,14,0,1163,1162,1,0,0,0,1163,1164,1,0,0,
        0,1164,1166,1,0,0,0,1165,1167,3,140,70,0,1166,1165,1,0,0,0,1166,
        1167,1,0,0,0,1167,1169,1,0,0,0,1168,1170,3,134,67,0,1169,1168,1,
        0,0,0,1169,1170,1,0,0,0,1170,1172,1,0,0,0,1171,1135,1,0,0,0,1171,
        1138,1,0,0,0,1171,1143,1,0,0,0,1171,1150,1,0,0,0,1171,1158,1,0,0,
        0,1172,133,1,0,0,0,1173,1174,5,66,0,0,1174,1175,3,140,70,0,1175,
        135,1,0,0,0,1176,1177,7,4,0,0,1177,137,1,0,0,0,1178,1179,7,5,0,0,
        1179,139,1,0,0,0,1180,1181,5,64,0,0,1181,1185,5,137,0,0,1182,1184,
        3,142,71,0,1183,1182,1,0,0,0,1184,1187,1,0,0,0,1185,1183,1,0,0,0,
        1185,1186,1,0,0,0,1186,1188,1,0,0,0,1187,1185,1,0,0,0,1188,1189,
        5,138,0,0,1189,141,1,0,0,0,1190,1191,3,162,81,0,1191,1192,5,58,0,
        0,1192,1193,5,9,0,0,1193,1194,5,23,0,0,1194,1195,5,139,0,0,1195,
        1196,3,86,43,0,1196,1197,5,140,0,0,1197,1198,5,134,0,0,1198,1289,
        1,0,0,0,1199,1200,3,162,81,0,1200,1201,5,58,0,0,1201,1202,5,61,0,
        0,1202,1209,3,162,81,0,1203,1204,5,67,0,0,1204,1205,5,62,0,0,1205,
        1206,3,162,81,0,1206,1207,5,136,0,0,1207,1208,3,162,81,0,1208,1210,
        1,0,0,0,1209,1203,1,0,0,0,1209,1210,1,0,0,0,1210,1211,1,0,0,0,1211,
        1212,5,134,0,0,1212,1289,1,0,0,0,1213,1214,3,162,81,0,1214,1215,
        5,58,0,0,1215,1216,5,62,0,0,1216,1217,3,162,81,0,1217,1218,5,136,
        0,0,1218,1225,3,162,81,0,1219,1220,5,67,0,0,1220,1221,5,62,0,0,1221,
        1222,3,162,81,0,1222,1223,5,136,0,0,1223,1224,3,162,81,0,1224,1226,
        1,0,0,0,1225,1219,1,0,0,0,1225,1226,1,0,0,0,1226,1227,1,0,0,0,1227,
        1228,5,134,0,0,1228,1289,1,0,0,0,1229,1230,3,162,81,0,1230,1231,
        5,58,0,0,1231,1232,5,44,0,0,1232,1234,3,162,81,0,1233,1235,3,28,
        14,0,1234,1233,1,0,0,0,1234,1235,1,0,0,0,1235,1244,1,0,0,0,1236,
        1237,5,67,0,0,1237,1238,5,62,0,0,1238,1239,3,162,81,0,1239,1240,
        5,136,0,0,1240,1241,3,162,81,0,1241,1245,1,0,0,0,1242,1243,5,18,
        0,0,1243,1245,5,53,0,0,1244,1236,1,0,0,0,1244,1242,1,0,0,0,1244,
        1245,1,0,0,0,1245,1246,1,0,0,0,1246,1247,5,134,0,0,1247,1289,1,0,
        0,0,1248,1249,3,162,81,0,1249,1250,5,58,0,0,1250,1251,5,7,0,0,1251,
        1252,3,162,81,0,1252,1253,5,64,0,0,1253,1257,5,137,0,0,1254,1256,
        3,120,60,0,1255,1254,1,0,0,0,1256,1259,1,0,0,0,1257,1255,1,0,0,0,
        1257,1258,1,0,0,0,1258,1260,1,0,0,0,1259,1257,1,0,0,0,1260,1261,
        5,138,0,0,1261,1262,5,134,0,0,1262,1289,1,0,0,0,1263,1264,3,162,
        81,0,1264,1265,5,58,0,0,1265,1266,5,51,0,0,1266,1267,3,162,81,0,
        1267,1268,5,134,0,0,1268,1289,1,0,0,0,1269,1270,3,162,81,0,1270,
        1272,5,58,0,0,1271,1273,5,9,0,0,1272,1271,1,0,0,0,1272,1273,1,0,
        0,0,1273,1274,1,0,0,0,1274,1275,5,22,0,0,1275,1276,3,162,81,0,1276,
        1277,5,136,0,0,1277,1284,3,162,81,0,1278,1279,5,67,0,0,1279,1280,
        5,62,0,0,1280,1281,3,162,81,0,1281,1282,5,136,0,0,1282,1283,3,162,
        81,0,1283,1285,1,0,0,0,1284,1278,1,0,0,0,1284,1285,1,0,0,0,1285,
        1286,1,0,0,0,1286,1287,5,134,0,0,1287,1289,1,0,0,0,1288,1190,1,0,
        0,0,1288,1199,1,0,0,0,1288,1213,1,0,0,0,1288,1229,1,0,0,0,1288,1248,
        1,0,0,0,1288,1263,1,0,0,0,1288,1269,1,0,0,0,1289,143,1,0,0,0,1290,
        1291,5,51,0,0,1291,1292,3,162,81,0,1292,1293,5,58,0,0,1293,1294,
        3,162,81,0,1294,1295,5,136,0,0,1295,1297,3,162,81,0,1296,1298,3,
        140,70,0,1297,1296,1,0,0,0,1297,1298,1,0,0,0,1298,1299,1,0,0,0,1299,
        1300,5,134,0,0,1300,145,1,0,0,0,1301,1348,3,150,75,0,1302,1348,5,
        113,0,0,1303,1348,5,114,0,0,1304,1305,5,115,0,0,1305,1348,3,164,
        82,0,1306,1307,5,116,0,0,1307,1308,5,143,0,0,1308,1309,3,162,81,
        0,1309,1310,5,144,0,0,1310,1348,1,0,0,0,1311,1312,5,117,0,0,1312,
        1313,5,143,0,0,1313,1315,3,162,81,0,1314,1316,3,28,14,0,1315,1314,
        1,0,0,0,1315,1316,1,0,0,0,1316,1317,1,0,0,0,1317,1318,5,144,0,0,
        1318,1348,1,0,0,0,1319,1320,5,39,0,0,1320,1321,5,143,0,0,1321,1322,
        3,162,81,0,1322,1323,5,144,0,0,1323,1348,1,0,0,0,1324,1325,5,118,
        0,0,1325,1326,5,143,0,0,1326,1327,3,146,73,0,1327,1328,5,144,0,0,
        1328,1348,1,0,0,0,1329,1330,5,119,0,0,1330,1331,5,143,0,0,1331,1332,
        3,146,73,0,1332,1333,5,144,0,0,1333,1348,1,0,0,0,1334,1335,5,120,
        0,0,1335,1339,5,137,0,0,1336,1338,3,148,74,0,1337,1336,1,0,0,0,1338,
        1341,1,0,0,0,1339,1337,1,0,0,0,1339,1340,1,0,0,0,1340,1342,1,0,0,
        0,1341,1339,1,0,0,0,1342,1348,5,138,0,0,1343,1345,3,162,81,0,1344,
        1346,3,28,14,0,1345,1344,1,0,0,0,1345,1346,1,0,0,0,1346,1348,1,0,
        0,0,1347,1301,1,0,0,0,1347,1302,1,0,0,0,1347,1303,1,0,0,0,1347,1304,
        1,0,0,0,1347,1306,1,0,0,0,1347,1311,1,0,0,0,1347,1319,1,0,0,0,1347,
        1324,1,0,0,0,1347,1329,1,0,0,0,1347,1334,1,0,0,0,1347,1343,1,0,0,
        0,1348,147,1,0,0,0,1349,1350,3,162,81,0,1350,1351,5,133,0,0,1351,
        1352,3,146,73,0,1352,1353,5,134,0,0,1353,149,1,0,0,0,1354,1355,7,
        6,0,0,1355,151,1,0,0,0,1356,1357,7,7,0,0,1357,153,1,0,0,0,1358,1367,
        3,164,82,0,1359,1367,5,147,0,0,1360,1367,5,148,0,0,1361,1367,5,129,
        0,0,1362,1367,5,130,0,0,1363,1367,5,131,0,0,1364,1367,3,156,78,0,
        1365,1367,3,160,80,0,1366,1358,1,0,0,0,1366,1359,1,0,0,0,1366,1360,
        1,0,0,0,1366,1361,1,0,0,0,1366,1362,1,0,0,0,1366,1363,1,0,0,0,1366,
        1364,1,0,0,0,1366,1365,1,0,0,0,1367,155,1,0,0,0,1368,1377,5,137,
        0,0,1369,1374,3,158,79,0,1370,1371,5,135,0,0,1371,1373,3,158,79,
        0,1372,1370,1,0,0,0,1373,1376,1,0,0,0,1374,1372,1,0,0,0,1374,1375,
        1,0,0,0,1375,1378,1,0,0,0,1376,1374,1,0,0,0,1377,1369,1,0,0,0,1377,
        1378,1,0,0,0,1378,1379,1,0,0,0,1379,1380,5,138,0,0,1380,157,1,0,
        0,0,1381,1382,3,164,82,0,1382,1383,5,133,0,0,1383,1384,3,154,77,
        0,1384,159,1,0,0,0,1385,1394,5,139,0,0,1386,1391,3,154,77,0,1387,
        1388,5,135,0,0,1388,1390,3,154,77,0,1389,1387,1,0,0,0,1390,1393,
        1,0,0,0,1391,1389,1,0,0,0,1391,1392,1,0,0,0,1392,1395,1,0,0,0,1393,
        1391,1,0,0,0,1394,1386,1,0,0,0,1394,1395,1,0,0,0,1395,1396,1,0,0,
        0,1396,1397,5,140,0,0,1397,161,1,0,0,0,1398,1399,7,8,0,0,1399,163,
        1,0,0,0,1400,1401,5,150,0,0,1401,165,1,0,0,0,125,178,185,206,219,
        231,251,259,266,272,284,287,293,304,313,323,326,328,332,340,352,
        357,367,377,382,397,403,415,424,432,440,453,456,466,470,476,483,
        489,497,505,518,525,529,534,545,551,562,588,592,598,609,618,624,
        629,631,662,666,672,699,709,720,723,728,731,738,747,750,753,770,
        779,793,814,817,820,827,835,875,878,882,904,918,926,938,952,962,
        980,984,987,991,994,1000,1004,1009,1013,1017,1023,1037,1052,1072,
        1081,1113,1133,1153,1163,1166,1169,1171,1185,1209,1225,1234,1244,
        1257,1272,1284,1288,1297,1315,1339,1345,1347,1366,1374,1377,1391,
        1394
    ];

    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 | null {
        return this.getRuleContext(0, WorkspaceDeclContext);
    }
    public EOF(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EOF, 0)!;
    }
    public interfaceResourceDecl(): InterfaceResourceDeclContext | null {
        return this.getRuleContext(0, InterfaceResourceDeclContext);
    }
    public packageResourceDecl(): PackageResourceDeclContext | null {
        return this.getRuleContext(0, PackageResourceDeclContext);
    }
    public fragmentDecl(): FragmentDeclContext | null {
        return this.getRuleContext(0, FragmentDeclContext);
    }
    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 FragmentDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public FRAGMENT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.FRAGMENT, 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_fragmentDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitFragmentDecl) {
            return visitor.visitFragmentDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class SourceImportDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public IMPORT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.IMPORT, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_sourceImportDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitSourceImportDecl) {
            return visitor.visitSourceImportDecl(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 sourceImportDecl(): SourceImportDeclContext | null {
        return this.getRuleContext(0, SourceImportDeclContext);
    }
    public atomDecl(): AtomDeclContext | null {
        return this.getRuleContext(0, AtomDeclContext);
    }
    public resourceImportDecl(): ResourceImportDeclContext | null {
        return this.getRuleContext(0, ResourceImportDeclContext);
    }
    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 presentationDecl(): PresentationDeclContext | null {
        return this.getRuleContext(0, PresentationDeclContext);
    }
    public typeAliasDecl(): TypeAliasDeclContext | null {
        return this.getRuleContext(0, TypeAliasDeclContext);
    }
    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 ResourceImportDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public IMPORT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.IMPORT, 0)!;
    }
    public INTERFACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public PACKAGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PACKAGE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_resourceImportDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitResourceImportDecl) {
            return visitor.visitResourceImportDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ExternalAtomDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EXTERNAL(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EXTERNAL, 0)!;
    }
    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 {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_externalAtomDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitExternalAtomDecl) {
            return visitor.visitExternalAtomDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ExternalInterfaceDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EXTERNAL(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EXTERNAL, 0)!;
    }
    public INTERFACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public REVISION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_externalInterfaceDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitExternalInterfaceDecl) {
            return visitor.visitExternalInterfaceDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ResourcePreambleContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public resourceImportDecl(): ResourceImportDeclContext | null {
        return this.getRuleContext(0, ResourceImportDeclContext);
    }
    public externalAtomDecl(): ExternalAtomDeclContext | null {
        return this.getRuleContext(0, ExternalAtomDeclContext);
    }
    public externalInterfaceDecl(): ExternalInterfaceDeclContext | null {
        return this.getRuleContext(0, ExternalInterfaceDeclContext);
    }
    public typeAliasDecl(): TypeAliasDeclContext | null {
        return this.getRuleContext(0, TypeAliasDeclContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_resourcePreamble;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitResourcePreamble) {
            return visitor.visitResourcePreamble(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 InterfaceResourceDeclContext 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 LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public resourcePreamble(): ResourcePreambleContext[];
    public resourcePreamble(i: number): ResourcePreambleContext | null;
    public resourcePreamble(i?: number): ResourcePreambleContext[] | ResourcePreambleContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ResourcePreambleContext);
        }

        return this.getRuleContext(i, ResourcePreambleContext);
    }
    public typeParameters(): TypeParametersContext | null {
        return this.getRuleContext(0, TypeParametersContext);
    }
    public REQUIRES(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REQUIRES, 0);
    }
    public interfaceType(): InterfaceTypeContext[];
    public interfaceType(i: number): InterfaceTypeContext | null;
    public interfaceType(i?: number): InterfaceTypeContext[] | InterfaceTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(InterfaceTypeContext);
        }

        return this.getRuleContext(i, InterfaceTypeContext);
    }
    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 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_interfaceResourceDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitInterfaceResourceDecl) {
            return visitor.visitInterfaceResourceDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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

        return this.getRuleContext(i, TypeParameterContext);
    }
    public GT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.GT, 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_typeParameters;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitTypeParameters) {
            return visitor.visitTypeParameters(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class TypeParameterContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public VALUE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.VALUE, 0);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public COLON(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.COLON, 0);
    }
    public STORABLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STORABLE, 0);
    }
    public OBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OBJECT, 0);
    }
    public IMPLEMENTS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.IMPLEMENTS, 0);
    }
    public interfaceType(): InterfaceTypeContext[];
    public interfaceType(i: number): InterfaceTypeContext | null;
    public interfaceType(i?: number): InterfaceTypeContext[] | InterfaceTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(InterfaceTypeContext);
        }

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


export class InterfaceTypeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_interfaceType;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitInterfaceType) {
            return visitor.visitInterfaceType(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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

        return this.getRuleContext(i, TypeArgumentContext);
    }
    public GT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.GT, 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_typeArguments;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitTypeArguments) {
            return visitor.visitTypeArguments(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class TypeArgumentContext 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 | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public INTERFACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
    }
    public interfaceType(): InterfaceTypeContext | null {
        return this.getRuleContext(0, InterfaceTypeContext);
    }
    public OBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OBJECT, 0);
    }
    public valueType(): ValueTypeContext | null {
        return this.getRuleContext(0, ValueTypeContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_typeArgument;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitTypeArgument) {
            return visitor.visitTypeArgument(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class TypeAliasDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public TYPE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.TYPE, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public EQUAL(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EQUAL, 0)!;
    }
    public valueType(): ValueTypeContext {
        return this.getRuleContext(0, ValueTypeContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public typeParameters(): TypeParametersContext | null {
        return this.getRuleContext(0, TypeParametersContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_typeAliasDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitTypeAliasDecl) {
            return visitor.visitTypeAliasDecl(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 moduleMember(): ModuleMemberContext | null {
        return this.getRuleContext(0, ModuleMemberContext);
    }
    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 ModuleMemberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public MODULE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.MODULE, 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 CONTRACT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.CONTRACT, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public SUBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SUBJECT, 0);
    }
    public targetConstraint(): TargetConstraintContext | null {
        return this.getRuleContext(0, TargetConstraintContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_moduleMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitModuleMember) {
            return visitor.visitModuleMember(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 STATIC(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATIC, 0);
    }
    public executionClause(): ExecutionClauseContext | null {
        return this.getRuleContext(0, ExecutionClauseContext);
    }
    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 queryReadContract(): QueryReadContractContext | null {
        return this.getRuleContext(0, QueryReadContractContext);
    }
    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 executionClause(): ExecutionClauseContext | null {
        return this.getRuleContext(0, ExecutionClauseContext);
    }
    public SET(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SET, 0);
    }
    public EDIT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDIT, 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[];
    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 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 queryReadContract(): QueryReadContractContext | null {
        return this.getRuleContext(0, QueryReadContractContext);
    }
    public ORDERED(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ORDERED, 0);
    }
    public KEYED(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.KEYED, 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 QueryReadContractContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public QUERYABLE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.QUERYABLE, 0)!;
    }
    public RPC(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RPC, 0);
    }
    public PORTABLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PORTABLE, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_queryReadContract;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitQueryReadContract) {
            return visitor.visitQueryReadContract(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 executionClause(): ExecutionClauseContext | null {
        return this.getRuleContext(0, ExecutionClauseContext);
    }
    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 typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public OBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OBJECT, 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 PackageResourceDeclContext 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 LBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
    }
    public resourcePreamble(): ResourcePreambleContext[];
    public resourcePreamble(i: number): ResourcePreambleContext | null;
    public resourcePreamble(i?: number): ResourcePreambleContext[] | ResourcePreambleContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ResourcePreambleContext);
        }

        return this.getRuleContext(i, ResourcePreambleContext);
    }
    public SEMANTIC_MAJOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SEMANTIC_MAJOR, 0);
    }
    public INTEGER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTEGER, 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_packageResourceDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageResourceDecl) {
            return visitor.visitPackageResourceDecl(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 packageQuery(): PackageQueryContext | null {
        return this.getRuleContext(0, PackageQueryContext);
    }
    public packageQuerySpecialization(): PackageQuerySpecializationContext | null {
        return this.getRuleContext(0, PackageQuerySpecializationContext);
    }
    public moduleExport(): ModuleExportContext | null {
        return this.getRuleContext(0, ModuleExportContext);
    }
    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 ModuleExportContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public MODULE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.MODULE, 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 IMPLEMENTS(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.IMPLEMENTS, 0)!;
    }
    public interfaceType(): InterfaceTypeContext {
        return this.getRuleContext(0, InterfaceTypeContext)!;
    }
    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_moduleExport;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitModuleExport) {
            return visitor.visitModuleExport(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PresentationDeclContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public PRESENTATION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.PRESENTATION, 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 FOR(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.FOR, 0)!;
    }
    public interfaceType(): InterfaceTypeContext {
        return this.getRuleContext(0, InterfaceTypeContext)!;
    }
    public USING(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.USING, 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_presentationDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPresentationDecl) {
            return visitor.visitPresentationDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PackageQueryContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public QUERY(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.QUERY, 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 ROOT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ROOT, 0)!;
    }
    public interfaceType(): InterfaceTypeContext {
        return this.getRuleContext(0, InterfaceTypeContext)!;
    }
    public DOCUMENT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.DOCUMENT, 0)!;
    }
    public OPERATION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OPERATION, 0);
    }
    public LBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0);
    }
    public RBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0);
    }
    public FRAGMENT(): antlr.TerminalNode[];
    public FRAGMENT(i: number): antlr.TerminalNode | null;
    public FRAGMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(QuixosCapabilityParser.FRAGMENT);
    	} else {
    		return this.getToken(QuixosCapabilityParser.FRAGMENT, i);
    	}
    }
    public typeParameters(): TypeParametersContext | null {
        return this.getRuleContext(0, TypeParametersContext);
    }
    public WORKSPACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WORKSPACE, 0);
    }
    public SEMI(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SEMI, 0);
    }
    public queryClause(): QueryClauseContext[];
    public queryClause(i: number): QueryClauseContext | null;
    public queryClause(i?: number): QueryClauseContext[] | QueryClauseContext | null {
        if (i === undefined) {
            return this.getRuleContexts(QueryClauseContext);
        }

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


export class PackageQuerySpecializationContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public QUERY(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.QUERY, 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 SPECIALIZE(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SPECIALIZE, 0)!;
    }
    public typeArguments(): TypeArgumentsContext {
        return this.getRuleContext(0, TypeArgumentsContext)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_packageQuerySpecialization;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitPackageQuerySpecialization) {
            return visitor.visitPackageQuerySpecialization(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class QueryClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public REPLICA(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REPLICA, 0);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public LOCAL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LOCAL, 0);
    }
    public FROM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FROM, 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 FRAGMENTS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FRAGMENTS, 0);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DOT, 0);
    }
    public WITH(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WITH, 0);
    }
    public LBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0);
    }
    public RBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0);
    }
    public fragmentVariable(): FragmentVariableContext[];
    public fragmentVariable(i: number): FragmentVariableContext | null;
    public fragmentVariable(i?: number): FragmentVariableContext[] | FragmentVariableContext | null {
        if (i === undefined) {
            return this.getRuleContexts(FragmentVariableContext);
        }

        return this.getRuleContext(i, FragmentVariableContext);
    }
    public VIEW(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.VIEW, 0);
    }
    public AS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.AS, 0);
    }
    public interfaceType(): InterfaceTypeContext | null {
        return this.getRuleContext(0, InterfaceTypeContext);
    }
    public OBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OBJECT, 0);
    }
    public MAX(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.MAX, 0);
    }
    public INTEGER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTEGER, 0);
    }
    public ALLOW(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ALLOW, 0);
    }
    public WATCH(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WATCH, 0);
    }
    public POLL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.POLL, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_queryClause;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitQueryClause) {
            return visitor.visitQueryClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class FragmentVariableContext 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 SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_fragmentVariable;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitFragmentVariable) {
            return visitor.visitFragmentVariable(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 typeParameters(): TypeParametersContext | null {
        return this.getRuleContext(0, TypeParametersContext);
    }
    public executionClause(): ExecutionClauseContext | null {
        return this.getRuleContext(0, ExecutionClauseContext);
    }
    public eventClause(): EventClauseContext | null {
        return this.getRuleContext(0, EventClauseContext);
    }
    public dependencyBlock(): DependencyBlockContext | null {
        return this.getRuleContext(0, DependencyBlockContext);
    }
    public acceptanceClause(): AcceptanceClauseContext | null {
        return this.getRuleContext(0, AcceptanceClauseContext);
    }
    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 typeParameters(): TypeParametersContext | null {
        return this.getRuleContext(0, TypeParametersContext);
    }
    public executionClause(): ExecutionClauseContext | null {
        return this.getRuleContext(0, ExecutionClauseContext);
    }
    public dependencyBlock(): DependencyBlockContext | null {
        return this.getRuleContext(0, DependencyBlockContext);
    }
    public acceptanceClause(): AcceptanceClauseContext | null {
        return this.getRuleContext(0, AcceptanceClauseContext);
    }
    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 AcceptanceClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ACCEPT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ACCEPT, 0)!;
    }
    public USING(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.USING, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_acceptanceClause;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitAcceptanceClause) {
            return visitor.visitAcceptanceClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ExecutionClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EXECUTION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.EXECUTION, 0)!;
    }
    public REMOTE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REMOTE, 0);
    }
    public TARGETS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.TARGETS, 0);
    }
    public LBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACK, 0);
    }
    public identifierList(): IdentifierListContext | null {
        return this.getRuleContext(0, IdentifierListContext);
    }
    public RBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACK, 0);
    }
    public SNAPSHOT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SNAPSHOT, 0);
    }
    public TRANSACTION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.TRANSACTION, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_executionClause;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitExecutionClause) {
            return visitor.visitExecutionClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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

        return this.getRuleContext(i, MemberOperationRefContext);
    }
    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_selectedOperations;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitSelectedOperations) {
            return visitor.visitSelectedOperations(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 OBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.OBJECT, 0);
    }
    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 interfaceType(): InterfaceTypeContext[];
    public interfaceType(i: number): InterfaceTypeContext | null;
    public interfaceType(i?: number): InterfaceTypeContext[] | InterfaceTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(InterfaceTypeContext);
        }

        return this.getRuleContext(i, InterfaceTypeContext);
    }
    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_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 REFLECTION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REFLECTION, 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 LBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACK, 0);
    }
    public identifierList(): IdentifierListContext | null {
        return this.getRuleContext(0, IdentifierListContext);
    }
    public RBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACK, 0);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 0);
    }
    public COLON(): antlr.TerminalNode | null {
        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 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 typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public selectedOperations(): SelectedOperationsContext | null {
        return this.getRuleContext(0, SelectedOperationsContext);
    }
    public FROM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FROM, 0);
    }
    public INPUT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INPUT, 0);
    }
    public CREATION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CREATION, 0);
    }
    public CONSTRUCTOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
    }
    public QUERY(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.QUERY, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DOT, 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 EDIT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDIT, 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 REGISTER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.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[];
    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 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 ON_DELETE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ON_DELETE, 0);
    }
    public RETAIN_OTHER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RETAIN_OTHER, 0);
    }
    public KEYED(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.KEYED, 0);
    }
    public PUBLIC_TRAVERSAL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PUBLIC_TRAVERSAL, 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 typeParameters(): TypeParametersContext | null {
        return this.getRuleContext(0, TypeParametersContext);
    }
    public conformanceSourceArguments(): ConformanceSourceArgumentsContext | null {
        return this.getRuleContext(0, ConformanceSourceArgumentsContext);
    }
    public typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public ID(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ID, 0);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public SEMANTIC_MAJOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SEMANTIC_MAJOR, 0);
    }
    public INTEGER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTEGER, 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 ConformanceSourceArgumentsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public typeArguments(): TypeArgumentsContext {
        return this.getRuleContext(0, TypeArgumentsContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_conformanceSourceArguments;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitConformanceSourceArguments) {
            return visitor.visitConformanceSourceArguments(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 stateFieldBindingDecl(): StateFieldBindingDeclContext | null {
        return this.getRuleContext(0, StateFieldBindingDeclContext);
    }
    public initializationDecl(): InitializationDeclContext | null {
        return this.getRuleContext(0, InitializationDeclContext);
    }
    public relationshipMaterializationDecl(): RelationshipMaterializationDeclContext | null {
        return this.getRuleContext(0, RelationshipMaterializationDeclContext);
    }
    public moduleBindingDecl(): ModuleBindingDeclContext | null {
        return this.getRuleContext(0, ModuleBindingDeclContext);
    }
    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 ModuleBindingDeclContext 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 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 override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_moduleBindingDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitModuleBindingDecl) {
            return visitor.visitModuleBindingDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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

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


export class InitializationFieldContext 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 EDGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDGE, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DOT, 0);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_initializationField;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitInitializationField) {
            return visitor.visitInitializationField(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class CreationOwnerMappingContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public interfaceType(): InterfaceTypeContext {
        return this.getRuleContext(0, InterfaceTypeContext)!;
    }
    public FROM(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.FROM, 0)!;
    }
    public INPUT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.INPUT, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    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 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 override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_creationOwnerMapping;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitCreationOwnerMapping) {
            return visitor.visitCreationOwnerMapping(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class StateFieldBindingDeclContext 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 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 {
        return this.getToken(QuixosCapabilityParser.STATE, 0)!;
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_stateFieldBindingDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitStateFieldBindingDecl) {
            return visitor.visitStateFieldBindingDecl(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 QUERY_REASON(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.QUERY_REASON, 0);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    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 EDIT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDIT, 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 LIFECYCLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LIFECYCLE, 0);
    }
    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 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 STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 0);
    }
    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 INTERFACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
    }
    public memberOperationRef(): MemberOperationRefContext | null {
        return this.getRuleContext(0, MemberOperationRefContext);
    }
    public typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public PACKAGE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PACKAGE, 0);
    }
    public dependencyBindingBlock(): DependencyBindingBlockContext | null {
        return this.getRuleContext(0, DependencyBindingBlockContext);
    }
    public acceptanceBinding(): AcceptanceBindingContext | null {
        return this.getRuleContext(0, AcceptanceBindingContext);
    }
    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 AcceptanceBindingContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ACCEPT(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ACCEPT, 0)!;
    }
    public dependencyBindingBlock(): DependencyBindingBlockContext {
        return this.getRuleContext(0, DependencyBindingBlockContext)!;
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_acceptanceBinding;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitAcceptanceBinding) {
            return visitor.visitAcceptanceBinding(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 EDIT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDIT, 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 WORKSPACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WORKSPACE, 0);
    }
    public REFLECTION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REFLECTION, 0);
    }
    public LBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACK, 0);
    }
    public identifierList(): IdentifierListContext | null {
        return this.getRuleContext(0, IdentifierListContext);
    }
    public RBRACK(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACK, 0);
    }
    public SEMI(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
    }
    public STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 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 typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public FROM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FROM, 0);
    }
    public INPUT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INPUT, 0);
    }
    public CREATION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CREATION, 0);
    }
    public WITH(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.WITH, 0);
    }
    public LBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0);
    }
    public RBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0);
    }
    public creationOwnerMapping(): CreationOwnerMappingContext[];
    public creationOwnerMapping(i: number): CreationOwnerMappingContext | null;
    public creationOwnerMapping(i?: number): CreationOwnerMappingContext[] | CreationOwnerMappingContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CreationOwnerMappingContext);
        }

        return this.getRuleContext(i, CreationOwnerMappingContext);
    }
    public CONSTRUCTOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
    }
    public QUERY(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.QUERY, 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 typeArguments(): TypeArgumentsContext | null {
        return this.getRuleContext(0, TypeArgumentsContext);
    }
    public REF(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.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 RECORD(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RECORD, 0);
    }
    public LBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LBRACE, 0);
    }
    public RBRACE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RBRACE, 0);
    }
    public recordField(): RecordFieldContext[];
    public recordField(i: number): RecordFieldContext | null;
    public recordField(i?: number): RecordFieldContext[] | RecordFieldContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RecordFieldContext);
        }

        return this.getRuleContext(i, RecordFieldContext);
    }
    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 RecordFieldContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    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 override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_recordField;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitRecordField) {
            return visitor.visitRecordField(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 START(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.START, 0);
    }
    public STOP(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STOP, 0);
    }
    public EDIT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EDIT, 0);
    }
    public CREATION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.CREATION, 0);
    }
    public INITIALIZE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INITIALIZE, 0);
    }
    public EXECUTION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.EXECUTION, 0);
    }
    public SNAPSHOT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SNAPSHOT, 0);
    }
    public TRANSACTION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.TRANSACTION, 0);
    }
    public REMOTE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REMOTE, 0);
    }
    public TARGETS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.TARGETS, 0);
    }
    public PORTABLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PORTABLE, 0);
    }
    public REPLICA(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REPLICA, 0);
    }
    public LOCAL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.LOCAL, 0);
    }
    public FROM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FROM, 0);
    }
    public REGISTER(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REGISTER, 0);
    }
    public INTERFACES(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.INTERFACES, 0);
    }
    public REFLECTION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.REFLECTION, 0);
    }
    public SOURCE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SOURCE, 0);
    }
    public QUERY(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.QUERY, 0);
    }
    public SPECIALIZE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SPECIALIZE, 0);
    }
    public ROOT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ROOT, 0);
    }
    public DOCUMENT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DOCUMENT, 0);
    }
    public FRAGMENTS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FRAGMENTS, 0);
    }
    public FRAGMENT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FRAGMENT, 0);
    }
    public VIEW(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.VIEW, 0);
    }
    public MAX(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.MAX, 0);
    }
    public ALLOW(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ALLOW, 0);
    }
    public POLL(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.POLL, 0);
    }
    public RPC(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RPC, 0);
    }
    public QUERYABLE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.QUERYABLE, 0);
    }
    public RESULT_BYTES(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RESULT_BYTES, 0);
    }
    public RPC_CALLS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.RPC_CALLS, 0);
    }
    public DEADLINE_MS(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.DEADLINE_MS, 0);
    }
    public PRESENTATION(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.PRESENTATION, 0);
    }
    public SUBJECT(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.SUBJECT, 0);
    }
    public FOR(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.FOR, 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);
        }
    }
}