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

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

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

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


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

    public static readonly literalNames = [
        null, "'workspace'", "'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'", "'via'", "'materialize'", 
        "'if'", "'absent'", "'on'", "'policy'", "'default'", "'source'", 
        "'repository'", "'commit'", "'revision'", "'semantic-major'", "'on-delete'", 
        "'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'", "'optimistic-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, "WORKSPACE", "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", 
        "VIA", "MATERIALIZE", "IF", "ABSENT", "ON", "POLICY", "DEFAULT", 
        "SOURCE", "REPOSITORY", "COMMIT", "REVISION", "SEMANTIC_MAJOR", 
        "ON_DELETE", "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", "OPTIMISTIC_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", "operationMember", "valueMember", 
        "valueMemberOperation", "relationshipMember", "relationshipOperation", 
        "targetConstraint", "packageResourceDecl", "packageExport", "packageOperationExport", 
        "packageFunctionExport", "packageConstructorExport", "eventClause", 
        "operationMode", "receiverRequirement", "identifierList", "dependencyBlock", 
        "dependencyPort", "primitiveList", "primitive", "sharedAttachmentDecl", 
        "attachmentDecl", "stateDecl", "storagePolicy", "edgeDecl", "edgeEndpoint", 
        "conformanceDecl", "conformanceItem", "stateFieldBindingDecl", "relationshipMaterializationDecl", 
        "operationBindingDecl", "memberOperationRef", "operationName", "operationProvider", 
        "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 = 144;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 0, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 132;
                this.workspaceDecl();
                this.state = 133;
                this.match(QuixosCapabilityParser.EOF);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 135;
                this.interfaceResourceDecl();
                this.state = 136;
                this.match(QuixosCapabilityParser.EOF);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 138;
                this.packageResourceDecl();
                this.state = 139;
                this.match(QuixosCapabilityParser.EOF);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 141;
                this.fragmentDecl();
                this.state = 142;
                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 = 146;
            this.match(QuixosCapabilityParser.FRAGMENT);
            this.state = 147;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 151;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 136578308) !== 0)) {
                {
                {
                this.state = 148;
                this.workspaceItem();
                }
                }
                this.state = 153;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 154;
            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 = 156;
            this.match(QuixosCapabilityParser.IMPORT);
            this.state = 157;
            this.stringLiteral();
            this.state = 158;
            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 = 160;
            this.match(QuixosCapabilityParser.WORKSPACE);
            this.state = 161;
            this.identifier();
            this.state = 162;
            this.match(QuixosCapabilityParser.ID);
            this.state = 163;
            this.stringLiteral();
            this.state = 164;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 165;
            this.stringLiteral();
            this.state = 166;
            this.match(QuixosCapabilityParser.COMMIT);
            this.state = 167;
            this.stringLiteral();
            this.state = 168;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 172;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 136578308) !== 0)) {
                {
                {
                this.state = 169;
                this.workspaceItem();
                }
                }
                this.state = 174;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 175;
            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 = 184;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 177;
                this.sourceImportDecl();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 178;
                this.atomDecl();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 179;
                this.resourceImportDecl();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 180;
                this.sharedAttachmentDecl();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 181;
                this.conformanceDecl();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 182;
                this.constructorBindingDecl();
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 183;
                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 = 196;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 186;
                this.match(QuixosCapabilityParser.IMPORT);
                this.state = 187;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 188;
                this.identifier();
                this.state = 189;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 191;
                this.match(QuixosCapabilityParser.IMPORT);
                this.state = 192;
                this.match(QuixosCapabilityParser.PACKAGE);
                this.state = 193;
                this.identifier();
                this.state = 194;
                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 = 198;
            this.match(QuixosCapabilityParser.EXTERNAL);
            this.state = 199;
            this.match(QuixosCapabilityParser.ATOM);
            this.state = 200;
            this.identifier();
            this.state = 201;
            this.match(QuixosCapabilityParser.ID);
            this.state = 202;
            this.stringLiteral();
            this.state = 203;
            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 = 205;
            this.match(QuixosCapabilityParser.EXTERNAL);
            this.state = 206;
            this.match(QuixosCapabilityParser.INTERFACE);
            this.state = 207;
            this.identifier();
            this.state = 208;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 209;
            this.stringLiteral();
            this.state = 210;
            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 = 216;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 212;
                this.resourceImportDecl();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 213;
                this.externalAtomDecl();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 214;
                this.externalInterfaceDecl();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 215;
                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 = 218;
            this.match(QuixosCapabilityParser.ATOM);
            this.state = 219;
            this.identifier();
            this.state = 220;
            this.match(QuixosCapabilityParser.ID);
            this.state = 221;
            this.stringLiteral();
            this.state = 224;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 50) {
                {
                this.state = 222;
                this.match(QuixosCapabilityParser.DOC);
                this.state = 223;
                this.stringLiteral();
                }
            }

            this.state = 226;
            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 = 231;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 772) !== 0)) {
                {
                {
                this.state = 228;
                this.resourcePreamble();
                }
                }
                this.state = 233;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 234;
            this.match(QuixosCapabilityParser.INTERFACE);
            this.state = 235;
            this.identifier();
            this.state = 237;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 108) {
                {
                this.state = 236;
                this.typeParameters();
                }
            }

            this.state = 239;
            this.match(QuixosCapabilityParser.ID);
            this.state = 240;
            this.stringLiteral();
            this.state = 241;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 242;
            this.stringLiteral();
            this.state = 252;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 54) {
                {
                this.state = 243;
                this.match(QuixosCapabilityParser.REQUIRES);
                this.state = 244;
                this.interfaceType();
                this.state = 249;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 100) {
                    {
                    {
                    this.state = 245;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 246;
                    this.interfaceType();
                    }
                    }
                    this.state = 251;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 254;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 258;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 16891904) !== 0)) {
                {
                {
                this.state = 255;
                this.interfaceMember();
                }
                }
                this.state = 260;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 261;
            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 = 263;
            this.match(QuixosCapabilityParser.LT);
            this.state = 264;
            this.typeParameter();
            this.state = 269;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 100) {
                {
                {
                this.state = 265;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 266;
                this.typeParameter();
                }
                }
                this.state = 271;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 272;
            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 = 293;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 274;
                this.match(QuixosCapabilityParser.VALUE);
                this.state = 275;
                this.identifier();
                this.state = 278;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 98) {
                    {
                    this.state = 276;
                    this.match(QuixosCapabilityParser.COLON);
                    this.state = 277;
                    this.match(QuixosCapabilityParser.STORABLE);
                    }
                }

                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 280;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 281;
                this.identifier();
                this.state = 291;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 5) {
                    {
                    this.state = 282;
                    this.match(QuixosCapabilityParser.IMPLEMENTS);
                    this.state = 283;
                    this.interfaceType();
                    this.state = 288;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 110) {
                        {
                        {
                        this.state = 284;
                        this.match(QuixosCapabilityParser.AMP);
                        this.state = 285;
                        this.interfaceType();
                        }
                        }
                        this.state = 290;
                        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 = 295;
            this.identifier();
            this.state = 297;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 108) {
                {
                this.state = 296;
                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 = 299;
            this.match(QuixosCapabilityParser.LT);
            this.state = 300;
            this.typeArgument();
            this.state = 305;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 100) {
                {
                {
                this.state = 301;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 302;
                this.typeArgument();
                }
                }
                this.state = 307;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 308;
            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 = 317;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 310;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 311;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 312;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 313;
                this.interfaceType();
                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 314;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 315;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.REF:
            case QuixosCapabilityParser.SOURCE:
            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 = 316;
                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 = 319;
            this.match(QuixosCapabilityParser.TYPE);
            this.state = 320;
            this.identifier();
            this.state = 322;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 108) {
                {
                this.state = 321;
                this.typeParameters();
                }
            }

            this.state = 324;
            this.match(QuixosCapabilityParser.EQUAL);
            this.state = 325;
            this.valueType();
            this.state = 326;
            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 = 331;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 328;
                this.valueMember();
                }
                break;
            case QuixosCapabilityParser.RELATION:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 329;
                this.relationshipMember();
                }
                break;
            case QuixosCapabilityParser.OPERATION:
            case QuixosCapabilityParser.STATIC:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 330;
                this.operationMember();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationMember(): OperationMemberContext {
        let localContext = new OperationMemberContext(this.context, this.state);
        this.enterRule(localContext, 36, QuixosCapabilityParser.RULE_operationMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 334;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 24) {
                {
                this.state = 333;
                this.match(QuixosCapabilityParser.STATIC);
                }
            }

            this.state = 336;
            this.match(QuixosCapabilityParser.OPERATION);
            this.state = 337;
            this.identifier();
            this.state = 338;
            this.match(QuixosCapabilityParser.ID);
            this.state = 339;
            this.stringLiteral();
            this.state = 340;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 341;
            this.valueType();
            this.state = 342;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 343;
            this.valueType();
            this.state = 344;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 345;
            this.match(QuixosCapabilityParser.CALL);
            this.state = 346;
            this.match(QuixosCapabilityParser.ID);
            this.state = 347;
            this.stringLiteral();
            this.state = 348;
            this.match(QuixosCapabilityParser.SEMI);
            this.state = 349;
            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, 38, QuixosCapabilityParser.RULE_valueMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 351;
            this.match(QuixosCapabilityParser.VALUE);
            this.state = 352;
            this.identifier();
            this.state = 353;
            this.match(QuixosCapabilityParser.ID);
            this.state = 354;
            this.stringLiteral();
            this.state = 355;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 356;
            this.valueType();
            this.state = 357;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 361;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 56)) & ~0x1F) === 0 && ((1 << (_la - 56)) & 7) !== 0)) {
                {
                {
                this.state = 358;
                this.valueMemberOperation();
                }
                }
                this.state = 363;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 364;
            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, 40, QuixosCapabilityParser.RULE_valueMemberOperation);
        try {
            this.state = 385;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.GET:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 366;
                this.match(QuixosCapabilityParser.GET);
                this.state = 367;
                this.match(QuixosCapabilityParser.ID);
                this.state = 368;
                this.stringLiteral();
                this.state = 369;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.SET:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 371;
                this.match(QuixosCapabilityParser.SET);
                this.state = 372;
                this.match(QuixosCapabilityParser.ID);
                this.state = 373;
                this.stringLiteral();
                this.state = 374;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.WATCH:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 376;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 377;
                this.match(QuixosCapabilityParser.START);
                this.state = 378;
                this.match(QuixosCapabilityParser.ID);
                this.state = 379;
                this.stringLiteral();
                this.state = 380;
                this.match(QuixosCapabilityParser.STOP);
                this.state = 381;
                this.match(QuixosCapabilityParser.ID);
                this.state = 382;
                this.stringLiteral();
                this.state = 383;
                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, 42, QuixosCapabilityParser.RULE_relationshipMember);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 387;
            this.match(QuixosCapabilityParser.RELATION);
            this.state = 388;
            this.identifier();
            this.state = 389;
            this.match(QuixosCapabilityParser.ID);
            this.state = 390;
            this.stringLiteral();
            this.state = 391;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 392;
            this.cardinality();
            this.state = 393;
            this.targetConstraint();
            this.state = 395;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 77) {
                {
                this.state = 394;
                this.match(QuixosCapabilityParser.ORDERED);
                }
            }

            this.state = 397;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 401;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 58)) & ~0x1F) === 0 && ((1 << (_la - 58)) & 225) !== 0)) {
                {
                {
                this.state = 398;
                this.relationshipOperation();
                }
                }
                this.state = 403;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 404;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relationshipOperation(): RelationshipOperationContext {
        let localContext = new RelationshipOperationContext(this.context, this.state);
        this.enterRule(localContext, 44, QuixosCapabilityParser.RULE_relationshipOperation);
        try {
            this.state = 430;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.RESOLVE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 406;
                this.match(QuixosCapabilityParser.RESOLVE);
                this.state = 407;
                this.match(QuixosCapabilityParser.ID);
                this.state = 408;
                this.stringLiteral();
                this.state = 409;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CONNECT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 411;
                this.match(QuixosCapabilityParser.CONNECT);
                this.state = 412;
                this.match(QuixosCapabilityParser.ID);
                this.state = 413;
                this.stringLiteral();
                this.state = 414;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.DISCONNECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 416;
                this.match(QuixosCapabilityParser.DISCONNECT);
                this.state = 417;
                this.match(QuixosCapabilityParser.ID);
                this.state = 418;
                this.stringLiteral();
                this.state = 419;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.WATCH:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 421;
                this.match(QuixosCapabilityParser.WATCH);
                this.state = 422;
                this.match(QuixosCapabilityParser.START);
                this.state = 423;
                this.match(QuixosCapabilityParser.ID);
                this.state = 424;
                this.stringLiteral();
                this.state = 425;
                this.match(QuixosCapabilityParser.STOP);
                this.state = 426;
                this.match(QuixosCapabilityParser.ID);
                this.state = 427;
                this.stringLiteral();
                this.state = 428;
                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, 46, QuixosCapabilityParser.RULE_targetConstraint);
        let _la: number;
        try {
            this.state = 441;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 432;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 433;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 434;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 435;
                this.identifier();
                this.state = 437;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 108) {
                    {
                    this.state = 436;
                    this.typeArguments();
                    }
                }

                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 439;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 440;
                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, 48, QuixosCapabilityParser.RULE_packageResourceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 446;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 772) !== 0)) {
                {
                {
                this.state = 443;
                this.resourcePreamble();
                }
                }
                this.state = 448;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 449;
            this.match(QuixosCapabilityParser.PACKAGE);
            this.state = 450;
            this.identifier();
            this.state = 451;
            this.match(QuixosCapabilityParser.ID);
            this.state = 452;
            this.stringLiteral();
            this.state = 453;
            this.match(QuixosCapabilityParser.REVISION);
            this.state = 454;
            this.stringLiteral();
            this.state = 457;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 44) {
                {
                this.state = 455;
                this.match(QuixosCapabilityParser.SEMANTIC_MAJOR);
                this.state = 456;
                this.match(QuixosCapabilityParser.INTEGER);
                }
            }

            this.state = 459;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 463;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 458752) !== 0)) {
                {
                {
                this.state = 460;
                this.packageExport();
                }
                }
                this.state = 465;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 466;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageExport(): PackageExportContext {
        let localContext = new PackageExportContext(this.context, this.state);
        this.enterRule(localContext, 50, QuixosCapabilityParser.RULE_packageExport);
        try {
            this.state = 471;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.OPERATION:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 468;
                this.packageOperationExport();
                }
                break;
            case QuixosCapabilityParser.FUNCTION:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 469;
                this.packageFunctionExport();
                }
                break;
            case QuixosCapabilityParser.CONSTRUCTOR:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 470;
                this.packageConstructorExport();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageOperationExport(): PackageOperationExportContext {
        let localContext = new PackageOperationExportContext(this.context, this.state);
        this.enterRule(localContext, 52, QuixosCapabilityParser.RULE_packageOperationExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 473;
            this.match(QuixosCapabilityParser.OPERATION);
            this.state = 474;
            this.identifier();
            this.state = 476;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 108) {
                {
                this.state = 475;
                this.typeParameters();
                }
            }

            this.state = 478;
            this.match(QuixosCapabilityParser.ID);
            this.state = 479;
            this.stringLiteral();
            this.state = 480;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 481;
            this.valueType();
            this.state = 482;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 483;
            this.valueType();
            this.state = 484;
            this.match(QuixosCapabilityParser.MODE);
            this.state = 485;
            this.operationMode();
            this.state = 487;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 52) {
                {
                this.state = 486;
                this.eventClause();
                }
            }

            this.state = 489;
            this.match(QuixosCapabilityParser.RECEIVER);
            this.state = 490;
            this.receiverRequirement();
            this.state = 492;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 54) {
                {
                this.state = 491;
                this.dependencyBlock();
                }
            }

            this.state = 494;
            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, 54, QuixosCapabilityParser.RULE_packageFunctionExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 496;
            this.match(QuixosCapabilityParser.FUNCTION);
            this.state = 497;
            this.identifier();
            this.state = 499;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 108) {
                {
                this.state = 498;
                this.typeParameters();
                }
            }

            this.state = 501;
            this.match(QuixosCapabilityParser.ID);
            this.state = 502;
            this.stringLiteral();
            this.state = 503;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 504;
            this.valueType();
            this.state = 505;
            this.match(QuixosCapabilityParser.ARROW);
            this.state = 506;
            this.valueType();
            this.state = 508;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 54) {
                {
                this.state = 507;
                this.dependencyBlock();
                }
            }

            this.state = 510;
            this.match(QuixosCapabilityParser.SEMI);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public packageConstructorExport(): PackageConstructorExportContext {
        let localContext = new PackageConstructorExportContext(this.context, this.state);
        this.enterRule(localContext, 56, QuixosCapabilityParser.RULE_packageConstructorExport);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 512;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 513;
            this.identifier();
            this.state = 514;
            this.match(QuixosCapabilityParser.ID);
            this.state = 515;
            this.stringLiteral();
            this.state = 516;
            this.match(QuixosCapabilityParser.CONSTRUCTS);
            this.state = 517;
            this.identifier();
            this.state = 518;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 519;
            this.valueType();
            this.state = 521;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 54) {
                {
                this.state = 520;
                this.dependencyBlock();
                }
            }

            this.state = 523;
            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, 58, QuixosCapabilityParser.RULE_eventClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 525;
            this.match(QuixosCapabilityParser.EMITS);
            this.state = 526;
            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, 60, QuixosCapabilityParser.RULE_operationMode);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 528;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 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, 62, QuixosCapabilityParser.RULE_receiverRequirement);
        let _la: number;
        try {
            this.state = 548;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.ANY:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 530;
                this.match(QuixosCapabilityParser.ANY);
                }
                break;
            case QuixosCapabilityParser.ATOM:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 531;
                this.match(QuixosCapabilityParser.ATOM);
                this.state = 532;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.OBJECT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 533;
                this.match(QuixosCapabilityParser.OBJECT);
                this.state = 534;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.INTERFACES:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 535;
                this.match(QuixosCapabilityParser.INTERFACES);
                this.state = 536;
                this.match(QuixosCapabilityParser.LBRACK);
                this.state = 545;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 40 || _la === 114) {
                    {
                    this.state = 537;
                    this.interfaceType();
                    this.state = 542;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 100) {
                        {
                        {
                        this.state = 538;
                        this.match(QuixosCapabilityParser.COMMA);
                        this.state = 539;
                        this.interfaceType();
                        }
                        }
                        this.state = 544;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                }

                this.state = 547;
                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, 64, QuixosCapabilityParser.RULE_identifierList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 550;
            this.identifier();
            this.state = 555;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 100) {
                {
                {
                this.state = 551;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 552;
                this.identifier();
                }
                }
                this.state = 557;
                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, 66, QuixosCapabilityParser.RULE_dependencyBlock);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 558;
            this.match(QuixosCapabilityParser.REQUIRES);
            this.state = 559;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 563;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805570560) !== 0)) {
                {
                {
                this.state = 560;
                this.dependencyPort();
                }
                }
                this.state = 565;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 566;
            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, 68, QuixosCapabilityParser.RULE_dependencyPort);
        let _la: number;
        try {
            this.state = 610;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 568;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 569;
                this.identifier();
                this.state = 570;
                this.match(QuixosCapabilityParser.ID);
                this.state = 571;
                this.stringLiteral();
                this.state = 572;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 573;
                this.valueType();
                this.state = 574;
                this.primitiveList();
                this.state = 575;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 577;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 578;
                this.identifier();
                this.state = 579;
                this.match(QuixosCapabilityParser.ID);
                this.state = 580;
                this.stringLiteral();
                this.state = 581;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 582;
                this.cardinality();
                this.state = 583;
                this.targetConstraint();
                this.state = 584;
                this.primitiveList();
                this.state = 585;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.INTERFACE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 587;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 588;
                this.identifier();
                this.state = 589;
                this.match(QuixosCapabilityParser.ID);
                this.state = 590;
                this.stringLiteral();
                this.state = 591;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 592;
                this.identifier();
                this.state = 594;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 108) {
                    {
                    this.state = 593;
                    this.typeArguments();
                    }
                }

                this.state = 596;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case QuixosCapabilityParser.CONSTRUCTOR:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 598;
                this.match(QuixosCapabilityParser.CONSTRUCTOR);
                this.state = 599;
                this.identifier();
                this.state = 600;
                this.match(QuixosCapabilityParser.ID);
                this.state = 601;
                this.stringLiteral();
                this.state = 602;
                this.match(QuixosCapabilityParser.COLON);
                this.state = 603;
                this.identifier();
                this.state = 606;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20) {
                    {
                    this.state = 604;
                    this.match(QuixosCapabilityParser.INPUT);
                    this.state = 605;
                    this.valueType();
                    }
                }

                this.state = 608;
                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, 70, QuixosCapabilityParser.RULE_primitiveList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 612;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 613;
            this.primitive();
            this.state = 618;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 100) {
                {
                {
                this.state = 614;
                this.match(QuixosCapabilityParser.COMMA);
                this.state = 615;
                this.primitive();
                }
                }
                this.state = 620;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 621;
            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, 72, QuixosCapabilityParser.RULE_primitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 623;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 61)) & ~0x1F) === 0 && ((1 << (_la - 61)) & 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, 74, QuixosCapabilityParser.RULE_sharedAttachmentDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 625;
            this.match(QuixosCapabilityParser.SHARED);
            this.state = 626;
            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, 76, QuixosCapabilityParser.RULE_attachmentDecl);
        try {
            this.state = 630;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 628;
                this.stateDecl();
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 629;
                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, 78, QuixosCapabilityParser.RULE_stateDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 632;
            this.match(QuixosCapabilityParser.STATE);
            this.state = 633;
            this.identifier();
            this.state = 634;
            this.match(QuixosCapabilityParser.ID);
            this.state = 635;
            this.stringLiteral();
            this.state = 636;
            this.match(QuixosCapabilityParser.ON);
            this.state = 637;
            this.identifier();
            this.state = 638;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 639;
            this.valueType();
            this.state = 640;
            this.match(QuixosCapabilityParser.POLICY);
            this.state = 641;
            this.storagePolicy();
            this.state = 644;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 39) {
                {
                this.state = 642;
                this.match(QuixosCapabilityParser.DEFAULT);
                this.state = 643;
                this.jsonLiteral();
                }
            }

            this.state = 646;
            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, 80, QuixosCapabilityParser.RULE_storagePolicy);
        try {
            this.state = 654;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.OPTIMISTIC_REGISTER:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 648;
                this.match(QuixosCapabilityParser.OPTIMISTIC_REGISTER);
                }
                break;
            case QuixosCapabilityParser.CRDT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 649;
                this.match(QuixosCapabilityParser.CRDT);
                this.state = 650;
                this.match(QuixosCapabilityParser.LPAREN);
                this.state = 651;
                this.valueType();
                this.state = 652;
                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, 82, QuixosCapabilityParser.RULE_edgeDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 656;
            this.match(QuixosCapabilityParser.EDGE);
            this.state = 657;
            this.identifier();
            this.state = 658;
            this.match(QuixosCapabilityParser.ID);
            this.state = 659;
            this.stringLiteral();
            this.state = 660;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 661;
            this.edgeEndpoint();
            this.state = 662;
            this.edgeEndpoint();
            this.state = 663;
            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, 84, QuixosCapabilityParser.RULE_edgeEndpoint);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 665;
            this.targetConstraint();
            this.state = 666;
            this.match(QuixosCapabilityParser.PROJECTION);
            this.state = 667;
            this.identifier();
            this.state = 668;
            this.match(QuixosCapabilityParser.ID);
            this.state = 669;
            this.stringLiteral();
            this.state = 670;
            this.cardinality();
            this.state = 672;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 77) {
                {
                this.state = 671;
                this.match(QuixosCapabilityParser.ORDERED);
                }
            }

            this.state = 676;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 45) {
                {
                this.state = 674;
                this.match(QuixosCapabilityParser.ON_DELETE);
                this.state = 675;
                this.stringLiteral();
                }
            }

            this.state = 679;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 46) {
                {
                this.state = 678;
                this.match(QuixosCapabilityParser.RETAIN_OTHER);
                }
            }

            this.state = 683;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 47) {
                {
                this.state = 681;
                this.match(QuixosCapabilityParser.KEYED);
                this.state = 682;
                this.stringLiteral();
                }
            }

            this.state = 686;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 48) {
                {
                this.state = 685;
                this.match(QuixosCapabilityParser.PUBLIC_TRAVERSAL);
                }
            }

            this.state = 688;
            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, 86, QuixosCapabilityParser.RULE_conformanceDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 690;
            this.match(QuixosCapabilityParser.CONFORM);
            this.state = 691;
            this.identifier();
            this.state = 692;
            this.match(QuixosCapabilityParser.AS);
            this.state = 693;
            this.identifier();
            this.state = 695;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 108) {
                {
                this.state = 694;
                this.typeArguments();
                }
            }

            this.state = 699;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 49) {
                {
                this.state = 697;
                this.match(QuixosCapabilityParser.ID);
                this.state = 698;
                this.stringLiteral();
                }
            }

            this.state = 703;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 44) {
                {
                this.state = 701;
                this.match(QuixosCapabilityParser.SEMANTIC_MAJOR);
                this.state = 702;
                this.match(QuixosCapabilityParser.INTEGER);
                }
            }

            this.state = 705;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 709;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (((((_la - 23)) & ~0x1F) === 0 && ((1 << (_la - 23)) & 2057) !== 0)) {
                {
                {
                this.state = 706;
                this.conformanceItem();
                }
                }
                this.state = 711;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 712;
            this.match(QuixosCapabilityParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public conformanceItem(): ConformanceItemContext {
        let localContext = new ConformanceItemContext(this.context, this.state);
        this.enterRule(localContext, 88, QuixosCapabilityParser.RULE_conformanceItem);
        try {
            this.state = 719;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 61, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 714;
                this.match(QuixosCapabilityParser.PRIVATE);
                this.state = 715;
                this.attachmentDecl();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 716;
                this.operationBindingDecl();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 717;
                this.stateFieldBindingDecl();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 718;
                this.relationshipMaterializationDecl();
                }
                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 stateFieldBindingDecl(): StateFieldBindingDeclContext {
        let localContext = new StateFieldBindingDeclContext(this.context, this.state);
        this.enterRule(localContext, 90, QuixosCapabilityParser.RULE_stateFieldBindingDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 721;
            this.match(QuixosCapabilityParser.BIND);
            this.state = 722;
            this.identifier();
            this.state = 723;
            this.match(QuixosCapabilityParser.TO);
            this.state = 724;
            this.match(QuixosCapabilityParser.STATE);
            this.state = 725;
            this.identifier();
            this.state = 726;
            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, 92, QuixosCapabilityParser.RULE_relationshipMaterializationDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 728;
            this.match(QuixosCapabilityParser.MATERIALIZE);
            this.state = 729;
            this.identifier();
            this.state = 730;
            this.match(QuixosCapabilityParser.IF);
            this.state = 731;
            this.match(QuixosCapabilityParser.ABSENT);
            this.state = 732;
            this.match(QuixosCapabilityParser.USING);
            this.state = 733;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 734;
            this.identifier();
            this.state = 735;
            this.match(QuixosCapabilityParser.VIA);
            this.state = 736;
            this.match(QuixosCapabilityParser.EDGE);
            this.state = 737;
            this.identifier();
            this.state = 738;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 739;
            this.identifier();
            this.state = 740;
            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, 94, QuixosCapabilityParser.RULE_operationBindingDecl);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 742;
            this.match(QuixosCapabilityParser.BIND);
            this.state = 743;
            this.memberOperationRef();
            this.state = 744;
            this.match(QuixosCapabilityParser.TO);
            this.state = 745;
            this.operationProvider();
            this.state = 746;
            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, 96, QuixosCapabilityParser.RULE_memberOperationRef);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 748;
            this.identifier();
            this.state = 749;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 750;
            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, 98, QuixosCapabilityParser.RULE_operationName);
        try {
            this.state = 763;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.SOURCE:
            case QuixosCapabilityParser.IDENTIFIER:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 752;
                this.identifier();
                }
                break;
            case QuixosCapabilityParser.CALL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 753;
                this.match(QuixosCapabilityParser.CALL);
                }
                break;
            case QuixosCapabilityParser.GET:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 754;
                this.match(QuixosCapabilityParser.GET);
                }
                break;
            case QuixosCapabilityParser.SET:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 755;
                this.match(QuixosCapabilityParser.SET);
                }
                break;
            case QuixosCapabilityParser.RESOLVE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 756;
                this.match(QuixosCapabilityParser.RESOLVE);
                }
                break;
            case QuixosCapabilityParser.CONNECT:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 757;
                this.match(QuixosCapabilityParser.CONNECT);
                }
                break;
            case QuixosCapabilityParser.DISCONNECT:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 758;
                this.match(QuixosCapabilityParser.DISCONNECT);
                }
                break;
            case QuixosCapabilityParser.WATCH_START:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 759;
                this.match(QuixosCapabilityParser.WATCH_START);
                }
                break;
            case QuixosCapabilityParser.WATCH_STOP:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 760;
                this.match(QuixosCapabilityParser.WATCH_STOP);
                }
                break;
            case QuixosCapabilityParser.SUBSCRIBE:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 761;
                this.match(QuixosCapabilityParser.SUBSCRIBE);
                }
                break;
            case QuixosCapabilityParser.UNSUBSCRIBE:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 762;
                this.match(QuixosCapabilityParser.UNSUBSCRIBE);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public operationProvider(): OperationProviderContext {
        let localContext = new OperationProviderContext(this.context, this.state);
        this.enterRule(localContext, 100, QuixosCapabilityParser.RULE_operationProvider);
        let _la: number;
        try {
            this.state = 787;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STATE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 765;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 766;
                this.identifier();
                this.state = 767;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 768;
                this.statePrimitive();
                }
                break;
            case QuixosCapabilityParser.EDGE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 770;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 771;
                this.identifier();
                this.state = 772;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 773;
                this.identifier();
                this.state = 774;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 775;
                this.edgePrimitive();
                }
                break;
            case QuixosCapabilityParser.PACKAGE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 777;
                this.match(QuixosCapabilityParser.PACKAGE);
                this.state = 778;
                this.identifier();
                this.state = 779;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 780;
                this.identifier();
                this.state = 782;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 108) {
                    {
                    this.state = 781;
                    this.typeArguments();
                    }
                }

                this.state = 785;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 31) {
                    {
                    this.state = 784;
                    this.dependencyBindingBlock();
                    }
                }

                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public statePrimitive(): StatePrimitiveContext {
        let localContext = new StatePrimitiveContext(this.context, this.state);
        this.enterRule(localContext, 102, QuixosCapabilityParser.RULE_statePrimitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 789;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 61)) & ~0x1F) === 0 && ((1 << (_la - 61)) & 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, 104, QuixosCapabilityParser.RULE_edgePrimitive);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 791;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 63)) & ~0x1F) === 0 && ((1 << (_la - 63)) & 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, 106, QuixosCapabilityParser.RULE_dependencyBindingBlock);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 793;
            this.match(QuixosCapabilityParser.WITH);
            this.state = 794;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 798;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 40 || _la === 114) {
                {
                {
                this.state = 795;
                this.dependencyBinding();
                }
                }
                this.state = 800;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 801;
            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, 108, QuixosCapabilityParser.RULE_dependencyBinding);
        let _la: number;
        try {
            this.state = 856;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 71, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 803;
                this.identifier();
                this.state = 804;
                this.match(QuixosCapabilityParser.TO);
                this.state = 805;
                this.match(QuixosCapabilityParser.STATE);
                this.state = 806;
                this.identifier();
                this.state = 813;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 33) {
                    {
                    this.state = 807;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 808;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 809;
                    this.identifier();
                    this.state = 810;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 811;
                    this.identifier();
                    }
                }

                this.state = 815;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 817;
                this.identifier();
                this.state = 818;
                this.match(QuixosCapabilityParser.TO);
                this.state = 819;
                this.match(QuixosCapabilityParser.EDGE);
                this.state = 820;
                this.identifier();
                this.state = 821;
                this.match(QuixosCapabilityParser.DOT);
                this.state = 822;
                this.identifier();
                this.state = 829;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 33) {
                    {
                    this.state = 823;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 824;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 825;
                    this.identifier();
                    this.state = 826;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 827;
                    this.identifier();
                    }
                }

                this.state = 831;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 833;
                this.identifier();
                this.state = 834;
                this.match(QuixosCapabilityParser.TO);
                this.state = 835;
                this.match(QuixosCapabilityParser.INTERFACE);
                this.state = 836;
                this.identifier();
                this.state = 838;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 108) {
                    {
                    this.state = 837;
                    this.typeArguments();
                    }
                }

                this.state = 846;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 33) {
                    {
                    this.state = 840;
                    this.match(QuixosCapabilityParser.VIA);
                    this.state = 841;
                    this.match(QuixosCapabilityParser.EDGE);
                    this.state = 842;
                    this.identifier();
                    this.state = 843;
                    this.match(QuixosCapabilityParser.DOT);
                    this.state = 844;
                    this.identifier();
                    }
                }

                this.state = 848;
                this.match(QuixosCapabilityParser.SEMI);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 850;
                this.identifier();
                this.state = 851;
                this.match(QuixosCapabilityParser.TO);
                this.state = 852;
                this.match(QuixosCapabilityParser.CONSTRUCTOR);
                this.state = 853;
                this.identifier();
                this.state = 854;
                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, 110, QuixosCapabilityParser.RULE_constructorBindingDecl);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 858;
            this.match(QuixosCapabilityParser.CONSTRUCTOR);
            this.state = 859;
            this.identifier();
            this.state = 860;
            this.match(QuixosCapabilityParser.TO);
            this.state = 861;
            this.identifier();
            this.state = 862;
            this.match(QuixosCapabilityParser.DOT);
            this.state = 863;
            this.identifier();
            this.state = 865;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 31) {
                {
                this.state = 864;
                this.dependencyBindingBlock();
                }
            }

            this.state = 867;
            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, 112, QuixosCapabilityParser.RULE_valueType);
        let _la: number;
        try {
            this.state = 915;
            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 = 869;
                this.scalarType();
                }
                break;
            case QuixosCapabilityParser.UNIT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 870;
                this.match(QuixosCapabilityParser.UNIT);
                }
                break;
            case QuixosCapabilityParser.WATCH_HANDLE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 871;
                this.match(QuixosCapabilityParser.WATCH_HANDLE);
                }
                break;
            case QuixosCapabilityParser.MESSAGE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 872;
                this.match(QuixosCapabilityParser.MESSAGE);
                this.state = 873;
                this.stringLiteral();
                }
                break;
            case QuixosCapabilityParser.ATOM_REF:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 874;
                this.match(QuixosCapabilityParser.ATOM_REF);
                this.state = 875;
                this.match(QuixosCapabilityParser.LT);
                this.state = 876;
                this.identifier();
                this.state = 877;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.INTERFACE_REF:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 879;
                this.match(QuixosCapabilityParser.INTERFACE_REF);
                this.state = 880;
                this.match(QuixosCapabilityParser.LT);
                this.state = 881;
                this.identifier();
                this.state = 883;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 108) {
                    {
                    this.state = 882;
                    this.typeArguments();
                    }
                }

                this.state = 885;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.REF:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 887;
                this.match(QuixosCapabilityParser.REF);
                this.state = 888;
                this.match(QuixosCapabilityParser.LT);
                this.state = 889;
                this.identifier();
                this.state = 890;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.OPTIONAL:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 892;
                this.match(QuixosCapabilityParser.OPTIONAL);
                this.state = 893;
                this.match(QuixosCapabilityParser.LT);
                this.state = 894;
                this.valueType();
                this.state = 895;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.LIST:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 897;
                this.match(QuixosCapabilityParser.LIST);
                this.state = 898;
                this.match(QuixosCapabilityParser.LT);
                this.state = 899;
                this.valueType();
                this.state = 900;
                this.match(QuixosCapabilityParser.GT);
                }
                break;
            case QuixosCapabilityParser.RECORD:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 902;
                this.match(QuixosCapabilityParser.RECORD);
                this.state = 903;
                this.match(QuixosCapabilityParser.LBRACE);
                this.state = 907;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 40 || _la === 114) {
                    {
                    {
                    this.state = 904;
                    this.recordField();
                    }
                    }
                    this.state = 909;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 910;
                this.match(QuixosCapabilityParser.RBRACE);
                }
                break;
            case QuixosCapabilityParser.SOURCE:
            case QuixosCapabilityParser.IDENTIFIER:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 911;
                this.identifier();
                this.state = 913;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 108) {
                    {
                    this.state = 912;
                    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, 114, QuixosCapabilityParser.RULE_recordField);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 917;
            this.identifier();
            this.state = 918;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 919;
            this.valueType();
            this.state = 920;
            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, 116, QuixosCapabilityParser.RULE_scalarType);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 922;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 86)) & ~0x1F) === 0 && ((1 << (_la - 86)) & 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, 118, QuixosCapabilityParser.RULE_cardinality);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 924;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 73)) & ~0x1F) === 0 && ((1 << (_la - 73)) & 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, 120, QuixosCapabilityParser.RULE_jsonLiteral);
        try {
            this.state = 934;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case QuixosCapabilityParser.STRING_LITERAL:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 926;
                this.stringLiteral();
                }
                break;
            case QuixosCapabilityParser.INTEGER:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 927;
                this.match(QuixosCapabilityParser.INTEGER);
                }
                break;
            case QuixosCapabilityParser.JSON_NUMBER:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 928;
                this.match(QuixosCapabilityParser.JSON_NUMBER);
                }
                break;
            case QuixosCapabilityParser.TRUE:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 929;
                this.match(QuixosCapabilityParser.TRUE);
                }
                break;
            case QuixosCapabilityParser.FALSE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 930;
                this.match(QuixosCapabilityParser.FALSE);
                }
                break;
            case QuixosCapabilityParser.NULL:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 931;
                this.match(QuixosCapabilityParser.NULL);
                }
                break;
            case QuixosCapabilityParser.LBRACE:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 932;
                this.jsonObject();
                }
                break;
            case QuixosCapabilityParser.LBRACK:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 933;
                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, 122, QuixosCapabilityParser.RULE_jsonObject);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 936;
            this.match(QuixosCapabilityParser.LBRACE);
            this.state = 945;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 115) {
                {
                this.state = 937;
                this.jsonMember();
                this.state = 942;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 100) {
                    {
                    {
                    this.state = 938;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 939;
                    this.jsonMember();
                    }
                    }
                    this.state = 944;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 947;
            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, 124, QuixosCapabilityParser.RULE_jsonMember);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 949;
            this.stringLiteral();
            this.state = 950;
            this.match(QuixosCapabilityParser.COLON);
            this.state = 951;
            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, 126, QuixosCapabilityParser.RULE_jsonArray);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 953;
            this.match(QuixosCapabilityParser.LBRACK);
            this.state = 962;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (((((_la - 94)) & ~0x1F) === 0 && ((1 << (_la - 94)) & 2884871) !== 0)) {
                {
                this.state = 954;
                this.jsonLiteral();
                this.state = 959;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 100) {
                    {
                    {
                    this.state = 955;
                    this.match(QuixosCapabilityParser.COMMA);
                    this.state = 956;
                    this.jsonLiteral();
                    }
                    }
                    this.state = 961;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 964;
            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, 128, QuixosCapabilityParser.RULE_identifier);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 966;
            _la = this.tokenStream.LA(1);
            if(!(_la === 40 || _la === 114)) {
            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, 130, QuixosCapabilityParser.RULE_stringLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 968;
            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,118,971,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,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,145,8,0,1,
        1,1,1,1,1,5,1,150,8,1,10,1,12,1,153,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,171,8,3,10,3,12,3,174,
        9,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,185,8,4,1,5,1,5,1,5,
        1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,197,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,217,8,8,1,9,
        1,9,1,9,1,9,1,9,1,9,3,9,225,8,9,1,9,1,9,1,10,5,10,230,8,10,10,10,
        12,10,233,9,10,1,10,1,10,1,10,3,10,238,8,10,1,10,1,10,1,10,1,10,
        1,10,1,10,1,10,1,10,5,10,248,8,10,10,10,12,10,251,9,10,3,10,253,
        8,10,1,10,1,10,5,10,257,8,10,10,10,12,10,260,9,10,1,10,1,10,1,11,
        1,11,1,11,1,11,5,11,268,8,11,10,11,12,11,271,9,11,1,11,1,11,1,12,
        1,12,1,12,1,12,3,12,279,8,12,1,12,1,12,1,12,1,12,1,12,1,12,5,12,
        287,8,12,10,12,12,12,290,9,12,3,12,292,8,12,3,12,294,8,12,1,13,1,
        13,3,13,298,8,13,1,14,1,14,1,14,1,14,5,14,304,8,14,10,14,12,14,307,
        9,14,1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,318,8,15,
        1,16,1,16,1,16,3,16,323,8,16,1,16,1,16,1,16,1,16,1,17,1,17,1,17,
        3,17,332,8,17,1,18,3,18,335,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
        18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,
        19,1,19,1,19,1,19,5,19,360,8,19,10,19,12,19,363,9,19,1,19,1,19,1,
        20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,
        20,1,20,1,20,1,20,1,20,1,20,3,20,386,8,20,1,21,1,21,1,21,1,21,1,
        21,1,21,1,21,1,21,3,21,396,8,21,1,21,1,21,5,21,400,8,21,10,21,12,
        21,403,9,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,
        22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,
        22,1,22,1,22,3,22,431,8,22,1,23,1,23,1,23,1,23,1,23,3,23,438,8,23,
        1,23,1,23,3,23,442,8,23,1,24,5,24,445,8,24,10,24,12,24,448,9,24,
        1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,458,8,24,1,24,1,24,
        5,24,462,8,24,10,24,12,24,465,9,24,1,24,1,24,1,25,1,25,1,25,3,25,
        472,8,25,1,26,1,26,1,26,3,26,477,8,26,1,26,1,26,1,26,1,26,1,26,1,
        26,1,26,1,26,1,26,3,26,488,8,26,1,26,1,26,1,26,3,26,493,8,26,1,26,
        1,26,1,27,1,27,1,27,3,27,500,8,27,1,27,1,27,1,27,1,27,1,27,1,27,
        1,27,3,27,509,8,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,
        1,28,1,28,3,28,522,8,28,1,28,1,28,1,29,1,29,1,29,1,30,1,30,1,31,
        1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,5,31,541,8,31,10,31,
        12,31,544,9,31,3,31,546,8,31,1,31,3,31,549,8,31,1,32,1,32,1,32,5,
        32,554,8,32,10,32,12,32,557,9,32,1,33,1,33,1,33,5,33,562,8,33,10,
        33,12,33,565,9,33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,
        34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,
        34,1,34,1,34,1,34,1,34,1,34,3,34,595,8,34,1,34,1,34,1,34,1,34,1,
        34,1,34,1,34,1,34,1,34,1,34,3,34,607,8,34,1,34,1,34,3,34,611,8,34,
        1,35,1,35,1,35,1,35,5,35,617,8,35,10,35,12,35,620,9,35,1,35,1,35,
        1,36,1,36,1,37,1,37,1,37,1,38,1,38,3,38,631,8,38,1,39,1,39,1,39,
        1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,645,8,39,1,39,
        1,39,1,40,1,40,1,40,1,40,1,40,1,40,3,40,655,8,40,1,41,1,41,1,41,
        1,41,1,41,1,41,1,41,1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,
        3,42,673,8,42,1,42,1,42,3,42,677,8,42,1,42,3,42,680,8,42,1,42,1,
        42,3,42,684,8,42,1,42,3,42,687,8,42,1,42,1,42,1,43,1,43,1,43,1,43,
        1,43,3,43,696,8,43,1,43,1,43,3,43,700,8,43,1,43,1,43,3,43,704,8,
        43,1,43,1,43,5,43,708,8,43,10,43,12,43,711,9,43,1,43,1,43,1,44,1,
        44,1,44,1,44,1,44,3,44,720,8,44,1,45,1,45,1,45,1,45,1,45,1,45,1,
        45,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,
        46,1,46,1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,49,1,
        49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,764,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,1,50,1,
        50,1,50,1,50,1,50,3,50,783,8,50,1,50,3,50,786,8,50,3,50,788,8,50,
        1,51,1,51,1,52,1,52,1,53,1,53,1,53,5,53,797,8,53,10,53,12,53,800,
        9,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,
        3,54,814,8,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,
        1,54,1,54,1,54,1,54,3,54,830,8,54,1,54,1,54,1,54,1,54,1,54,1,54,
        1,54,3,54,839,8,54,1,54,1,54,1,54,1,54,1,54,1,54,3,54,847,8,54,1,
        54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,3,54,857,8,54,1,55,1,55,1,
        55,1,55,1,55,1,55,1,55,3,55,866,8,55,1,55,1,55,1,56,1,56,1,56,1,
        56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,3,56,884,8,
        56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,
        56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,5,56,906,8,56,10,56,12,56,
        909,9,56,1,56,1,56,1,56,3,56,914,8,56,3,56,916,8,56,1,57,1,57,1,
        57,1,57,1,57,1,58,1,58,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,1,
        60,1,60,3,60,935,8,60,1,61,1,61,1,61,1,61,5,61,941,8,61,10,61,12,
        61,944,9,61,3,61,946,8,61,1,61,1,61,1,62,1,62,1,62,1,62,1,63,1,63,
        1,63,1,63,5,63,958,8,63,10,63,12,63,961,9,63,3,63,963,8,63,1,63,
        1,63,1,64,1,64,1,65,1,65,1,65,0,0,66,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,0,7,1,0,66,70,2,
        0,61,65,67,68,2,0,61,62,67,68,2,0,63,65,67,68,1,0,86,93,1,0,73,76,
        2,0,40,40,114,114,1036,0,144,1,0,0,0,2,146,1,0,0,0,4,156,1,0,0,0,
        6,160,1,0,0,0,8,184,1,0,0,0,10,196,1,0,0,0,12,198,1,0,0,0,14,205,
        1,0,0,0,16,216,1,0,0,0,18,218,1,0,0,0,20,231,1,0,0,0,22,263,1,0,
        0,0,24,293,1,0,0,0,26,295,1,0,0,0,28,299,1,0,0,0,30,317,1,0,0,0,
        32,319,1,0,0,0,34,331,1,0,0,0,36,334,1,0,0,0,38,351,1,0,0,0,40,385,
        1,0,0,0,42,387,1,0,0,0,44,430,1,0,0,0,46,441,1,0,0,0,48,446,1,0,
        0,0,50,471,1,0,0,0,52,473,1,0,0,0,54,496,1,0,0,0,56,512,1,0,0,0,
        58,525,1,0,0,0,60,528,1,0,0,0,62,548,1,0,0,0,64,550,1,0,0,0,66,558,
        1,0,0,0,68,610,1,0,0,0,70,612,1,0,0,0,72,623,1,0,0,0,74,625,1,0,
        0,0,76,630,1,0,0,0,78,632,1,0,0,0,80,654,1,0,0,0,82,656,1,0,0,0,
        84,665,1,0,0,0,86,690,1,0,0,0,88,719,1,0,0,0,90,721,1,0,0,0,92,728,
        1,0,0,0,94,742,1,0,0,0,96,748,1,0,0,0,98,763,1,0,0,0,100,787,1,0,
        0,0,102,789,1,0,0,0,104,791,1,0,0,0,106,793,1,0,0,0,108,856,1,0,
        0,0,110,858,1,0,0,0,112,915,1,0,0,0,114,917,1,0,0,0,116,922,1,0,
        0,0,118,924,1,0,0,0,120,934,1,0,0,0,122,936,1,0,0,0,124,949,1,0,
        0,0,126,953,1,0,0,0,128,966,1,0,0,0,130,968,1,0,0,0,132,133,3,6,
        3,0,133,134,5,0,0,1,134,145,1,0,0,0,135,136,3,20,10,0,136,137,5,
        0,0,1,137,145,1,0,0,0,138,139,3,48,24,0,139,140,5,0,0,1,140,145,
        1,0,0,0,141,142,3,2,1,0,142,143,5,0,0,1,143,145,1,0,0,0,144,132,
        1,0,0,0,144,135,1,0,0,0,144,138,1,0,0,0,144,141,1,0,0,0,145,1,1,
        0,0,0,146,147,5,7,0,0,147,151,5,102,0,0,148,150,3,8,4,0,149,148,
        1,0,0,0,150,153,1,0,0,0,151,149,1,0,0,0,151,152,1,0,0,0,152,154,
        1,0,0,0,153,151,1,0,0,0,154,155,5,103,0,0,155,3,1,0,0,0,156,157,
        5,8,0,0,157,158,3,130,65,0,158,159,5,99,0,0,159,5,1,0,0,0,160,161,
        5,1,0,0,161,162,3,128,64,0,162,163,5,49,0,0,163,164,3,130,65,0,164,
        165,5,43,0,0,165,166,3,130,65,0,166,167,5,42,0,0,167,168,3,130,65,
        0,168,172,5,102,0,0,169,171,3,8,4,0,170,169,1,0,0,0,171,174,1,0,
        0,0,172,170,1,0,0,0,172,173,1,0,0,0,173,175,1,0,0,0,174,172,1,0,
        0,0,175,176,5,103,0,0,176,7,1,0,0,0,177,185,3,4,2,0,178,185,3,18,
        9,0,179,185,3,10,5,0,180,185,3,74,37,0,181,185,3,86,43,0,182,185,
        3,110,55,0,183,185,3,32,16,0,184,177,1,0,0,0,184,178,1,0,0,0,184,
        179,1,0,0,0,184,180,1,0,0,0,184,181,1,0,0,0,184,182,1,0,0,0,184,
        183,1,0,0,0,185,9,1,0,0,0,186,187,5,8,0,0,187,188,5,11,0,0,188,189,
        3,128,64,0,189,190,5,99,0,0,190,197,1,0,0,0,191,192,5,8,0,0,192,
        193,5,13,0,0,193,194,3,128,64,0,194,195,5,99,0,0,195,197,1,0,0,0,
        196,186,1,0,0,0,196,191,1,0,0,0,197,11,1,0,0,0,198,199,5,9,0,0,199,
        200,5,10,0,0,200,201,3,128,64,0,201,202,5,49,0,0,202,203,3,130,65,
        0,203,204,5,99,0,0,204,13,1,0,0,0,205,206,5,9,0,0,206,207,5,11,0,
        0,207,208,3,128,64,0,208,209,5,43,0,0,209,210,3,130,65,0,210,211,
        5,99,0,0,211,15,1,0,0,0,212,217,3,10,5,0,213,217,3,12,6,0,214,217,
        3,14,7,0,215,217,3,32,16,0,216,212,1,0,0,0,216,213,1,0,0,0,216,214,
        1,0,0,0,216,215,1,0,0,0,217,17,1,0,0,0,218,219,5,10,0,0,219,220,
        3,128,64,0,220,221,5,49,0,0,221,224,3,130,65,0,222,223,5,50,0,0,
        223,225,3,130,65,0,224,222,1,0,0,0,224,225,1,0,0,0,225,226,1,0,0,
        0,226,227,5,99,0,0,227,19,1,0,0,0,228,230,3,16,8,0,229,228,1,0,0,
        0,230,233,1,0,0,0,231,229,1,0,0,0,231,232,1,0,0,0,232,234,1,0,0,
        0,233,231,1,0,0,0,234,235,5,11,0,0,235,237,3,128,64,0,236,238,3,
        22,11,0,237,236,1,0,0,0,237,238,1,0,0,0,238,239,1,0,0,0,239,240,
        5,49,0,0,240,241,3,130,65,0,241,242,5,43,0,0,242,252,3,130,65,0,
        243,244,5,54,0,0,244,249,3,26,13,0,245,246,5,100,0,0,246,248,3,26,
        13,0,247,245,1,0,0,0,248,251,1,0,0,0,249,247,1,0,0,0,249,250,1,0,
        0,0,250,253,1,0,0,0,251,249,1,0,0,0,252,243,1,0,0,0,252,253,1,0,
        0,0,253,254,1,0,0,0,254,258,5,102,0,0,255,257,3,34,17,0,256,255,
        1,0,0,0,257,260,1,0,0,0,258,256,1,0,0,0,258,259,1,0,0,0,259,261,
        1,0,0,0,260,258,1,0,0,0,261,262,5,103,0,0,262,21,1,0,0,0,263,264,
        5,108,0,0,264,269,3,24,12,0,265,266,5,100,0,0,266,268,3,24,12,0,
        267,265,1,0,0,0,268,271,1,0,0,0,269,267,1,0,0,0,269,270,1,0,0,0,
        270,272,1,0,0,0,271,269,1,0,0,0,272,273,5,109,0,0,273,23,1,0,0,0,
        274,275,5,14,0,0,275,278,3,128,64,0,276,277,5,98,0,0,277,279,5,4,
        0,0,278,276,1,0,0,0,278,279,1,0,0,0,279,294,1,0,0,0,280,281,5,3,
        0,0,281,291,3,128,64,0,282,283,5,5,0,0,283,288,3,26,13,0,284,285,
        5,110,0,0,285,287,3,26,13,0,286,284,1,0,0,0,287,290,1,0,0,0,288,
        286,1,0,0,0,288,289,1,0,0,0,289,292,1,0,0,0,290,288,1,0,0,0,291,
        282,1,0,0,0,291,292,1,0,0,0,292,294,1,0,0,0,293,274,1,0,0,0,293,
        280,1,0,0,0,294,25,1,0,0,0,295,297,3,128,64,0,296,298,3,28,14,0,
        297,296,1,0,0,0,297,298,1,0,0,0,298,27,1,0,0,0,299,300,5,108,0,0,
        300,305,3,30,15,0,301,302,5,100,0,0,302,304,3,30,15,0,303,301,1,
        0,0,0,304,307,1,0,0,0,305,303,1,0,0,0,305,306,1,0,0,0,306,308,1,
        0,0,0,307,305,1,0,0,0,308,309,5,109,0,0,309,29,1,0,0,0,310,311,5,
        10,0,0,311,318,3,128,64,0,312,313,5,11,0,0,313,318,3,26,13,0,314,
        315,5,3,0,0,315,318,3,128,64,0,316,318,3,112,56,0,317,310,1,0,0,
        0,317,312,1,0,0,0,317,314,1,0,0,0,317,316,1,0,0,0,318,31,1,0,0,0,
        319,320,5,2,0,0,320,322,3,128,64,0,321,323,3,22,11,0,322,321,1,0,
        0,0,322,323,1,0,0,0,323,324,1,0,0,0,324,325,5,111,0,0,325,326,3,
        112,56,0,326,327,5,99,0,0,327,33,1,0,0,0,328,332,3,38,19,0,329,332,
        3,42,21,0,330,332,3,36,18,0,331,328,1,0,0,0,331,329,1,0,0,0,331,
        330,1,0,0,0,332,35,1,0,0,0,333,335,5,24,0,0,334,333,1,0,0,0,334,
        335,1,0,0,0,335,336,1,0,0,0,336,337,5,16,0,0,337,338,3,128,64,0,
        338,339,5,49,0,0,339,340,3,130,65,0,340,341,5,98,0,0,341,342,3,112,
        56,0,342,343,5,97,0,0,343,344,3,112,56,0,344,345,5,102,0,0,345,346,
        5,66,0,0,346,347,5,49,0,0,347,348,3,130,65,0,348,349,5,99,0,0,349,
        350,5,103,0,0,350,37,1,0,0,0,351,352,5,14,0,0,352,353,3,128,64,0,
        353,354,5,49,0,0,354,355,3,130,65,0,355,356,5,98,0,0,356,357,3,112,
        56,0,357,361,5,102,0,0,358,360,3,40,20,0,359,358,1,0,0,0,360,363,
        1,0,0,0,361,359,1,0,0,0,361,362,1,0,0,0,362,364,1,0,0,0,363,361,
        1,0,0,0,364,365,5,103,0,0,365,39,1,0,0,0,366,367,5,56,0,0,367,368,
        5,49,0,0,368,369,3,130,65,0,369,370,5,99,0,0,370,386,1,0,0,0,371,
        372,5,57,0,0,372,373,5,49,0,0,373,374,3,130,65,0,374,375,5,99,0,
        0,375,386,1,0,0,0,376,377,5,58,0,0,377,378,5,59,0,0,378,379,5,49,
        0,0,379,380,3,130,65,0,380,381,5,60,0,0,381,382,5,49,0,0,382,383,
        3,130,65,0,383,384,5,99,0,0,384,386,1,0,0,0,385,366,1,0,0,0,385,
        371,1,0,0,0,385,376,1,0,0,0,386,41,1,0,0,0,387,388,5,15,0,0,388,
        389,3,128,64,0,389,390,5,49,0,0,390,391,3,130,65,0,391,392,5,98,
        0,0,392,393,3,118,59,0,393,395,3,46,23,0,394,396,5,77,0,0,395,394,
        1,0,0,0,395,396,1,0,0,0,396,397,1,0,0,0,397,401,5,102,0,0,398,400,
        3,44,22,0,399,398,1,0,0,0,400,403,1,0,0,0,401,399,1,0,0,0,401,402,
        1,0,0,0,402,404,1,0,0,0,403,401,1,0,0,0,404,405,5,103,0,0,405,43,
        1,0,0,0,406,407,5,63,0,0,407,408,5,49,0,0,408,409,3,130,65,0,409,
        410,5,99,0,0,410,431,1,0,0,0,411,412,5,64,0,0,412,413,5,49,0,0,413,
        414,3,130,65,0,414,415,5,99,0,0,415,431,1,0,0,0,416,417,5,65,0,0,
        417,418,5,49,0,0,418,419,3,130,65,0,419,420,5,99,0,0,420,431,1,0,
        0,0,421,422,5,58,0,0,422,423,5,59,0,0,423,424,5,49,0,0,424,425,3,
        130,65,0,425,426,5,60,0,0,426,427,5,49,0,0,427,428,3,130,65,0,428,
        429,5,99,0,0,429,431,1,0,0,0,430,406,1,0,0,0,430,411,1,0,0,0,430,
        416,1,0,0,0,430,421,1,0,0,0,431,45,1,0,0,0,432,433,5,10,0,0,433,
        442,3,128,64,0,434,435,5,11,0,0,435,437,3,128,64,0,436,438,3,28,
        14,0,437,436,1,0,0,0,437,438,1,0,0,0,438,442,1,0,0,0,439,440,5,3,
        0,0,440,442,3,128,64,0,441,432,1,0,0,0,441,434,1,0,0,0,441,439,1,
        0,0,0,442,47,1,0,0,0,443,445,3,16,8,0,444,443,1,0,0,0,445,448,1,
        0,0,0,446,444,1,0,0,0,446,447,1,0,0,0,447,449,1,0,0,0,448,446,1,
        0,0,0,449,450,5,13,0,0,450,451,3,128,64,0,451,452,5,49,0,0,452,453,
        3,130,65,0,453,454,5,43,0,0,454,457,3,130,65,0,455,456,5,44,0,0,
        456,458,5,112,0,0,457,455,1,0,0,0,457,458,1,0,0,0,458,459,1,0,0,
        0,459,463,5,102,0,0,460,462,3,50,25,0,461,460,1,0,0,0,462,465,1,
        0,0,0,463,461,1,0,0,0,463,464,1,0,0,0,464,466,1,0,0,0,465,463,1,
        0,0,0,466,467,5,103,0,0,467,49,1,0,0,0,468,472,3,52,26,0,469,472,
        3,54,27,0,470,472,3,56,28,0,471,468,1,0,0,0,471,469,1,0,0,0,471,
        470,1,0,0,0,472,51,1,0,0,0,473,474,5,16,0,0,474,476,3,128,64,0,475,
        477,3,22,11,0,476,475,1,0,0,0,476,477,1,0,0,0,477,478,1,0,0,0,478,
        479,5,49,0,0,479,480,3,130,65,0,480,481,5,98,0,0,481,482,3,112,56,
        0,482,483,5,97,0,0,483,484,3,112,56,0,484,485,5,51,0,0,485,487,3,
        60,30,0,486,488,3,58,29,0,487,486,1,0,0,0,487,488,1,0,0,0,488,489,
        1,0,0,0,489,490,5,53,0,0,490,492,3,62,31,0,491,493,3,66,33,0,492,
        491,1,0,0,0,492,493,1,0,0,0,493,494,1,0,0,0,494,495,5,99,0,0,495,
        53,1,0,0,0,496,497,5,17,0,0,497,499,3,128,64,0,498,500,3,22,11,0,
        499,498,1,0,0,0,499,500,1,0,0,0,500,501,1,0,0,0,501,502,5,49,0,0,
        502,503,3,130,65,0,503,504,5,98,0,0,504,505,3,112,56,0,505,506,5,
        97,0,0,506,508,3,112,56,0,507,509,3,66,33,0,508,507,1,0,0,0,508,
        509,1,0,0,0,509,510,1,0,0,0,510,511,5,99,0,0,511,55,1,0,0,0,512,
        513,5,18,0,0,513,514,3,128,64,0,514,515,5,49,0,0,515,516,3,130,65,
        0,516,517,5,19,0,0,517,518,3,128,64,0,518,519,5,98,0,0,519,521,3,
        112,56,0,520,522,3,66,33,0,521,520,1,0,0,0,521,522,1,0,0,0,522,523,
        1,0,0,0,523,524,5,99,0,0,524,57,1,0,0,0,525,526,5,52,0,0,526,527,
        3,112,56,0,527,59,1,0,0,0,528,529,7,0,0,0,529,61,1,0,0,0,530,549,
        5,55,0,0,531,532,5,10,0,0,532,549,3,128,64,0,533,534,5,3,0,0,534,
        549,3,128,64,0,535,536,5,12,0,0,536,545,5,104,0,0,537,542,3,26,13,
        0,538,539,5,100,0,0,539,541,3,26,13,0,540,538,1,0,0,0,541,544,1,
        0,0,0,542,540,1,0,0,0,542,543,1,0,0,0,543,546,1,0,0,0,544,542,1,
        0,0,0,545,537,1,0,0,0,545,546,1,0,0,0,546,547,1,0,0,0,547,549,5,
        105,0,0,548,530,1,0,0,0,548,531,1,0,0,0,548,533,1,0,0,0,548,535,
        1,0,0,0,549,63,1,0,0,0,550,555,3,128,64,0,551,552,5,100,0,0,552,
        554,3,128,64,0,553,551,1,0,0,0,554,557,1,0,0,0,555,553,1,0,0,0,555,
        556,1,0,0,0,556,65,1,0,0,0,557,555,1,0,0,0,558,559,5,54,0,0,559,
        563,5,102,0,0,560,562,3,68,34,0,561,560,1,0,0,0,562,565,1,0,0,0,
        563,561,1,0,0,0,563,564,1,0,0,0,564,566,1,0,0,0,565,563,1,0,0,0,
        566,567,5,103,0,0,567,67,1,0,0,0,568,569,5,28,0,0,569,570,3,128,
        64,0,570,571,5,49,0,0,571,572,3,130,65,0,572,573,5,98,0,0,573,574,
        3,112,56,0,574,575,3,70,35,0,575,576,5,99,0,0,576,611,1,0,0,0,577,
        578,5,29,0,0,578,579,3,128,64,0,579,580,5,49,0,0,580,581,3,130,65,
        0,581,582,5,98,0,0,582,583,3,118,59,0,583,584,3,46,23,0,584,585,
        3,70,35,0,585,586,5,99,0,0,586,611,1,0,0,0,587,588,5,11,0,0,588,
        589,3,128,64,0,589,590,5,49,0,0,590,591,3,130,65,0,591,592,5,98,
        0,0,592,594,3,128,64,0,593,595,3,28,14,0,594,593,1,0,0,0,594,595,
        1,0,0,0,595,596,1,0,0,0,596,597,5,99,0,0,597,611,1,0,0,0,598,599,
        5,18,0,0,599,600,3,128,64,0,600,601,5,49,0,0,601,602,3,130,65,0,
        602,603,5,98,0,0,603,606,3,128,64,0,604,605,5,20,0,0,605,607,3,112,
        56,0,606,604,1,0,0,0,606,607,1,0,0,0,607,608,1,0,0,0,608,609,5,99,
        0,0,609,611,1,0,0,0,610,568,1,0,0,0,610,577,1,0,0,0,610,587,1,0,
        0,0,610,598,1,0,0,0,611,69,1,0,0,0,612,613,5,104,0,0,613,618,3,72,
        36,0,614,615,5,100,0,0,615,617,3,72,36,0,616,614,1,0,0,0,617,620,
        1,0,0,0,618,616,1,0,0,0,618,619,1,0,0,0,619,621,1,0,0,0,620,618,
        1,0,0,0,621,622,5,105,0,0,622,71,1,0,0,0,623,624,7,1,0,0,624,73,
        1,0,0,0,625,626,5,27,0,0,626,627,3,76,38,0,627,75,1,0,0,0,628,631,
        3,78,39,0,629,631,3,82,41,0,630,628,1,0,0,0,630,629,1,0,0,0,631,
        77,1,0,0,0,632,633,5,28,0,0,633,634,3,128,64,0,634,635,5,49,0,0,
        635,636,3,130,65,0,636,637,5,37,0,0,637,638,3,128,64,0,638,639,5,
        98,0,0,639,640,3,112,56,0,640,641,5,38,0,0,641,644,3,80,40,0,642,
        643,5,39,0,0,643,645,3,120,60,0,644,642,1,0,0,0,644,645,1,0,0,0,
        645,646,1,0,0,0,646,647,5,99,0,0,647,79,1,0,0,0,648,655,5,71,0,0,
        649,650,5,72,0,0,650,651,5,106,0,0,651,652,3,112,56,0,652,653,5,
        107,0,0,653,655,1,0,0,0,654,648,1,0,0,0,654,649,1,0,0,0,655,81,1,
        0,0,0,656,657,5,29,0,0,657,658,3,128,64,0,658,659,5,49,0,0,659,660,
        3,130,65,0,660,661,5,102,0,0,661,662,3,84,42,0,662,663,3,84,42,0,
        663,664,5,103,0,0,664,83,1,0,0,0,665,666,3,46,23,0,666,667,5,30,
        0,0,667,668,3,128,64,0,668,669,5,49,0,0,669,670,3,130,65,0,670,672,
        3,118,59,0,671,673,5,77,0,0,672,671,1,0,0,0,672,673,1,0,0,0,673,
        676,1,0,0,0,674,675,5,45,0,0,675,677,3,130,65,0,676,674,1,0,0,0,
        676,677,1,0,0,0,677,679,1,0,0,0,678,680,5,46,0,0,679,678,1,0,0,0,
        679,680,1,0,0,0,680,683,1,0,0,0,681,682,5,47,0,0,682,684,3,130,65,
        0,683,681,1,0,0,0,683,684,1,0,0,0,684,686,1,0,0,0,685,687,5,48,0,
        0,686,685,1,0,0,0,686,687,1,0,0,0,687,688,1,0,0,0,688,689,5,99,0,
        0,689,85,1,0,0,0,690,691,5,21,0,0,691,692,3,128,64,0,692,693,5,22,
        0,0,693,695,3,128,64,0,694,696,3,28,14,0,695,694,1,0,0,0,695,696,
        1,0,0,0,696,699,1,0,0,0,697,698,5,49,0,0,698,700,3,130,65,0,699,
        697,1,0,0,0,699,700,1,0,0,0,700,703,1,0,0,0,701,702,5,44,0,0,702,
        704,5,112,0,0,703,701,1,0,0,0,703,704,1,0,0,0,704,705,1,0,0,0,705,
        709,5,102,0,0,706,708,3,88,44,0,707,706,1,0,0,0,708,711,1,0,0,0,
        709,707,1,0,0,0,709,710,1,0,0,0,710,712,1,0,0,0,711,709,1,0,0,0,
        712,713,5,103,0,0,713,87,1,0,0,0,714,715,5,26,0,0,715,720,3,76,38,
        0,716,720,3,94,47,0,717,720,3,90,45,0,718,720,3,92,46,0,719,714,
        1,0,0,0,719,716,1,0,0,0,719,717,1,0,0,0,719,718,1,0,0,0,720,89,1,
        0,0,0,721,722,5,23,0,0,722,723,3,128,64,0,723,724,5,25,0,0,724,725,
        5,28,0,0,725,726,3,128,64,0,726,727,5,99,0,0,727,91,1,0,0,0,728,
        729,5,34,0,0,729,730,3,128,64,0,730,731,5,35,0,0,731,732,5,36,0,
        0,732,733,5,32,0,0,733,734,5,18,0,0,734,735,3,128,64,0,735,736,5,
        33,0,0,736,737,5,29,0,0,737,738,3,128,64,0,738,739,5,101,0,0,739,
        740,3,128,64,0,740,741,5,99,0,0,741,93,1,0,0,0,742,743,5,23,0,0,
        743,744,3,96,48,0,744,745,5,25,0,0,745,746,3,100,50,0,746,747,5,
        99,0,0,747,95,1,0,0,0,748,749,3,128,64,0,749,750,5,101,0,0,750,751,
        3,98,49,0,751,97,1,0,0,0,752,764,3,128,64,0,753,764,5,66,0,0,754,
        764,5,56,0,0,755,764,5,57,0,0,756,764,5,63,0,0,757,764,5,64,0,0,
        758,764,5,65,0,0,759,764,5,67,0,0,760,764,5,68,0,0,761,764,5,69,
        0,0,762,764,5,70,0,0,763,752,1,0,0,0,763,753,1,0,0,0,763,754,1,0,
        0,0,763,755,1,0,0,0,763,756,1,0,0,0,763,757,1,0,0,0,763,758,1,0,
        0,0,763,759,1,0,0,0,763,760,1,0,0,0,763,761,1,0,0,0,763,762,1,0,
        0,0,764,99,1,0,0,0,765,766,5,28,0,0,766,767,3,128,64,0,767,768,5,
        101,0,0,768,769,3,102,51,0,769,788,1,0,0,0,770,771,5,29,0,0,771,
        772,3,128,64,0,772,773,5,101,0,0,773,774,3,128,64,0,774,775,5,101,
        0,0,775,776,3,104,52,0,776,788,1,0,0,0,777,778,5,13,0,0,778,779,
        3,128,64,0,779,780,5,101,0,0,780,782,3,128,64,0,781,783,3,28,14,
        0,782,781,1,0,0,0,782,783,1,0,0,0,783,785,1,0,0,0,784,786,3,106,
        53,0,785,784,1,0,0,0,785,786,1,0,0,0,786,788,1,0,0,0,787,765,1,0,
        0,0,787,770,1,0,0,0,787,777,1,0,0,0,788,101,1,0,0,0,789,790,7,2,
        0,0,790,103,1,0,0,0,791,792,7,3,0,0,792,105,1,0,0,0,793,794,5,31,
        0,0,794,798,5,102,0,0,795,797,3,108,54,0,796,795,1,0,0,0,797,800,
        1,0,0,0,798,796,1,0,0,0,798,799,1,0,0,0,799,801,1,0,0,0,800,798,
        1,0,0,0,801,802,5,103,0,0,802,107,1,0,0,0,803,804,3,128,64,0,804,
        805,5,25,0,0,805,806,5,28,0,0,806,813,3,128,64,0,807,808,5,33,0,
        0,808,809,5,29,0,0,809,810,3,128,64,0,810,811,5,101,0,0,811,812,
        3,128,64,0,812,814,1,0,0,0,813,807,1,0,0,0,813,814,1,0,0,0,814,815,
        1,0,0,0,815,816,5,99,0,0,816,857,1,0,0,0,817,818,3,128,64,0,818,
        819,5,25,0,0,819,820,5,29,0,0,820,821,3,128,64,0,821,822,5,101,0,
        0,822,829,3,128,64,0,823,824,5,33,0,0,824,825,5,29,0,0,825,826,3,
        128,64,0,826,827,5,101,0,0,827,828,3,128,64,0,828,830,1,0,0,0,829,
        823,1,0,0,0,829,830,1,0,0,0,830,831,1,0,0,0,831,832,5,99,0,0,832,
        857,1,0,0,0,833,834,3,128,64,0,834,835,5,25,0,0,835,836,5,11,0,0,
        836,838,3,128,64,0,837,839,3,28,14,0,838,837,1,0,0,0,838,839,1,0,
        0,0,839,846,1,0,0,0,840,841,5,33,0,0,841,842,5,29,0,0,842,843,3,
        128,64,0,843,844,5,101,0,0,844,845,3,128,64,0,845,847,1,0,0,0,846,
        840,1,0,0,0,846,847,1,0,0,0,847,848,1,0,0,0,848,849,5,99,0,0,849,
        857,1,0,0,0,850,851,3,128,64,0,851,852,5,25,0,0,852,853,5,18,0,0,
        853,854,3,128,64,0,854,855,5,99,0,0,855,857,1,0,0,0,856,803,1,0,
        0,0,856,817,1,0,0,0,856,833,1,0,0,0,856,850,1,0,0,0,857,109,1,0,
        0,0,858,859,5,18,0,0,859,860,3,128,64,0,860,861,5,25,0,0,861,862,
        3,128,64,0,862,863,5,101,0,0,863,865,3,128,64,0,864,866,3,106,53,
        0,865,864,1,0,0,0,865,866,1,0,0,0,866,867,1,0,0,0,867,868,5,99,0,
        0,868,111,1,0,0,0,869,916,3,116,58,0,870,916,5,78,0,0,871,916,5,
        79,0,0,872,873,5,80,0,0,873,916,3,130,65,0,874,875,5,81,0,0,875,
        876,5,108,0,0,876,877,3,128,64,0,877,878,5,109,0,0,878,916,1,0,0,
        0,879,880,5,82,0,0,880,881,5,108,0,0,881,883,3,128,64,0,882,884,
        3,28,14,0,883,882,1,0,0,0,883,884,1,0,0,0,884,885,1,0,0,0,885,886,
        5,109,0,0,886,916,1,0,0,0,887,888,5,6,0,0,888,889,5,108,0,0,889,
        890,3,128,64,0,890,891,5,109,0,0,891,916,1,0,0,0,892,893,5,83,0,
        0,893,894,5,108,0,0,894,895,3,112,56,0,895,896,5,109,0,0,896,916,
        1,0,0,0,897,898,5,84,0,0,898,899,5,108,0,0,899,900,3,112,56,0,900,
        901,5,109,0,0,901,916,1,0,0,0,902,903,5,85,0,0,903,907,5,102,0,0,
        904,906,3,114,57,0,905,904,1,0,0,0,906,909,1,0,0,0,907,905,1,0,0,
        0,907,908,1,0,0,0,908,910,1,0,0,0,909,907,1,0,0,0,910,916,5,103,
        0,0,911,913,3,128,64,0,912,914,3,28,14,0,913,912,1,0,0,0,913,914,
        1,0,0,0,914,916,1,0,0,0,915,869,1,0,0,0,915,870,1,0,0,0,915,871,
        1,0,0,0,915,872,1,0,0,0,915,874,1,0,0,0,915,879,1,0,0,0,915,887,
        1,0,0,0,915,892,1,0,0,0,915,897,1,0,0,0,915,902,1,0,0,0,915,911,
        1,0,0,0,916,113,1,0,0,0,917,918,3,128,64,0,918,919,5,98,0,0,919,
        920,3,112,56,0,920,921,5,99,0,0,921,115,1,0,0,0,922,923,7,4,0,0,
        923,117,1,0,0,0,924,925,7,5,0,0,925,119,1,0,0,0,926,935,3,130,65,
        0,927,935,5,112,0,0,928,935,5,113,0,0,929,935,5,94,0,0,930,935,5,
        95,0,0,931,935,5,96,0,0,932,935,3,122,61,0,933,935,3,126,63,0,934,
        926,1,0,0,0,934,927,1,0,0,0,934,928,1,0,0,0,934,929,1,0,0,0,934,
        930,1,0,0,0,934,931,1,0,0,0,934,932,1,0,0,0,934,933,1,0,0,0,935,
        121,1,0,0,0,936,945,5,102,0,0,937,942,3,124,62,0,938,939,5,100,0,
        0,939,941,3,124,62,0,940,938,1,0,0,0,941,944,1,0,0,0,942,940,1,0,
        0,0,942,943,1,0,0,0,943,946,1,0,0,0,944,942,1,0,0,0,945,937,1,0,
        0,0,945,946,1,0,0,0,946,947,1,0,0,0,947,948,5,103,0,0,948,123,1,
        0,0,0,949,950,3,130,65,0,950,951,5,98,0,0,951,952,3,120,60,0,952,
        125,1,0,0,0,953,962,5,104,0,0,954,959,3,120,60,0,955,956,5,100,0,
        0,956,958,3,120,60,0,957,955,1,0,0,0,958,961,1,0,0,0,959,957,1,0,
        0,0,959,960,1,0,0,0,960,963,1,0,0,0,961,959,1,0,0,0,962,954,1,0,
        0,0,962,963,1,0,0,0,963,964,1,0,0,0,964,965,5,105,0,0,965,127,1,
        0,0,0,966,967,7,6,0,0,967,129,1,0,0,0,968,969,5,115,0,0,969,131,
        1,0,0,0,82,144,151,172,184,196,216,224,231,237,249,252,258,269,278,
        288,291,293,297,305,317,322,331,334,361,385,395,401,430,437,441,
        446,457,463,471,476,487,492,499,508,521,542,545,548,555,563,594,
        606,610,618,630,644,654,672,676,679,683,686,695,699,703,709,719,
        763,782,785,787,798,813,829,838,846,856,865,883,907,913,915,934,
        942,945,959,962
    ];

    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 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 override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_interfaceMember;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitInterfaceMember) {
            return visitor.visitInterfaceMember(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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

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

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


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

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


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

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


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

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


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

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


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


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

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


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

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


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

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


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


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


export class ReceiverRequirementContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ANY(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ANY, 0);
    }
    public ATOM(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.ATOM, 0);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public 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 STATE(): antlr.TerminalNode | null {
        return this.getToken(QuixosCapabilityParser.STATE, 0);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

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


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

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


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


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


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


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

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


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


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

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


export class EdgeEndpointContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public targetConstraint(): TargetConstraintContext {
        return this.getRuleContext(0, TargetConstraintContext)!;
    }
    public PROJECTION(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.PROJECTION, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public ID(): antlr.TerminalNode {
        return this.getToken(QuixosCapabilityParser.ID, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    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 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 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 relationshipMaterializationDecl(): RelationshipMaterializationDeclContext | null {
        return this.getRuleContext(0, RelationshipMaterializationDeclContext);
    }
    public override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_conformanceItem;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitConformanceItem) {
            return visitor.visitConformanceItem(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class 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 override get ruleIndex(): number {
        return QuixosCapabilityParser.RULE_operationBindingDecl;
    }
    public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
        if (visitor.visitOperationBindingDecl) {
            return visitor.visitOperationBindingDecl(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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

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


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


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


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

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


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

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


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

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


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


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