import { ATN, DFA, FailedPredicateException, Parser, ParserRuleContext, TerminalNode, Token, TokenStream } from 'antlr4';
import CypherCmdParserListener from "./CypherCmdParserListener.js";
import CypherCmdParserVisitor from "./CypherCmdParserVisitor.js";
export default class CypherCmdParser extends Parser {
    static readonly PARAM = 1;
    static readonly CLEAR = 2;
    static readonly HISTORY = 3;
    static readonly EXPLAIN = 4;
    static readonly PROFILE = 5;
    static readonly SPACE = 6;
    static readonly SINGLE_LINE_COMMENT = 7;
    static readonly MULTI_LINE_COMMENT = 8;
    static readonly DECIMAL_DOUBLE = 9;
    static readonly UNSIGNED_DECIMAL_INTEGER = 10;
    static readonly UNSIGNED_HEX_INTEGER = 11;
    static readonly UNSIGNED_OCTAL_INTEGER = 12;
    static readonly STRING_LITERAL1 = 13;
    static readonly STRING_LITERAL2 = 14;
    static readonly ESCAPED_SYMBOLIC_NAME = 15;
    static readonly ACCESS = 16;
    static readonly ACTIVE = 17;
    static readonly ADMIN = 18;
    static readonly ADMINISTRATOR = 19;
    static readonly ALIAS = 20;
    static readonly ALIASES = 21;
    static readonly ALL_SHORTEST_PATHS = 22;
    static readonly ALL = 23;
    static readonly ALTER = 24;
    static readonly AND = 25;
    static readonly ANY = 26;
    static readonly ARRAY = 27;
    static readonly AS = 28;
    static readonly ASC = 29;
    static readonly ASCENDING = 30;
    static readonly ASSERT = 31;
    static readonly ASSIGN = 32;
    static readonly AT = 33;
    static readonly BAR = 34;
    static readonly BINDINGS = 35;
    static readonly BOOL = 36;
    static readonly BOOLEAN = 37;
    static readonly BOOSTED = 38;
    static readonly BOTH = 39;
    static readonly BREAK = 40;
    static readonly BRIEF = 41;
    static readonly BTREE = 42;
    static readonly BUILT = 43;
    static readonly BY = 44;
    static readonly CALL = 45;
    static readonly CASE = 46;
    static readonly CHANGE = 47;
    static readonly CIDR = 48;
    static readonly COLLECT = 49;
    static readonly COLON = 50;
    static readonly COLONCOLON = 51;
    static readonly COMMA = 52;
    static readonly COMMAND = 53;
    static readonly COMMANDS = 54;
    static readonly COMMIT = 55;
    static readonly COMPOSITE = 56;
    static readonly CONCURRENT = 57;
    static readonly CONSTRAINT = 58;
    static readonly CONSTRAINTS = 59;
    static readonly CONTAINS = 60;
    static readonly COPY = 61;
    static readonly CONTINUE = 62;
    static readonly COUNT = 63;
    static readonly CREATE = 64;
    static readonly CSV = 65;
    static readonly CURRENT = 66;
    static readonly DATA = 67;
    static readonly DATABASE = 68;
    static readonly DATABASES = 69;
    static readonly DATE = 70;
    static readonly DATETIME = 71;
    static readonly DBMS = 72;
    static readonly DEALLOCATE = 73;
    static readonly DEFAULT = 74;
    static readonly DEFINED = 75;
    static readonly DELETE = 76;
    static readonly DENY = 77;
    static readonly DESC = 78;
    static readonly DESCENDING = 79;
    static readonly DESTROY = 80;
    static readonly DETACH = 81;
    static readonly DIFFERENT = 82;
    static readonly DOLLAR = 83;
    static readonly DISTINCT = 84;
    static readonly DIVIDE = 85;
    static readonly DOT = 86;
    static readonly DOTDOT = 87;
    static readonly DOUBLEBAR = 88;
    static readonly DRIVER = 89;
    static readonly DROP = 90;
    static readonly DRYRUN = 91;
    static readonly DUMP = 92;
    static readonly DURATION = 93;
    static readonly EACH = 94;
    static readonly EDGE = 95;
    static readonly ENABLE = 96;
    static readonly ELEMENT = 97;
    static readonly ELEMENTS = 98;
    static readonly ELSE = 99;
    static readonly ENCRYPTED = 100;
    static readonly END = 101;
    static readonly ENDS = 102;
    static readonly EQ = 103;
    static readonly EXECUTABLE = 104;
    static readonly EXECUTE = 105;
    static readonly EXIST = 106;
    static readonly EXISTENCE = 107;
    static readonly EXISTS = 108;
    static readonly ERROR = 109;
    static readonly FAIL = 110;
    static readonly FALSE = 111;
    static readonly FIELDTERMINATOR = 112;
    static readonly FINISH = 113;
    static readonly FLOAT = 114;
    static readonly FOR = 115;
    static readonly FOREACH = 116;
    static readonly FROM = 117;
    static readonly FULLTEXT = 118;
    static readonly FUNCTION = 119;
    static readonly FUNCTIONS = 120;
    static readonly GE = 121;
    static readonly GRANT = 122;
    static readonly GRAPH = 123;
    static readonly GRAPHS = 124;
    static readonly GROUP = 125;
    static readonly GROUPS = 126;
    static readonly GT = 127;
    static readonly HEADERS = 128;
    static readonly HOME = 129;
    static readonly IF = 130;
    static readonly IMPERSONATE = 131;
    static readonly IMMUTABLE = 132;
    static readonly IN = 133;
    static readonly INDEX = 134;
    static readonly INDEXES = 135;
    static readonly INF = 136;
    static readonly INFINITY = 137;
    static readonly INSERT = 138;
    static readonly INT = 139;
    static readonly INTEGER = 140;
    static readonly IS = 141;
    static readonly JOIN = 142;
    static readonly KEY = 143;
    static readonly LABEL = 144;
    static readonly LABELS = 145;
    static readonly AMPERSAND = 146;
    static readonly EXCLAMATION_MARK = 147;
    static readonly LBRACKET = 148;
    static readonly LCURLY = 149;
    static readonly LE = 150;
    static readonly LEADING = 151;
    static readonly LIMITROWS = 152;
    static readonly LIST = 153;
    static readonly LOAD = 154;
    static readonly LOCAL = 155;
    static readonly LOOKUP = 156;
    static readonly LPAREN = 157;
    static readonly LT = 158;
    static readonly MANAGEMENT = 159;
    static readonly MAP = 160;
    static readonly MATCH = 161;
    static readonly MERGE = 162;
    static readonly MINUS = 163;
    static readonly PERCENT = 164;
    static readonly INVALID_NEQ = 165;
    static readonly NEQ = 166;
    static readonly NAME = 167;
    static readonly NAMES = 168;
    static readonly NAN = 169;
    static readonly NFC = 170;
    static readonly NFD = 171;
    static readonly NFKC = 172;
    static readonly NFKD = 173;
    static readonly NEW = 174;
    static readonly NODE = 175;
    static readonly NODETACH = 176;
    static readonly NODES = 177;
    static readonly NONE = 178;
    static readonly NORMALIZE = 179;
    static readonly NORMALIZED = 180;
    static readonly NOT = 181;
    static readonly NOTHING = 182;
    static readonly NOWAIT = 183;
    static readonly NULL = 184;
    static readonly OF = 185;
    static readonly ON = 186;
    static readonly ONLY = 187;
    static readonly OPTIONAL = 188;
    static readonly OPTIONS = 189;
    static readonly OPTION = 190;
    static readonly OR = 191;
    static readonly ORDER = 192;
    static readonly OUTPUT = 193;
    static readonly PASSWORD = 194;
    static readonly PASSWORDS = 195;
    static readonly PATH = 196;
    static readonly PATHS = 197;
    static readonly PERIODIC = 198;
    static readonly PLAINTEXT = 199;
    static readonly PLUS = 200;
    static readonly PLUSEQUAL = 201;
    static readonly POINT = 202;
    static readonly POPULATED = 203;
    static readonly POW = 204;
    static readonly PRIMARY = 205;
    static readonly PRIMARIES = 206;
    static readonly PRIVILEGE = 207;
    static readonly PRIVILEGES = 208;
    static readonly PROCEDURE = 209;
    static readonly PROCEDURES = 210;
    static readonly PROPERTIES = 211;
    static readonly PROPERTY = 212;
    static readonly QUESTION = 213;
    static readonly RANGE = 214;
    static readonly RBRACKET = 215;
    static readonly RCURLY = 216;
    static readonly READ = 217;
    static readonly REALLOCATE = 218;
    static readonly REDUCE = 219;
    static readonly RENAME = 220;
    static readonly REGEQ = 221;
    static readonly REL = 222;
    static readonly RELATIONSHIP = 223;
    static readonly RELATIONSHIPS = 224;
    static readonly REMOVE = 225;
    static readonly REPEATABLE = 226;
    static readonly REPLACE = 227;
    static readonly REPORT = 228;
    static readonly REQUIRE = 229;
    static readonly REQUIRED = 230;
    static readonly RETURN = 231;
    static readonly REVOKE = 232;
    static readonly ROLE = 233;
    static readonly ROLES = 234;
    static readonly ROW = 235;
    static readonly ROWS = 236;
    static readonly RPAREN = 237;
    static readonly SCAN = 238;
    static readonly SEC = 239;
    static readonly SECOND = 240;
    static readonly SECONDARY = 241;
    static readonly SECONDARIES = 242;
    static readonly SECONDS = 243;
    static readonly SEEK = 244;
    static readonly SEMICOLON = 245;
    static readonly SERVER = 246;
    static readonly SERVERS = 247;
    static readonly SET = 248;
    static readonly SETTING = 249;
    static readonly SETTINGS = 250;
    static readonly SHORTEST_PATH = 251;
    static readonly SHORTEST = 252;
    static readonly SHOW = 253;
    static readonly SIGNED = 254;
    static readonly SINGLE = 255;
    static readonly SKIPROWS = 256;
    static readonly START = 257;
    static readonly STARTS = 258;
    static readonly STATUS = 259;
    static readonly STOP = 260;
    static readonly STRING = 261;
    static readonly SUPPORTED = 262;
    static readonly SUSPENDED = 263;
    static readonly TARGET = 264;
    static readonly TERMINATE = 265;
    static readonly TEXT = 266;
    static readonly THEN = 267;
    static readonly TIME = 268;
    static readonly TIMES = 269;
    static readonly TIMESTAMP = 270;
    static readonly TIMEZONE = 271;
    static readonly TO = 272;
    static readonly TOPOLOGY = 273;
    static readonly TRAILING = 274;
    static readonly TRANSACTION = 275;
    static readonly TRANSACTIONS = 276;
    static readonly TRAVERSE = 277;
    static readonly TRIM = 278;
    static readonly TRUE = 279;
    static readonly TYPE = 280;
    static readonly TYPED = 281;
    static readonly TYPES = 282;
    static readonly UNION = 283;
    static readonly UNIQUE = 284;
    static readonly UNIQUENESS = 285;
    static readonly UNWIND = 286;
    static readonly URL = 287;
    static readonly USE = 288;
    static readonly USER = 289;
    static readonly USERS = 290;
    static readonly USING = 291;
    static readonly VALUE = 292;
    static readonly VARCHAR = 293;
    static readonly VECTOR = 294;
    static readonly VERBOSE = 295;
    static readonly VERTEX = 296;
    static readonly WAIT = 297;
    static readonly WHEN = 298;
    static readonly WHERE = 299;
    static readonly WITH = 300;
    static readonly WITHOUT = 301;
    static readonly WRITE = 302;
    static readonly XOR = 303;
    static readonly YIELD = 304;
    static readonly ZONED = 305;
    static readonly IDENTIFIER = 306;
    static readonly ARROW_LINE = 307;
    static readonly ARROW_LEFT_HEAD = 308;
    static readonly ARROW_RIGHT_HEAD = 309;
    static readonly ErrorChar = 310;
    static readonly EOF: number;
    static readonly RULE_statementsOrCommands = 0;
    static readonly RULE_statementOrCommand = 1;
    static readonly RULE_consoleCommand = 2;
    static readonly RULE_paramsCmd = 3;
    static readonly RULE_paramsArgs = 4;
    static readonly RULE_lambda = 5;
    static readonly RULE_clearCmd = 6;
    static readonly RULE_historyCmd = 7;
    static readonly RULE_useCmd = 8;
    static readonly RULE_listCompletionRule = 9;
    static readonly RULE_useCompletionRule = 10;
    static readonly RULE_preparsedStatement = 11;
    static readonly RULE_preparserOption = 12;
    static readonly RULE_statements = 13;
    static readonly RULE_statement = 14;
    static readonly RULE_periodicCommitQueryHintFailure = 15;
    static readonly RULE_regularQuery = 16;
    static readonly RULE_singleQuery = 17;
    static readonly RULE_clause = 18;
    static readonly RULE_useClause = 19;
    static readonly RULE_graphReference = 20;
    static readonly RULE_finishClause = 21;
    static readonly RULE_returnClause = 22;
    static readonly RULE_returnBody = 23;
    static readonly RULE_returnItem = 24;
    static readonly RULE_returnItems = 25;
    static readonly RULE_orderItem = 26;
    static readonly RULE_ascToken = 27;
    static readonly RULE_descToken = 28;
    static readonly RULE_orderBy = 29;
    static readonly RULE_skip = 30;
    static readonly RULE_limit = 31;
    static readonly RULE_whereClause = 32;
    static readonly RULE_withClause = 33;
    static readonly RULE_createClause = 34;
    static readonly RULE_insertClause = 35;
    static readonly RULE_setClause = 36;
    static readonly RULE_setItem = 37;
    static readonly RULE_removeClause = 38;
    static readonly RULE_removeItem = 39;
    static readonly RULE_deleteClause = 40;
    static readonly RULE_matchClause = 41;
    static readonly RULE_matchMode = 42;
    static readonly RULE_hint = 43;
    static readonly RULE_mergeClause = 44;
    static readonly RULE_mergeAction = 45;
    static readonly RULE_unwindClause = 46;
    static readonly RULE_callClause = 47;
    static readonly RULE_procedureName = 48;
    static readonly RULE_procedureArgument = 49;
    static readonly RULE_procedureResultItem = 50;
    static readonly RULE_loadCSVClause = 51;
    static readonly RULE_foreachClause = 52;
    static readonly RULE_subqueryClause = 53;
    static readonly RULE_subqueryInTransactionsParameters = 54;
    static readonly RULE_subqueryInTransactionsBatchParameters = 55;
    static readonly RULE_subqueryInTransactionsErrorParameters = 56;
    static readonly RULE_subqueryInTransactionsReportParameters = 57;
    static readonly RULE_patternList = 58;
    static readonly RULE_insertPatternList = 59;
    static readonly RULE_pattern = 60;
    static readonly RULE_insertPattern = 61;
    static readonly RULE_quantifier = 62;
    static readonly RULE_anonymousPattern = 63;
    static readonly RULE_shortestPathPattern = 64;
    static readonly RULE_patternElement = 65;
    static readonly RULE_selector = 66;
    static readonly RULE_groupToken = 67;
    static readonly RULE_pathToken = 68;
    static readonly RULE_pathPatternNonEmpty = 69;
    static readonly RULE_nodePattern = 70;
    static readonly RULE_insertNodePattern = 71;
    static readonly RULE_parenthesizedPath = 72;
    static readonly RULE_nodeLabels = 73;
    static readonly RULE_nodeLabelsIs = 74;
    static readonly RULE_labelType = 75;
    static readonly RULE_relType = 76;
    static readonly RULE_labelOrRelType = 77;
    static readonly RULE_properties = 78;
    static readonly RULE_relationshipPattern = 79;
    static readonly RULE_insertRelationshipPattern = 80;
    static readonly RULE_leftArrow = 81;
    static readonly RULE_arrowLine = 82;
    static readonly RULE_rightArrow = 83;
    static readonly RULE_pathLength = 84;
    static readonly RULE_labelExpression = 85;
    static readonly RULE_labelExpression4 = 86;
    static readonly RULE_labelExpression4Is = 87;
    static readonly RULE_labelExpression3 = 88;
    static readonly RULE_labelExpression3Is = 89;
    static readonly RULE_labelExpression2 = 90;
    static readonly RULE_labelExpression2Is = 91;
    static readonly RULE_labelExpression1 = 92;
    static readonly RULE_labelExpression1Is = 93;
    static readonly RULE_insertNodeLabelExpression = 94;
    static readonly RULE_insertRelationshipLabelExpression = 95;
    static readonly RULE_expression = 96;
    static readonly RULE_expression11 = 97;
    static readonly RULE_expression10 = 98;
    static readonly RULE_expression9 = 99;
    static readonly RULE_expression8 = 100;
    static readonly RULE_expression7 = 101;
    static readonly RULE_comparisonExpression6 = 102;
    static readonly RULE_normalForm = 103;
    static readonly RULE_expression6 = 104;
    static readonly RULE_expression5 = 105;
    static readonly RULE_expression4 = 106;
    static readonly RULE_expression3 = 107;
    static readonly RULE_expression2 = 108;
    static readonly RULE_postFix = 109;
    static readonly RULE_property = 110;
    static readonly RULE_propertyExpression = 111;
    static readonly RULE_expression1 = 112;
    static readonly RULE_literal = 113;
    static readonly RULE_caseExpression = 114;
    static readonly RULE_caseAlternative = 115;
    static readonly RULE_extendedCaseExpression = 116;
    static readonly RULE_extendedCaseAlternative = 117;
    static readonly RULE_extendedWhen = 118;
    static readonly RULE_listComprehension = 119;
    static readonly RULE_patternComprehension = 120;
    static readonly RULE_reduceExpression = 121;
    static readonly RULE_listItemsPredicate = 122;
    static readonly RULE_normalizeFunction = 123;
    static readonly RULE_trimFunction = 124;
    static readonly RULE_patternExpression = 125;
    static readonly RULE_shortestPathExpression = 126;
    static readonly RULE_parenthesizedExpression = 127;
    static readonly RULE_mapProjection = 128;
    static readonly RULE_mapProjectionElement = 129;
    static readonly RULE_countStar = 130;
    static readonly RULE_existsExpression = 131;
    static readonly RULE_countExpression = 132;
    static readonly RULE_collectExpression = 133;
    static readonly RULE_numberLiteral = 134;
    static readonly RULE_signedIntegerLiteral = 135;
    static readonly RULE_listLiteral = 136;
    static readonly RULE_propertyKeyName = 137;
    static readonly RULE_parameter = 138;
    static readonly RULE_parameterName = 139;
    static readonly RULE_functionInvocation = 140;
    static readonly RULE_functionArgument = 141;
    static readonly RULE_functionName = 142;
    static readonly RULE_namespace = 143;
    static readonly RULE_variable = 144;
    static readonly RULE_nonEmptyNameList = 145;
    static readonly RULE_command = 146;
    static readonly RULE_createCommand = 147;
    static readonly RULE_dropCommand = 148;
    static readonly RULE_alterCommand = 149;
    static readonly RULE_renameCommand = 150;
    static readonly RULE_showCommand = 151;
    static readonly RULE_showCommandYield = 152;
    static readonly RULE_yieldItem = 153;
    static readonly RULE_yieldSkip = 154;
    static readonly RULE_yieldLimit = 155;
    static readonly RULE_yieldClause = 156;
    static readonly RULE_showBriefAndYield = 157;
    static readonly RULE_showIndexCommand = 158;
    static readonly RULE_showIndexesAllowBrief = 159;
    static readonly RULE_showIndexesNoBrief = 160;
    static readonly RULE_showConstraintCommand = 161;
    static readonly RULE_constraintAllowYieldType = 162;
    static readonly RULE_constraintExistType = 163;
    static readonly RULE_constraintBriefAndYieldType = 164;
    static readonly RULE_showConstraintsAllowBriefAndYield = 165;
    static readonly RULE_showConstraintsAllowBrief = 166;
    static readonly RULE_showConstraintsAllowYield = 167;
    static readonly RULE_showProcedures = 168;
    static readonly RULE_showFunctions = 169;
    static readonly RULE_functionToken = 170;
    static readonly RULE_executableBy = 171;
    static readonly RULE_showFunctionsType = 172;
    static readonly RULE_showTransactions = 173;
    static readonly RULE_terminateCommand = 174;
    static readonly RULE_terminateTransactions = 175;
    static readonly RULE_showSettings = 176;
    static readonly RULE_settingToken = 177;
    static readonly RULE_namesAndClauses = 178;
    static readonly RULE_composableCommandClauses = 179;
    static readonly RULE_composableShowCommandClauses = 180;
    static readonly RULE_stringsOrExpression = 181;
    static readonly RULE_type = 182;
    static readonly RULE_typePart = 183;
    static readonly RULE_typeName = 184;
    static readonly RULE_typeNullability = 185;
    static readonly RULE_typeListSuffix = 186;
    static readonly RULE_commandNodePattern = 187;
    static readonly RULE_commandRelPattern = 188;
    static readonly RULE_createConstraint = 189;
    static readonly RULE_constraintType = 190;
    static readonly RULE_dropConstraint = 191;
    static readonly RULE_createIndex = 192;
    static readonly RULE_oldCreateIndex = 193;
    static readonly RULE_createIndex_ = 194;
    static readonly RULE_createFulltextIndex = 195;
    static readonly RULE_fulltextNodePattern = 196;
    static readonly RULE_fulltextRelPattern = 197;
    static readonly RULE_createLookupIndex = 198;
    static readonly RULE_lookupIndexNodePattern = 199;
    static readonly RULE_lookupIndexRelPattern = 200;
    static readonly RULE_dropIndex = 201;
    static readonly RULE_propertyList = 202;
    static readonly RULE_enableServerCommand = 203;
    static readonly RULE_alterServer = 204;
    static readonly RULE_renameServer = 205;
    static readonly RULE_dropServer = 206;
    static readonly RULE_showServers = 207;
    static readonly RULE_allocationCommand = 208;
    static readonly RULE_deallocateDatabaseFromServers = 209;
    static readonly RULE_reallocateDatabases = 210;
    static readonly RULE_createRole = 211;
    static readonly RULE_dropRole = 212;
    static readonly RULE_renameRole = 213;
    static readonly RULE_showRoles = 214;
    static readonly RULE_roleToken = 215;
    static readonly RULE_createUser = 216;
    static readonly RULE_dropUser = 217;
    static readonly RULE_renameUser = 218;
    static readonly RULE_alterCurrentUser = 219;
    static readonly RULE_alterUser = 220;
    static readonly RULE_password = 221;
    static readonly RULE_passwordExpression = 222;
    static readonly RULE_passwordChangeRequired = 223;
    static readonly RULE_userStatus = 224;
    static readonly RULE_homeDatabase = 225;
    static readonly RULE_showUsers = 226;
    static readonly RULE_showCurrentUser = 227;
    static readonly RULE_showPrivileges = 228;
    static readonly RULE_showSupportedPrivileges = 229;
    static readonly RULE_showRolePrivileges = 230;
    static readonly RULE_showUserPrivileges = 231;
    static readonly RULE_privilegeAsCommand = 232;
    static readonly RULE_privilegeToken = 233;
    static readonly RULE_grantCommand = 234;
    static readonly RULE_grantRole = 235;
    static readonly RULE_userNames = 236;
    static readonly RULE_roleNames = 237;
    static readonly RULE_denyCommand = 238;
    static readonly RULE_revokeCommand = 239;
    static readonly RULE_revokeRole = 240;
    static readonly RULE_privilege = 241;
    static readonly RULE_allPrivilege = 242;
    static readonly RULE_allPrivilegeType = 243;
    static readonly RULE_allPrivilegeTarget = 244;
    static readonly RULE_createPrivilege = 245;
    static readonly RULE_createPrivilegeForDatabase = 246;
    static readonly RULE_createNodePrivilegeToken = 247;
    static readonly RULE_createRelPrivilegeToken = 248;
    static readonly RULE_createPropertyPrivilegeToken = 249;
    static readonly RULE_actionForDBMS = 250;
    static readonly RULE_dropPrivilege = 251;
    static readonly RULE_loadPrivilege = 252;
    static readonly RULE_showPrivilege = 253;
    static readonly RULE_setPrivilege = 254;
    static readonly RULE_passwordToken = 255;
    static readonly RULE_removePrivilege = 256;
    static readonly RULE_writePrivilege = 257;
    static readonly RULE_databasePrivilege = 258;
    static readonly RULE_dbmsPrivilege = 259;
    static readonly RULE_dbmsPrivilegeExecute = 260;
    static readonly RULE_adminToken = 261;
    static readonly RULE_procedureToken = 262;
    static readonly RULE_indexToken = 263;
    static readonly RULE_constraintToken = 264;
    static readonly RULE_transactionToken = 265;
    static readonly RULE_userQualifier = 266;
    static readonly RULE_executeFunctionQualifier = 267;
    static readonly RULE_executeProcedureQualifier = 268;
    static readonly RULE_settingQualifier = 269;
    static readonly RULE_globs = 270;
    static readonly RULE_qualifiedGraphPrivilegesWithProperty = 271;
    static readonly RULE_qualifiedGraphPrivileges = 272;
    static readonly RULE_labelsResource = 273;
    static readonly RULE_propertiesResource = 274;
    static readonly RULE_nonEmptyStringList = 275;
    static readonly RULE_graphQualifier = 276;
    static readonly RULE_graphQualifierToken = 277;
    static readonly RULE_relToken = 278;
    static readonly RULE_elementToken = 279;
    static readonly RULE_nodeToken = 280;
    static readonly RULE_createCompositeDatabase = 281;
    static readonly RULE_createDatabase = 282;
    static readonly RULE_primaryTopology = 283;
    static readonly RULE_primaryToken = 284;
    static readonly RULE_secondaryTopology = 285;
    static readonly RULE_secondaryToken = 286;
    static readonly RULE_dropDatabase = 287;
    static readonly RULE_alterDatabase = 288;
    static readonly RULE_alterDatabaseAccess = 289;
    static readonly RULE_alterDatabaseTopology = 290;
    static readonly RULE_alterDatabaseOption = 291;
    static readonly RULE_startDatabase = 292;
    static readonly RULE_stopDatabase = 293;
    static readonly RULE_waitClause = 294;
    static readonly RULE_secondsToken = 295;
    static readonly RULE_showDatabase = 296;
    static readonly RULE_databaseScope = 297;
    static readonly RULE_graphScope = 298;
    static readonly RULE_commandOptions = 299;
    static readonly RULE_commandNameExpression = 300;
    static readonly RULE_symbolicNameOrStringParameter = 301;
    static readonly RULE_createAlias = 302;
    static readonly RULE_dropAlias = 303;
    static readonly RULE_alterAlias = 304;
    static readonly RULE_alterAliasTarget = 305;
    static readonly RULE_alterAliasUser = 306;
    static readonly RULE_alterAliasPassword = 307;
    static readonly RULE_alterAliasDriver = 308;
    static readonly RULE_alterAliasProperties = 309;
    static readonly RULE_showAliases = 310;
    static readonly RULE_symbolicAliasNameList = 311;
    static readonly RULE_symbolicAliasNameOrParameter = 312;
    static readonly RULE_symbolicAliasName = 313;
    static readonly RULE_symbolicNameOrStringParameterList = 314;
    static readonly RULE_glob = 315;
    static readonly RULE_globRecursive = 316;
    static readonly RULE_globPart = 317;
    static readonly RULE_stringList = 318;
    static readonly RULE_stringLiteral = 319;
    static readonly RULE_stringOrParameter = 320;
    static readonly RULE_mapOrParameter = 321;
    static readonly RULE_map = 322;
    static readonly RULE_symbolicNameString = 323;
    static readonly RULE_escapedSymbolicNameString = 324;
    static readonly RULE_unescapedSymbolicNameString = 325;
    static readonly RULE_symbolicLabelNameString = 326;
    static readonly RULE_unescapedLabelSymbolicNameString = 327;
    static readonly RULE_endOfFile = 328;
    static readonly literalNames: (string | null)[];
    static readonly symbolicNames: (string | null)[];
    static readonly ruleNames: string[];
    get grammarFileName(): string;
    get literalNames(): (string | null)[];
    get symbolicNames(): (string | null)[];
    get ruleNames(): string[];
    get serializedATN(): number[];
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    statementsOrCommands(): StatementsOrCommandsContext;
    statementOrCommand(): StatementOrCommandContext;
    consoleCommand(): ConsoleCommandContext;
    paramsCmd(): ParamsCmdContext;
    paramsArgs(): ParamsArgsContext;
    lambda(): LambdaContext;
    clearCmd(): ClearCmdContext;
    historyCmd(): HistoryCmdContext;
    useCmd(): UseCmdContext;
    listCompletionRule(): ListCompletionRuleContext;
    useCompletionRule(): UseCompletionRuleContext;
    preparsedStatement(): PreparsedStatementContext;
    preparserOption(): PreparserOptionContext;
    statements(): StatementsContext;
    statement(): StatementContext;
    periodicCommitQueryHintFailure(): PeriodicCommitQueryHintFailureContext;
    regularQuery(): RegularQueryContext;
    singleQuery(): SingleQueryContext;
    clause(): ClauseContext;
    useClause(): UseClauseContext;
    graphReference(): GraphReferenceContext;
    finishClause(): FinishClauseContext;
    returnClause(): ReturnClauseContext;
    returnBody(): ReturnBodyContext;
    returnItem(): ReturnItemContext;
    returnItems(): ReturnItemsContext;
    orderItem(): OrderItemContext;
    ascToken(): AscTokenContext;
    descToken(): DescTokenContext;
    orderBy(): OrderByContext;
    skip(): SkipContext;
    limit(): LimitContext;
    whereClause(): WhereClauseContext;
    withClause(): WithClauseContext;
    createClause(): CreateClauseContext;
    insertClause(): InsertClauseContext;
    setClause(): SetClauseContext;
    setItem(): SetItemContext;
    removeClause(): RemoveClauseContext;
    removeItem(): RemoveItemContext;
    deleteClause(): DeleteClauseContext;
    matchClause(): MatchClauseContext;
    matchMode(): MatchModeContext;
    hint(): HintContext;
    mergeClause(): MergeClauseContext;
    mergeAction(): MergeActionContext;
    unwindClause(): UnwindClauseContext;
    callClause(): CallClauseContext;
    procedureName(): ProcedureNameContext;
    procedureArgument(): ProcedureArgumentContext;
    procedureResultItem(): ProcedureResultItemContext;
    loadCSVClause(): LoadCSVClauseContext;
    foreachClause(): ForeachClauseContext;
    subqueryClause(): SubqueryClauseContext;
    subqueryInTransactionsParameters(): SubqueryInTransactionsParametersContext;
    subqueryInTransactionsBatchParameters(): SubqueryInTransactionsBatchParametersContext;
    subqueryInTransactionsErrorParameters(): SubqueryInTransactionsErrorParametersContext;
    subqueryInTransactionsReportParameters(): SubqueryInTransactionsReportParametersContext;
    patternList(): PatternListContext;
    insertPatternList(): InsertPatternListContext;
    pattern(): PatternContext;
    insertPattern(): InsertPatternContext;
    quantifier(): QuantifierContext;
    anonymousPattern(): AnonymousPatternContext;
    shortestPathPattern(): ShortestPathPatternContext;
    patternElement(): PatternElementContext;
    selector(): SelectorContext;
    groupToken(): GroupTokenContext;
    pathToken(): PathTokenContext;
    pathPatternNonEmpty(): PathPatternNonEmptyContext;
    nodePattern(): NodePatternContext;
    insertNodePattern(): InsertNodePatternContext;
    parenthesizedPath(): ParenthesizedPathContext;
    nodeLabels(): NodeLabelsContext;
    nodeLabelsIs(): NodeLabelsIsContext;
    labelType(): LabelTypeContext;
    relType(): RelTypeContext;
    labelOrRelType(): LabelOrRelTypeContext;
    properties(): PropertiesContext;
    relationshipPattern(): RelationshipPatternContext;
    insertRelationshipPattern(): InsertRelationshipPatternContext;
    leftArrow(): LeftArrowContext;
    arrowLine(): ArrowLineContext;
    rightArrow(): RightArrowContext;
    pathLength(): PathLengthContext;
    labelExpression(): LabelExpressionContext;
    labelExpression4(): LabelExpression4Context;
    labelExpression4Is(): LabelExpression4IsContext;
    labelExpression3(): LabelExpression3Context;
    labelExpression3Is(): LabelExpression3IsContext;
    labelExpression2(): LabelExpression2Context;
    labelExpression2Is(): LabelExpression2IsContext;
    labelExpression1(): LabelExpression1Context;
    labelExpression1Is(): LabelExpression1IsContext;
    insertNodeLabelExpression(): InsertNodeLabelExpressionContext;
    insertRelationshipLabelExpression(): InsertRelationshipLabelExpressionContext;
    expression(): ExpressionContext;
    expression11(): Expression11Context;
    expression10(): Expression10Context;
    expression9(): Expression9Context;
    expression8(): Expression8Context;
    expression7(): Expression7Context;
    comparisonExpression6(): ComparisonExpression6Context;
    normalForm(): NormalFormContext;
    expression6(): Expression6Context;
    expression5(): Expression5Context;
    expression4(): Expression4Context;
    expression3(): Expression3Context;
    expression2(): Expression2Context;
    postFix(): PostFixContext;
    property(): PropertyContext;
    propertyExpression(): PropertyExpressionContext;
    expression1(): Expression1Context;
    literal(): LiteralContext;
    caseExpression(): CaseExpressionContext;
    caseAlternative(): CaseAlternativeContext;
    extendedCaseExpression(): ExtendedCaseExpressionContext;
    extendedCaseAlternative(): ExtendedCaseAlternativeContext;
    extendedWhen(): ExtendedWhenContext;
    listComprehension(): ListComprehensionContext;
    patternComprehension(): PatternComprehensionContext;
    reduceExpression(): ReduceExpressionContext;
    listItemsPredicate(): ListItemsPredicateContext;
    normalizeFunction(): NormalizeFunctionContext;
    trimFunction(): TrimFunctionContext;
    patternExpression(): PatternExpressionContext;
    shortestPathExpression(): ShortestPathExpressionContext;
    parenthesizedExpression(): ParenthesizedExpressionContext;
    mapProjection(): MapProjectionContext;
    mapProjectionElement(): MapProjectionElementContext;
    countStar(): CountStarContext;
    existsExpression(): ExistsExpressionContext;
    countExpression(): CountExpressionContext;
    collectExpression(): CollectExpressionContext;
    numberLiteral(): NumberLiteralContext;
    signedIntegerLiteral(): SignedIntegerLiteralContext;
    listLiteral(): ListLiteralContext;
    propertyKeyName(): PropertyKeyNameContext;
    parameter(paramType: String): ParameterContext;
    parameterName(): ParameterNameContext;
    functionInvocation(): FunctionInvocationContext;
    functionArgument(): FunctionArgumentContext;
    functionName(): FunctionNameContext;
    namespace(): NamespaceContext;
    variable(): VariableContext;
    nonEmptyNameList(): NonEmptyNameListContext;
    command(): CommandContext;
    createCommand(): CreateCommandContext;
    dropCommand(): DropCommandContext;
    alterCommand(): AlterCommandContext;
    renameCommand(): RenameCommandContext;
    showCommand(): ShowCommandContext;
    showCommandYield(): ShowCommandYieldContext;
    yieldItem(): YieldItemContext;
    yieldSkip(): YieldSkipContext;
    yieldLimit(): YieldLimitContext;
    yieldClause(): YieldClauseContext;
    showBriefAndYield(): ShowBriefAndYieldContext;
    showIndexCommand(): ShowIndexCommandContext;
    showIndexesAllowBrief(): ShowIndexesAllowBriefContext;
    showIndexesNoBrief(): ShowIndexesNoBriefContext;
    showConstraintCommand(): ShowConstraintCommandContext;
    constraintAllowYieldType(): ConstraintAllowYieldTypeContext;
    constraintExistType(): ConstraintExistTypeContext;
    constraintBriefAndYieldType(): ConstraintBriefAndYieldTypeContext;
    showConstraintsAllowBriefAndYield(): ShowConstraintsAllowBriefAndYieldContext;
    showConstraintsAllowBrief(): ShowConstraintsAllowBriefContext;
    showConstraintsAllowYield(): ShowConstraintsAllowYieldContext;
    showProcedures(): ShowProceduresContext;
    showFunctions(): ShowFunctionsContext;
    functionToken(): FunctionTokenContext;
    executableBy(): ExecutableByContext;
    showFunctionsType(): ShowFunctionsTypeContext;
    showTransactions(): ShowTransactionsContext;
    terminateCommand(): TerminateCommandContext;
    terminateTransactions(): TerminateTransactionsContext;
    showSettings(): ShowSettingsContext;
    settingToken(): SettingTokenContext;
    namesAndClauses(): NamesAndClausesContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    composableShowCommandClauses(): ComposableShowCommandClausesContext;
    stringsOrExpression(): StringsOrExpressionContext;
    type_(): TypeContext;
    typePart(): TypePartContext;
    typeName(): TypeNameContext;
    typeNullability(): TypeNullabilityContext;
    typeListSuffix(): TypeListSuffixContext;
    commandNodePattern(): CommandNodePatternContext;
    commandRelPattern(): CommandRelPatternContext;
    createConstraint(): CreateConstraintContext;
    constraintType(): ConstraintTypeContext;
    dropConstraint(): DropConstraintContext;
    createIndex(): CreateIndexContext;
    oldCreateIndex(): OldCreateIndexContext;
    createIndex_(): CreateIndex_Context;
    createFulltextIndex(): CreateFulltextIndexContext;
    fulltextNodePattern(): FulltextNodePatternContext;
    fulltextRelPattern(): FulltextRelPatternContext;
    createLookupIndex(): CreateLookupIndexContext;
    lookupIndexNodePattern(): LookupIndexNodePatternContext;
    lookupIndexRelPattern(): LookupIndexRelPatternContext;
    dropIndex(): DropIndexContext;
    propertyList(): PropertyListContext;
    enableServerCommand(): EnableServerCommandContext;
    alterServer(): AlterServerContext;
    renameServer(): RenameServerContext;
    dropServer(): DropServerContext;
    showServers(): ShowServersContext;
    allocationCommand(): AllocationCommandContext;
    deallocateDatabaseFromServers(): DeallocateDatabaseFromServersContext;
    reallocateDatabases(): ReallocateDatabasesContext;
    createRole(): CreateRoleContext;
    dropRole(): DropRoleContext;
    renameRole(): RenameRoleContext;
    showRoles(): ShowRolesContext;
    roleToken(): RoleTokenContext;
    createUser(): CreateUserContext;
    dropUser(): DropUserContext;
    renameUser(): RenameUserContext;
    alterCurrentUser(): AlterCurrentUserContext;
    alterUser(): AlterUserContext;
    password(): PasswordContext;
    passwordExpression(): PasswordExpressionContext;
    passwordChangeRequired(): PasswordChangeRequiredContext;
    userStatus(): UserStatusContext;
    homeDatabase(): HomeDatabaseContext;
    showUsers(): ShowUsersContext;
    showCurrentUser(): ShowCurrentUserContext;
    showPrivileges(): ShowPrivilegesContext;
    showSupportedPrivileges(): ShowSupportedPrivilegesContext;
    showRolePrivileges(): ShowRolePrivilegesContext;
    showUserPrivileges(): ShowUserPrivilegesContext;
    privilegeAsCommand(): PrivilegeAsCommandContext;
    privilegeToken(): PrivilegeTokenContext;
    grantCommand(): GrantCommandContext;
    grantRole(): GrantRoleContext;
    userNames(): UserNamesContext;
    roleNames(): RoleNamesContext;
    denyCommand(): DenyCommandContext;
    revokeCommand(): RevokeCommandContext;
    revokeRole(): RevokeRoleContext;
    privilege(): PrivilegeContext;
    allPrivilege(): AllPrivilegeContext;
    allPrivilegeType(): AllPrivilegeTypeContext;
    allPrivilegeTarget(): AllPrivilegeTargetContext;
    createPrivilege(): CreatePrivilegeContext;
    createPrivilegeForDatabase(): CreatePrivilegeForDatabaseContext;
    createNodePrivilegeToken(): CreateNodePrivilegeTokenContext;
    createRelPrivilegeToken(): CreateRelPrivilegeTokenContext;
    createPropertyPrivilegeToken(): CreatePropertyPrivilegeTokenContext;
    actionForDBMS(): ActionForDBMSContext;
    dropPrivilege(): DropPrivilegeContext;
    loadPrivilege(): LoadPrivilegeContext;
    showPrivilege(): ShowPrivilegeContext;
    setPrivilege(): SetPrivilegeContext;
    passwordToken(): PasswordTokenContext;
    removePrivilege(): RemovePrivilegeContext;
    writePrivilege(): WritePrivilegeContext;
    databasePrivilege(): DatabasePrivilegeContext;
    dbmsPrivilege(): DbmsPrivilegeContext;
    dbmsPrivilegeExecute(): DbmsPrivilegeExecuteContext;
    adminToken(): AdminTokenContext;
    procedureToken(): ProcedureTokenContext;
    indexToken(): IndexTokenContext;
    constraintToken(): ConstraintTokenContext;
    transactionToken(): TransactionTokenContext;
    userQualifier(): UserQualifierContext;
    executeFunctionQualifier(): ExecuteFunctionQualifierContext;
    executeProcedureQualifier(): ExecuteProcedureQualifierContext;
    settingQualifier(): SettingQualifierContext;
    globs(): GlobsContext;
    qualifiedGraphPrivilegesWithProperty(): QualifiedGraphPrivilegesWithPropertyContext;
    qualifiedGraphPrivileges(): QualifiedGraphPrivilegesContext;
    labelsResource(): LabelsResourceContext;
    propertiesResource(): PropertiesResourceContext;
    nonEmptyStringList(): NonEmptyStringListContext;
    graphQualifier(): GraphQualifierContext;
    graphQualifierToken(): GraphQualifierTokenContext;
    relToken(): RelTokenContext;
    elementToken(): ElementTokenContext;
    nodeToken(): NodeTokenContext;
    createCompositeDatabase(): CreateCompositeDatabaseContext;
    createDatabase(): CreateDatabaseContext;
    primaryTopology(): PrimaryTopologyContext;
    primaryToken(): PrimaryTokenContext;
    secondaryTopology(): SecondaryTopologyContext;
    secondaryToken(): SecondaryTokenContext;
    dropDatabase(): DropDatabaseContext;
    alterDatabase(): AlterDatabaseContext;
    alterDatabaseAccess(): AlterDatabaseAccessContext;
    alterDatabaseTopology(): AlterDatabaseTopologyContext;
    alterDatabaseOption(): AlterDatabaseOptionContext;
    startDatabase(): StartDatabaseContext;
    stopDatabase(): StopDatabaseContext;
    waitClause(): WaitClauseContext;
    secondsToken(): SecondsTokenContext;
    showDatabase(): ShowDatabaseContext;
    databaseScope(): DatabaseScopeContext;
    graphScope(): GraphScopeContext;
    commandOptions(): CommandOptionsContext;
    commandNameExpression(): CommandNameExpressionContext;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    createAlias(): CreateAliasContext;
    dropAlias(): DropAliasContext;
    alterAlias(): AlterAliasContext;
    alterAliasTarget(): AlterAliasTargetContext;
    alterAliasUser(): AlterAliasUserContext;
    alterAliasPassword(): AlterAliasPasswordContext;
    alterAliasDriver(): AlterAliasDriverContext;
    alterAliasProperties(): AlterAliasPropertiesContext;
    showAliases(): ShowAliasesContext;
    symbolicAliasNameList(): SymbolicAliasNameListContext;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    symbolicAliasName(): SymbolicAliasNameContext;
    symbolicNameOrStringParameterList(): SymbolicNameOrStringParameterListContext;
    glob(): GlobContext;
    globRecursive(): GlobRecursiveContext;
    globPart(): GlobPartContext;
    stringList(): StringListContext;
    stringLiteral(): StringLiteralContext;
    stringOrParameter(): StringOrParameterContext;
    mapOrParameter(): MapOrParameterContext;
    map(): MapContext;
    symbolicNameString(): SymbolicNameStringContext;
    escapedSymbolicNameString(): EscapedSymbolicNameStringContext;
    unescapedSymbolicNameString(): UnescapedSymbolicNameStringContext;
    symbolicLabelNameString(): SymbolicLabelNameStringContext;
    unescapedLabelSymbolicNameString(): UnescapedLabelSymbolicNameStringContext;
    endOfFile(): EndOfFileContext;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): ATN;
    static DecisionsToDFA: DFA[];
}
export declare class StatementsOrCommandsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    statementOrCommand_list(): StatementOrCommandContext[];
    statementOrCommand(i: number): StatementOrCommandContext;
    EOF(): TerminalNode;
    SEMICOLON_list(): TerminalNode[];
    SEMICOLON(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StatementOrCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    preparsedStatement(): PreparsedStatementContext;
    consoleCommand(): ConsoleCommandContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConsoleCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    clearCmd(): ClearCmdContext;
    historyCmd(): HistoryCmdContext;
    useCmd(): UseCmdContext;
    paramsCmd(): ParamsCmdContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParamsCmdContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PARAM(): TerminalNode;
    paramsArgs(): ParamsArgsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParamsArgsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CLEAR(): TerminalNode;
    listCompletionRule(): ListCompletionRuleContext;
    map(): MapContext;
    lambda(): LambdaContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LambdaContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    unescapedSymbolicNameString(): UnescapedSymbolicNameStringContext;
    EQ(): TerminalNode;
    GT(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ClearCmdContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CLEAR(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class HistoryCmdContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    HISTORY(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UseCmdContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    useCompletionRule(): UseCompletionRuleContext;
    symbolicAliasName(): SymbolicAliasNameContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ListCompletionRuleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LIST(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UseCompletionRuleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PreparsedStatementContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    statement(): StatementContext;
    preparserOption(): PreparserOptionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PreparserOptionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    EXPLAIN(): TerminalNode;
    PROFILE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StatementsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    statement_list(): StatementContext[];
    statement(i: number): StatementContext;
    EOF(): TerminalNode;
    SEMICOLON_list(): TerminalNode[];
    SEMICOLON(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StatementContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    command(): CommandContext;
    regularQuery(): RegularQueryContext;
    periodicCommitQueryHintFailure(): PeriodicCommitQueryHintFailureContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PeriodicCommitQueryHintFailureContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USING(): TerminalNode;
    PERIODIC(): TerminalNode;
    COMMIT(): TerminalNode;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RegularQueryContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    singleQuery_list(): SingleQueryContext[];
    singleQuery(i: number): SingleQueryContext;
    UNION_list(): TerminalNode[];
    UNION(i: number): TerminalNode;
    ALL_list(): TerminalNode[];
    ALL(i: number): TerminalNode;
    DISTINCT_list(): TerminalNode[];
    DISTINCT(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SingleQueryContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    clause_list(): ClauseContext[];
    clause(i: number): ClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    useClause(): UseClauseContext;
    finishClause(): FinishClauseContext;
    returnClause(): ReturnClauseContext;
    createClause(): CreateClauseContext;
    insertClause(): InsertClauseContext;
    deleteClause(): DeleteClauseContext;
    setClause(): SetClauseContext;
    removeClause(): RemoveClauseContext;
    matchClause(): MatchClauseContext;
    mergeClause(): MergeClauseContext;
    withClause(): WithClauseContext;
    unwindClause(): UnwindClauseContext;
    callClause(): CallClauseContext;
    subqueryClause(): SubqueryClauseContext;
    loadCSVClause(): LoadCSVClauseContext;
    foreachClause(): ForeachClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UseClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USE(): TerminalNode;
    graphReference(): GraphReferenceContext;
    GRAPH(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GraphReferenceContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    graphReference(): GraphReferenceContext;
    RPAREN(): TerminalNode;
    functionInvocation(): FunctionInvocationContext;
    symbolicAliasName(): SymbolicAliasNameContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FinishClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FINISH(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ReturnClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    RETURN(): TerminalNode;
    returnBody(): ReturnBodyContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ReturnBodyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    returnItems(): ReturnItemsContext;
    DISTINCT(): TerminalNode;
    orderBy(): OrderByContext;
    skip(): SkipContext;
    limit(): LimitContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ReturnItemContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    AS(): TerminalNode;
    variable(): VariableContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ReturnItemsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TIMES(): TerminalNode;
    returnItem_list(): ReturnItemContext[];
    returnItem(i: number): ReturnItemContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class OrderItemContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    ascToken(): AscTokenContext;
    descToken(): DescTokenContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AscTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ASC(): TerminalNode;
    ASCENDING(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DescTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DESC(): TerminalNode;
    DESCENDING(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class OrderByContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ORDER(): TerminalNode;
    BY(): TerminalNode;
    orderItem_list(): OrderItemContext[];
    orderItem(i: number): OrderItemContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SkipContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SKIPROWS(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LimitContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LIMITROWS(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WhereClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    WHERE(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WithClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    WITH(): TerminalNode;
    returnBody(): ReturnBodyContext;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CREATE(): TerminalNode;
    patternList(): PatternListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    INSERT(): TerminalNode;
    insertPatternList(): InsertPatternListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SetClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SET(): TerminalNode;
    setItem_list(): SetItemContext[];
    setItem(i: number): SetItemContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SetItemContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: SetItemContext): void;
}
export declare class SetPropContext extends SetItemContext {
    constructor(parser: CypherCmdParser, ctx: SetItemContext);
    propertyExpression(): PropertyExpressionContext;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AddPropContext extends SetItemContext {
    constructor(parser: CypherCmdParser, ctx: SetItemContext);
    variable(): VariableContext;
    PLUSEQUAL(): TerminalNode;
    expression(): ExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SetPropsContext extends SetItemContext {
    constructor(parser: CypherCmdParser, ctx: SetItemContext);
    variable(): VariableContext;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SetLabelsContext extends SetItemContext {
    constructor(parser: CypherCmdParser, ctx: SetItemContext);
    variable(): VariableContext;
    nodeLabels(): NodeLabelsContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SetLabelsIsContext extends SetItemContext {
    constructor(parser: CypherCmdParser, ctx: SetItemContext);
    variable(): VariableContext;
    nodeLabelsIs(): NodeLabelsIsContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RemoveClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REMOVE(): TerminalNode;
    removeItem_list(): RemoveItemContext[];
    removeItem(i: number): RemoveItemContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RemoveItemContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: RemoveItemContext): void;
}
export declare class RemoveLabelsIsContext extends RemoveItemContext {
    constructor(parser: CypherCmdParser, ctx: RemoveItemContext);
    variable(): VariableContext;
    nodeLabelsIs(): NodeLabelsIsContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RemoveLabelsContext extends RemoveItemContext {
    constructor(parser: CypherCmdParser, ctx: RemoveItemContext);
    variable(): VariableContext;
    nodeLabels(): NodeLabelsContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RemovePropContext extends RemoveItemContext {
    constructor(parser: CypherCmdParser, ctx: RemoveItemContext);
    propertyExpression(): PropertyExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DeleteClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DELETE(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    DETACH(): TerminalNode;
    NODETACH(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MatchClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    MATCH(): TerminalNode;
    patternList(): PatternListContext;
    OPTIONAL(): TerminalNode;
    matchMode(): MatchModeContext;
    hint_list(): HintContext[];
    hint(i: number): HintContext;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MatchModeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REPEATABLE(): TerminalNode;
    ELEMENT(): TerminalNode;
    ELEMENTS(): TerminalNode;
    BINDINGS(): TerminalNode;
    DIFFERENT(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    RELATIONSHIPS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class HintContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USING(): TerminalNode;
    JOIN(): TerminalNode;
    ON(): TerminalNode;
    nonEmptyNameList(): NonEmptyNameListContext;
    SCAN(): TerminalNode;
    variable(): VariableContext;
    labelOrRelType(): LabelOrRelTypeContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    INDEX(): TerminalNode;
    BTREE(): TerminalNode;
    TEXT(): TerminalNode;
    RANGE(): TerminalNode;
    POINT(): TerminalNode;
    SEEK(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MergeClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    MERGE(): TerminalNode;
    pattern(): PatternContext;
    mergeAction_list(): MergeActionContext[];
    mergeAction(i: number): MergeActionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MergeActionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ON(): TerminalNode;
    setClause(): SetClauseContext;
    MATCH(): TerminalNode;
    CREATE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UnwindClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    UNWIND(): TerminalNode;
    expression(): ExpressionContext;
    AS(): TerminalNode;
    variable(): VariableContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CallClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CALL(): TerminalNode;
    procedureName(): ProcedureNameContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    YIELD(): TerminalNode;
    TIMES(): TerminalNode;
    procedureResultItem_list(): ProcedureResultItemContext[];
    procedureResultItem(i: number): ProcedureResultItemContext;
    procedureArgument_list(): ProcedureArgumentContext[];
    procedureArgument(i: number): ProcedureArgumentContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ProcedureNameContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    namespace(): NamespaceContext;
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ProcedureArgumentContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ProcedureResultItemContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    AS(): TerminalNode;
    variable(): VariableContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LoadCSVClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LOAD(): TerminalNode;
    CSV(): TerminalNode;
    FROM(): TerminalNode;
    expression(): ExpressionContext;
    AS(): TerminalNode;
    variable(): VariableContext;
    WITH(): TerminalNode;
    HEADERS(): TerminalNode;
    FIELDTERMINATOR(): TerminalNode;
    stringLiteral(): StringLiteralContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ForeachClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FOREACH(): TerminalNode;
    LPAREN(): TerminalNode;
    variable(): VariableContext;
    IN(): TerminalNode;
    expression(): ExpressionContext;
    BAR(): TerminalNode;
    RPAREN(): TerminalNode;
    clause_list(): ClauseContext[];
    clause(i: number): ClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SubqueryClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CALL(): TerminalNode;
    LCURLY(): TerminalNode;
    regularQuery(): RegularQueryContext;
    RCURLY(): TerminalNode;
    subqueryInTransactionsParameters(): SubqueryInTransactionsParametersContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SubqueryInTransactionsParametersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    IN(): TerminalNode;
    TRANSACTIONS(): TerminalNode;
    CONCURRENT(): TerminalNode;
    subqueryInTransactionsBatchParameters_list(): SubqueryInTransactionsBatchParametersContext[];
    subqueryInTransactionsBatchParameters(i: number): SubqueryInTransactionsBatchParametersContext;
    subqueryInTransactionsErrorParameters_list(): SubqueryInTransactionsErrorParametersContext[];
    subqueryInTransactionsErrorParameters(i: number): SubqueryInTransactionsErrorParametersContext;
    subqueryInTransactionsReportParameters_list(): SubqueryInTransactionsReportParametersContext[];
    subqueryInTransactionsReportParameters(i: number): SubqueryInTransactionsReportParametersContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SubqueryInTransactionsBatchParametersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    OF(): TerminalNode;
    expression(): ExpressionContext;
    ROW(): TerminalNode;
    ROWS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SubqueryInTransactionsErrorParametersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ON(): TerminalNode;
    ERROR(): TerminalNode;
    CONTINUE(): TerminalNode;
    BREAK(): TerminalNode;
    FAIL(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SubqueryInTransactionsReportParametersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REPORT(): TerminalNode;
    STATUS(): TerminalNode;
    AS(): TerminalNode;
    variable(): VariableContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PatternListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    pattern_list(): PatternContext[];
    pattern(i: number): PatternContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertPatternListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    insertPattern_list(): InsertPatternContext[];
    insertPattern(i: number): InsertPatternContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    anonymousPattern(): AnonymousPatternContext;
    variable(): VariableContext;
    EQ(): TerminalNode;
    selector(): SelectorContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    insertNodePattern_list(): InsertNodePatternContext[];
    insertNodePattern(i: number): InsertNodePatternContext;
    symbolicNameString(): SymbolicNameStringContext;
    EQ(): TerminalNode;
    insertRelationshipPattern_list(): InsertRelationshipPatternContext[];
    insertRelationshipPattern(i: number): InsertRelationshipPatternContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class QuantifierContext extends ParserRuleContext {
    _from_: Token;
    _to: Token;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LCURLY(): TerminalNode;
    UNSIGNED_DECIMAL_INTEGER_list(): TerminalNode[];
    UNSIGNED_DECIMAL_INTEGER(i: number): TerminalNode;
    RCURLY(): TerminalNode;
    COMMA(): TerminalNode;
    PLUS(): TerminalNode;
    TIMES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AnonymousPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    shortestPathPattern(): ShortestPathPatternContext;
    patternElement(): PatternElementContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShortestPathPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    patternElement(): PatternElementContext;
    RPAREN(): TerminalNode;
    SHORTEST_PATH(): TerminalNode;
    ALL_SHORTEST_PATHS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PatternElementContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    nodePattern_list(): NodePatternContext[];
    nodePattern(i: number): NodePatternContext;
    parenthesizedPath_list(): ParenthesizedPathContext[];
    parenthesizedPath(i: number): ParenthesizedPathContext;
    relationshipPattern_list(): RelationshipPatternContext[];
    relationshipPattern(i: number): RelationshipPatternContext;
    quantifier_list(): QuantifierContext[];
    quantifier(i: number): QuantifierContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SelectorContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: SelectorContext): void;
}
export declare class AllShortestPathContext extends SelectorContext {
    constructor(parser: CypherCmdParser, ctx: SelectorContext);
    ALL(): TerminalNode;
    SHORTEST(): TerminalNode;
    pathToken(): PathTokenContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AnyPathContext extends SelectorContext {
    constructor(parser: CypherCmdParser, ctx: SelectorContext);
    ANY(): TerminalNode;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    pathToken(): PathTokenContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShortestGroupContext extends SelectorContext {
    constructor(parser: CypherCmdParser, ctx: SelectorContext);
    SHORTEST(): TerminalNode;
    groupToken(): GroupTokenContext;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    pathToken(): PathTokenContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AnyShortestPathContext extends SelectorContext {
    constructor(parser: CypherCmdParser, ctx: SelectorContext);
    ANY(): TerminalNode;
    SHORTEST(): TerminalNode;
    pathToken(): PathTokenContext;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AllPathContext extends SelectorContext {
    constructor(parser: CypherCmdParser, ctx: SelectorContext);
    ALL(): TerminalNode;
    pathToken(): PathTokenContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GroupTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    GROUP(): TerminalNode;
    GROUPS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PathTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PATH(): TerminalNode;
    PATHS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PathPatternNonEmptyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    nodePattern_list(): NodePatternContext[];
    nodePattern(i: number): NodePatternContext;
    relationshipPattern_list(): RelationshipPatternContext[];
    relationshipPattern(i: number): RelationshipPatternContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NodePatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    variable(): VariableContext;
    labelExpression(): LabelExpressionContext;
    properties(): PropertiesContext;
    WHERE(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertNodePatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    variable(): VariableContext;
    insertNodeLabelExpression(): InsertNodeLabelExpressionContext;
    properties(): PropertiesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParenthesizedPathContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    pattern(): PatternContext;
    RPAREN(): TerminalNode;
    WHERE(): TerminalNode;
    expression(): ExpressionContext;
    quantifier(): QuantifierContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NodeLabelsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelType_list(): LabelTypeContext[];
    labelType(i: number): LabelTypeContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NodeLabelsIsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    IS(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    labelType_list(): LabelTypeContext[];
    labelType(i: number): LabelTypeContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RelTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelOrRelTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertiesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    map(): MapContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RelationshipPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    arrowLine_list(): ArrowLineContext[];
    arrowLine(i: number): ArrowLineContext;
    leftArrow(): LeftArrowContext;
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    rightArrow(): RightArrowContext;
    variable(): VariableContext;
    labelExpression(): LabelExpressionContext;
    pathLength(): PathLengthContext;
    properties(): PropertiesContext;
    WHERE(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertRelationshipPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    arrowLine_list(): ArrowLineContext[];
    arrowLine(i: number): ArrowLineContext;
    LBRACKET(): TerminalNode;
    insertRelationshipLabelExpression(): InsertRelationshipLabelExpressionContext;
    RBRACKET(): TerminalNode;
    leftArrow(): LeftArrowContext;
    variable(): VariableContext;
    properties(): PropertiesContext;
    rightArrow(): RightArrowContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LeftArrowContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LT(): TerminalNode;
    ARROW_LEFT_HEAD(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ArrowLineContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ARROW_LINE(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RightArrowContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    GT(): TerminalNode;
    ARROW_RIGHT_HEAD(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PathLengthContext extends ParserRuleContext {
    _from_: Token;
    _to: Token;
    _single: Token;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TIMES(): TerminalNode;
    DOTDOT(): TerminalNode;
    UNSIGNED_DECIMAL_INTEGER_list(): TerminalNode[];
    UNSIGNED_DECIMAL_INTEGER(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    labelExpression4(): LabelExpression4Context;
    IS(): TerminalNode;
    labelExpression4Is(): LabelExpression4IsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression4Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelExpression3_list(): LabelExpression3Context[];
    labelExpression3(i: number): LabelExpression3Context;
    BAR_list(): TerminalNode[];
    BAR(i: number): TerminalNode;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression4IsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelExpression3Is_list(): LabelExpression3IsContext[];
    labelExpression3Is(i: number): LabelExpression3IsContext;
    BAR_list(): TerminalNode[];
    BAR(i: number): TerminalNode;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression3Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelExpression2_list(): LabelExpression2Context[];
    labelExpression2(i: number): LabelExpression2Context;
    AMPERSAND_list(): TerminalNode[];
    AMPERSAND(i: number): TerminalNode;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression3IsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelExpression2Is_list(): LabelExpression2IsContext[];
    labelExpression2Is(i: number): LabelExpression2IsContext;
    AMPERSAND_list(): TerminalNode[];
    AMPERSAND(i: number): TerminalNode;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression2Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelExpression1(): LabelExpression1Context;
    EXCLAMATION_MARK_list(): TerminalNode[];
    EXCLAMATION_MARK(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression2IsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelExpression1Is(): LabelExpression1IsContext;
    EXCLAMATION_MARK_list(): TerminalNode[];
    EXCLAMATION_MARK(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression1Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: LabelExpression1Context): void;
}
export declare class AnyLabelContext extends LabelExpression1Context {
    constructor(parser: CypherCmdParser, ctx: LabelExpression1Context);
    PERCENT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelNameContext extends LabelExpression1Context {
    constructor(parser: CypherCmdParser, ctx: LabelExpression1Context);
    symbolicNameString(): SymbolicNameStringContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParenthesizedLabelExpressionContext extends LabelExpression1Context {
    constructor(parser: CypherCmdParser, ctx: LabelExpression1Context);
    LPAREN(): TerminalNode;
    labelExpression4(): LabelExpression4Context;
    RPAREN(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelExpression1IsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: LabelExpression1IsContext): void;
}
export declare class ParenthesizedLabelExpressionIsContext extends LabelExpression1IsContext {
    constructor(parser: CypherCmdParser, ctx: LabelExpression1IsContext);
    LPAREN(): TerminalNode;
    labelExpression4Is(): LabelExpression4IsContext;
    RPAREN(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AnyLabelIsContext extends LabelExpression1IsContext {
    constructor(parser: CypherCmdParser, ctx: LabelExpression1IsContext);
    PERCENT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelNameIsContext extends LabelExpression1IsContext {
    constructor(parser: CypherCmdParser, ctx: LabelExpression1IsContext);
    symbolicLabelNameString(): SymbolicLabelNameStringContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertNodeLabelExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    IS(): TerminalNode;
    AMPERSAND_list(): TerminalNode[];
    AMPERSAND(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class InsertRelationshipLabelExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    COLON(): TerminalNode;
    IS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression11_list(): Expression11Context[];
    expression11(i: number): Expression11Context;
    OR_list(): TerminalNode[];
    OR(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression11Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression10_list(): Expression10Context[];
    expression10(i: number): Expression10Context;
    XOR_list(): TerminalNode[];
    XOR(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression10Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression9_list(): Expression9Context[];
    expression9(i: number): Expression9Context;
    AND_list(): TerminalNode[];
    AND(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression9Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression8(): Expression8Context;
    NOT_list(): TerminalNode[];
    NOT(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression8Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression7_list(): Expression7Context[];
    expression7(i: number): Expression7Context;
    EQ_list(): TerminalNode[];
    EQ(i: number): TerminalNode;
    INVALID_NEQ_list(): TerminalNode[];
    INVALID_NEQ(i: number): TerminalNode;
    NEQ_list(): TerminalNode[];
    NEQ(i: number): TerminalNode;
    LE_list(): TerminalNode[];
    LE(i: number): TerminalNode;
    GE_list(): TerminalNode[];
    GE(i: number): TerminalNode;
    LT_list(): TerminalNode[];
    LT(i: number): TerminalNode;
    GT_list(): TerminalNode[];
    GT(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression7Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression6(): Expression6Context;
    comparisonExpression6(): ComparisonExpression6Context;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ComparisonExpression6Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: ComparisonExpression6Context): void;
}
export declare class TypeComparisonContext extends ComparisonExpression6Context {
    constructor(parser: CypherCmdParser, ctx: ComparisonExpression6Context);
    type_(): TypeContext;
    IS(): TerminalNode;
    COLONCOLON(): TerminalNode;
    TYPED(): TerminalNode;
    NOT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StringAndListComparisonContext extends ComparisonExpression6Context {
    constructor(parser: CypherCmdParser, ctx: ComparisonExpression6Context);
    expression6(): Expression6Context;
    REGEQ(): TerminalNode;
    STARTS(): TerminalNode;
    WITH(): TerminalNode;
    ENDS(): TerminalNode;
    CONTAINS(): TerminalNode;
    IN(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NormalFormComparisonContext extends ComparisonExpression6Context {
    constructor(parser: CypherCmdParser, ctx: ComparisonExpression6Context);
    IS(): TerminalNode;
    NORMALIZED(): TerminalNode;
    NOT(): TerminalNode;
    normalForm(): NormalFormContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NullComparisonContext extends ComparisonExpression6Context {
    constructor(parser: CypherCmdParser, ctx: ComparisonExpression6Context);
    IS(): TerminalNode;
    NULL(): TerminalNode;
    NOT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NormalFormContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NFC(): TerminalNode;
    NFD(): TerminalNode;
    NFKC(): TerminalNode;
    NFKD(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression6Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression5_list(): Expression5Context[];
    expression5(i: number): Expression5Context;
    PLUS_list(): TerminalNode[];
    PLUS(i: number): TerminalNode;
    MINUS_list(): TerminalNode[];
    MINUS(i: number): TerminalNode;
    DOUBLEBAR_list(): TerminalNode[];
    DOUBLEBAR(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression5Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression4_list(): Expression4Context[];
    expression4(i: number): Expression4Context;
    TIMES_list(): TerminalNode[];
    TIMES(i: number): TerminalNode;
    DIVIDE_list(): TerminalNode[];
    DIVIDE(i: number): TerminalNode;
    PERCENT_list(): TerminalNode[];
    PERCENT(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression4Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression3_list(): Expression3Context[];
    expression3(i: number): Expression3Context;
    POW_list(): TerminalNode[];
    POW(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression3Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression2(): Expression2Context;
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression2Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression1(): Expression1Context;
    postFix_list(): PostFixContext[];
    postFix(i: number): PostFixContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PostFixContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: PostFixContext): void;
}
export declare class IndexPostfixContext extends PostFixContext {
    constructor(parser: CypherCmdParser, ctx: PostFixContext);
    LBRACKET(): TerminalNode;
    expression(): ExpressionContext;
    RBRACKET(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertyPostfixContext extends PostFixContext {
    constructor(parser: CypherCmdParser, ctx: PostFixContext);
    property(): PropertyContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelPostfixContext extends PostFixContext {
    constructor(parser: CypherCmdParser, ctx: PostFixContext);
    labelExpression(): LabelExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RangePostfixContext extends PostFixContext {
    _fromExp: ExpressionContext;
    _toExp: ExpressionContext;
    constructor(parser: CypherCmdParser, ctx: PostFixContext);
    LBRACKET(): TerminalNode;
    DOTDOT(): TerminalNode;
    RBRACKET(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DOT(): TerminalNode;
    propertyKeyName(): PropertyKeyNameContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertyExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression1(): Expression1Context;
    property_list(): PropertyContext[];
    property(i: number): PropertyContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class Expression1Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    literal(): LiteralContext;
    parameter(): ParameterContext;
    caseExpression(): CaseExpressionContext;
    extendedCaseExpression(): ExtendedCaseExpressionContext;
    countStar(): CountStarContext;
    existsExpression(): ExistsExpressionContext;
    countExpression(): CountExpressionContext;
    collectExpression(): CollectExpressionContext;
    mapProjection(): MapProjectionContext;
    listComprehension(): ListComprehensionContext;
    listLiteral(): ListLiteralContext;
    patternComprehension(): PatternComprehensionContext;
    reduceExpression(): ReduceExpressionContext;
    listItemsPredicate(): ListItemsPredicateContext;
    normalizeFunction(): NormalizeFunctionContext;
    trimFunction(): TrimFunctionContext;
    patternExpression(): PatternExpressionContext;
    shortestPathExpression(): ShortestPathExpressionContext;
    parenthesizedExpression(): ParenthesizedExpressionContext;
    functionInvocation(): FunctionInvocationContext;
    variable(): VariableContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: LiteralContext): void;
}
export declare class NummericLiteralContext extends LiteralContext {
    constructor(parser: CypherCmdParser, ctx: LiteralContext);
    numberLiteral(): NumberLiteralContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class BooleanLiteralContext extends LiteralContext {
    constructor(parser: CypherCmdParser, ctx: LiteralContext);
    TRUE(): TerminalNode;
    FALSE(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class KeywordLiteralContext extends LiteralContext {
    constructor(parser: CypherCmdParser, ctx: LiteralContext);
    INF(): TerminalNode;
    INFINITY(): TerminalNode;
    NAN(): TerminalNode;
    NULL(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class OtherLiteralContext extends LiteralContext {
    constructor(parser: CypherCmdParser, ctx: LiteralContext);
    map(): MapContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StringsLiteralContext extends LiteralContext {
    constructor(parser: CypherCmdParser, ctx: LiteralContext);
    stringLiteral(): StringLiteralContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CaseExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CASE(): TerminalNode;
    END(): TerminalNode;
    caseAlternative_list(): CaseAlternativeContext[];
    caseAlternative(i: number): CaseAlternativeContext;
    ELSE(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CaseAlternativeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    WHEN(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    THEN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExtendedCaseExpressionContext extends ParserRuleContext {
    _elseExp: ExpressionContext;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CASE(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    END(): TerminalNode;
    extendedCaseAlternative_list(): ExtendedCaseAlternativeContext[];
    extendedCaseAlternative(i: number): ExtendedCaseAlternativeContext;
    ELSE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExtendedCaseAlternativeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    WHEN(): TerminalNode;
    extendedWhen_list(): ExtendedWhenContext[];
    extendedWhen(i: number): ExtendedWhenContext;
    THEN(): TerminalNode;
    expression(): ExpressionContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExtendedWhenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: ExtendedWhenContext): void;
}
export declare class WhenStringOrListContext extends ExtendedWhenContext {
    constructor(parser: CypherCmdParser, ctx: ExtendedWhenContext);
    expression6(): Expression6Context;
    REGEQ(): TerminalNode;
    STARTS(): TerminalNode;
    WITH(): TerminalNode;
    ENDS(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WhenTypeContext extends ExtendedWhenContext {
    constructor(parser: CypherCmdParser, ctx: ExtendedWhenContext);
    type_(): TypeContext;
    IS(): TerminalNode;
    TYPED(): TerminalNode;
    COLONCOLON(): TerminalNode;
    NOT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WhenFormContext extends ExtendedWhenContext {
    constructor(parser: CypherCmdParser, ctx: ExtendedWhenContext);
    IS(): TerminalNode;
    NORMALIZED(): TerminalNode;
    NOT(): TerminalNode;
    normalForm(): NormalFormContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WhenNullContext extends ExtendedWhenContext {
    constructor(parser: CypherCmdParser, ctx: ExtendedWhenContext);
    IS(): TerminalNode;
    NULL(): TerminalNode;
    NOT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WhenEqualsContext extends ExtendedWhenContext {
    constructor(parser: CypherCmdParser, ctx: ExtendedWhenContext);
    expression(): ExpressionContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WhenComparatorContext extends ExtendedWhenContext {
    constructor(parser: CypherCmdParser, ctx: ExtendedWhenContext);
    expression7(): Expression7Context;
    EQ(): TerminalNode;
    NEQ(): TerminalNode;
    INVALID_NEQ(): TerminalNode;
    LE(): TerminalNode;
    GE(): TerminalNode;
    LT(): TerminalNode;
    GT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ListComprehensionContext extends ParserRuleContext {
    _whereExp: ExpressionContext;
    _barExp: ExpressionContext;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACKET(): TerminalNode;
    variable(): VariableContext;
    IN(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    BAR(): TerminalNode;
    RBRACKET(): TerminalNode;
    WHERE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PatternComprehensionContext extends ParserRuleContext {
    _whereExp: ExpressionContext;
    _barExp: ExpressionContext;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACKET(): TerminalNode;
    pathPatternNonEmpty(): PathPatternNonEmptyContext;
    BAR(): TerminalNode;
    RBRACKET(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    variable(): VariableContext;
    EQ(): TerminalNode;
    WHERE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ReduceExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REDUCE(): TerminalNode;
    LPAREN(): TerminalNode;
    variable_list(): VariableContext[];
    variable(i: number): VariableContext;
    EQ(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA(): TerminalNode;
    IN(): TerminalNode;
    BAR(): TerminalNode;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ListItemsPredicateContext extends ParserRuleContext {
    _inExp: ExpressionContext;
    _whereExp: ExpressionContext;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    variable(): VariableContext;
    IN(): TerminalNode;
    RPAREN(): TerminalNode;
    ALL(): TerminalNode;
    ANY(): TerminalNode;
    NONE(): TerminalNode;
    SINGLE(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    WHERE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NormalizeFunctionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NORMALIZE(): TerminalNode;
    LPAREN(): TerminalNode;
    expression(): ExpressionContext;
    RPAREN(): TerminalNode;
    COMMA(): TerminalNode;
    normalForm(): NormalFormContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TrimFunctionContext extends ParserRuleContext {
    _trimCharacterString: ExpressionContext;
    _trimSource: ExpressionContext;
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TRIM(): TerminalNode;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    FROM(): TerminalNode;
    BOTH(): TerminalNode;
    LEADING(): TerminalNode;
    TRAILING(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PatternExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    pathPatternNonEmpty(): PathPatternNonEmptyContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShortestPathExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    shortestPathPattern(): ShortestPathPatternContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParenthesizedExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    expression(): ExpressionContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MapProjectionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    variable(): VariableContext;
    LCURLY(): TerminalNode;
    RCURLY(): TerminalNode;
    mapProjectionElement_list(): MapProjectionElementContext[];
    mapProjectionElement(i: number): MapProjectionElementContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MapProjectionElementContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    propertyKeyName(): PropertyKeyNameContext;
    COLON(): TerminalNode;
    expression(): ExpressionContext;
    property(): PropertyContext;
    variable(): VariableContext;
    DOT(): TerminalNode;
    TIMES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CountStarContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COUNT(): TerminalNode;
    LPAREN(): TerminalNode;
    TIMES(): TerminalNode;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExistsExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    EXISTS(): TerminalNode;
    LCURLY(): TerminalNode;
    RCURLY(): TerminalNode;
    regularQuery(): RegularQueryContext;
    patternList(): PatternListContext;
    matchMode(): MatchModeContext;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CountExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COUNT(): TerminalNode;
    LCURLY(): TerminalNode;
    RCURLY(): TerminalNode;
    regularQuery(): RegularQueryContext;
    patternList(): PatternListContext;
    matchMode(): MatchModeContext;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CollectExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COLLECT(): TerminalNode;
    LCURLY(): TerminalNode;
    regularQuery(): RegularQueryContext;
    RCURLY(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NumberLiteralContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DECIMAL_DOUBLE(): TerminalNode;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    UNSIGNED_HEX_INTEGER(): TerminalNode;
    UNSIGNED_OCTAL_INTEGER(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SignedIntegerLiteralContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ListLiteralContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertyKeyNameContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParameterContext extends ParserRuleContext {
    paramType: String;
    constructor(parser: CypherCmdParser, parent: ParserRuleContext, invokingState: number, paramType: String);
    DOLLAR(): TerminalNode;
    parameterName(): ParameterNameContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ParameterNameContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FunctionInvocationContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    functionName(): FunctionNameContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    functionArgument_list(): FunctionArgumentContext[];
    functionArgument(i: number): FunctionArgumentContext;
    DISTINCT(): TerminalNode;
    ALL(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FunctionArgumentContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FunctionNameContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    namespace(): NamespaceContext;
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NamespaceContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    DOT_list(): TerminalNode[];
    DOT(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class VariableContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NonEmptyNameListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    createCommand(): CreateCommandContext;
    dropCommand(): DropCommandContext;
    alterCommand(): AlterCommandContext;
    renameCommand(): RenameCommandContext;
    denyCommand(): DenyCommandContext;
    revokeCommand(): RevokeCommandContext;
    grantCommand(): GrantCommandContext;
    startDatabase(): StartDatabaseContext;
    stopDatabase(): StopDatabaseContext;
    enableServerCommand(): EnableServerCommandContext;
    allocationCommand(): AllocationCommandContext;
    showCommand(): ShowCommandContext;
    terminateCommand(): TerminateCommandContext;
    useClause(): UseClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CREATE(): TerminalNode;
    createAlias(): CreateAliasContext;
    createCompositeDatabase(): CreateCompositeDatabaseContext;
    createConstraint(): CreateConstraintContext;
    createDatabase(): CreateDatabaseContext;
    createIndex(): CreateIndexContext;
    createRole(): CreateRoleContext;
    createUser(): CreateUserContext;
    OR(): TerminalNode;
    REPLACE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DROP(): TerminalNode;
    dropAlias(): DropAliasContext;
    dropConstraint(): DropConstraintContext;
    dropDatabase(): DropDatabaseContext;
    dropIndex(): DropIndexContext;
    dropRole(): DropRoleContext;
    dropServer(): DropServerContext;
    dropUser(): DropUserContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALTER(): TerminalNode;
    alterAlias(): AlterAliasContext;
    alterCurrentUser(): AlterCurrentUserContext;
    alterDatabase(): AlterDatabaseContext;
    alterUser(): AlterUserContext;
    alterServer(): AlterServerContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RenameCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    RENAME(): TerminalNode;
    renameRole(): RenameRoleContext;
    renameServer(): RenameServerContext;
    renameUser(): RenameUserContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SHOW(): TerminalNode;
    showAliases(): ShowAliasesContext;
    showConstraintCommand(): ShowConstraintCommandContext;
    showCurrentUser(): ShowCurrentUserContext;
    showDatabase(): ShowDatabaseContext;
    showFunctions(): ShowFunctionsContext;
    showIndexCommand(): ShowIndexCommandContext;
    showPrivileges(): ShowPrivilegesContext;
    showProcedures(): ShowProceduresContext;
    showRolePrivileges(): ShowRolePrivilegesContext;
    showRoles(): ShowRolesContext;
    showServers(): ShowServersContext;
    showSettings(): ShowSettingsContext;
    showSupportedPrivileges(): ShowSupportedPrivilegesContext;
    showTransactions(): ShowTransactionsContext;
    showUserPrivileges(): ShowUserPrivilegesContext;
    showUsers(): ShowUsersContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowCommandYieldContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    yieldClause(): YieldClauseContext;
    returnClause(): ReturnClauseContext;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class YieldItemContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    variable_list(): VariableContext[];
    variable(i: number): VariableContext;
    AS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class YieldSkipContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SKIPROWS(): TerminalNode;
    signedIntegerLiteral(): SignedIntegerLiteralContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class YieldLimitContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LIMITROWS(): TerminalNode;
    signedIntegerLiteral(): SignedIntegerLiteralContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class YieldClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    YIELD(): TerminalNode;
    TIMES(): TerminalNode;
    yieldItem_list(): YieldItemContext[];
    yieldItem(i: number): YieldItemContext;
    orderBy(): OrderByContext;
    yieldSkip(): YieldSkipContext;
    yieldLimit(): YieldLimitContext;
    whereClause(): WhereClauseContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowBriefAndYieldContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    BRIEF(): TerminalNode;
    VERBOSE(): TerminalNode;
    OUTPUT(): TerminalNode;
    yieldClause(): YieldClauseContext;
    returnClause(): ReturnClauseContext;
    whereClause(): WhereClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowIndexCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    showIndexesNoBrief(): ShowIndexesNoBriefContext;
    FULLTEXT(): TerminalNode;
    LOOKUP(): TerminalNode;
    POINT(): TerminalNode;
    RANGE(): TerminalNode;
    TEXT(): TerminalNode;
    VECTOR(): TerminalNode;
    showIndexesAllowBrief(): ShowIndexesAllowBriefContext;
    ALL(): TerminalNode;
    BTREE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowIndexesAllowBriefContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    indexToken(): IndexTokenContext;
    showBriefAndYield(): ShowBriefAndYieldContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowIndexesNoBriefContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    indexToken(): IndexTokenContext;
    showCommandYield(): ShowCommandYieldContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: ShowConstraintCommandContext): void;
}
export declare class ShowConstraintUniqueContext extends ShowConstraintCommandContext {
    constructor(parser: CypherCmdParser, ctx: ShowConstraintCommandContext);
    UNIQUE(): TerminalNode;
    showConstraintsAllowYield(): ShowConstraintsAllowYieldContext;
    NODE(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    REL(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintMultiContext extends ShowConstraintCommandContext {
    constructor(parser: CypherCmdParser, ctx: ShowConstraintCommandContext);
    constraintAllowYieldType(): ConstraintAllowYieldTypeContext;
    showConstraintsAllowYield(): ShowConstraintsAllowYieldContext;
    NODE(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    REL(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintRelExistContext extends ShowConstraintCommandContext {
    constructor(parser: CypherCmdParser, ctx: ShowConstraintCommandContext);
    REL(): TerminalNode;
    EXIST(): TerminalNode;
    showConstraintsAllowYield(): ShowConstraintsAllowYieldContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintOldExistsContext extends ShowConstraintCommandContext {
    constructor(parser: CypherCmdParser, ctx: ShowConstraintCommandContext);
    EXISTS(): TerminalNode;
    showConstraintsAllowBrief(): ShowConstraintsAllowBriefContext;
    NODE(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintBriefAndYieldContext extends ShowConstraintCommandContext {
    constructor(parser: CypherCmdParser, ctx: ShowConstraintCommandContext);
    showConstraintsAllowBriefAndYield(): ShowConstraintsAllowBriefAndYieldContext;
    constraintBriefAndYieldType(): ConstraintBriefAndYieldTypeContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintKeyContext extends ShowConstraintCommandContext {
    constructor(parser: CypherCmdParser, ctx: ShowConstraintCommandContext);
    KEY(): TerminalNode;
    showConstraintsAllowYield(): ShowConstraintsAllowYieldContext;
    RELATIONSHIP(): TerminalNode;
    REL(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintAllowYieldTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    UNIQUENESS(): TerminalNode;
    constraintExistType(): ConstraintExistTypeContext;
    PROPERTY(): TerminalNode;
    TYPE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintExistTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    EXISTENCE(): TerminalNode;
    PROPERTY(): TerminalNode;
    EXIST(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintBriefAndYieldTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALL(): TerminalNode;
    UNIQUE(): TerminalNode;
    EXIST(): TerminalNode;
    NODE(): TerminalNode;
    KEY(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintsAllowBriefAndYieldContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    constraintToken(): ConstraintTokenContext;
    showBriefAndYield(): ShowBriefAndYieldContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintsAllowBriefContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    constraintToken(): ConstraintTokenContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    BRIEF(): TerminalNode;
    VERBOSE(): TerminalNode;
    OUTPUT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowConstraintsAllowYieldContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    constraintToken(): ConstraintTokenContext;
    showCommandYield(): ShowCommandYieldContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowProceduresContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PROCEDURE(): TerminalNode;
    PROCEDURES(): TerminalNode;
    executableBy(): ExecutableByContext;
    showCommandYield(): ShowCommandYieldContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowFunctionsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    functionToken(): FunctionTokenContext;
    showFunctionsType(): ShowFunctionsTypeContext;
    executableBy(): ExecutableByContext;
    showCommandYield(): ShowCommandYieldContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FunctionTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FUNCTION(): TerminalNode;
    FUNCTIONS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExecutableByContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    EXECUTABLE(): TerminalNode;
    BY(): TerminalNode;
    CURRENT(): TerminalNode;
    USER(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowFunctionsTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALL(): TerminalNode;
    BUILT(): TerminalNode;
    IN(): TerminalNode;
    USER(): TerminalNode;
    DEFINED(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowTransactionsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    transactionToken(): TransactionTokenContext;
    namesAndClauses(): NamesAndClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TerminateCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TERMINATE(): TerminalNode;
    terminateTransactions(): TerminateTransactionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TerminateTransactionsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    transactionToken(): TransactionTokenContext;
    namesAndClauses(): NamesAndClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowSettingsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    settingToken(): SettingTokenContext;
    namesAndClauses(): NamesAndClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SettingTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SETTING(): TerminalNode;
    SETTINGS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NamesAndClausesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    stringsOrExpression(): StringsOrExpressionContext;
    composableCommandClauses(): ComposableCommandClausesContext;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ComposableCommandClausesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    terminateCommand(): TerminateCommandContext;
    composableShowCommandClauses(): ComposableShowCommandClausesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ComposableShowCommandClausesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SHOW(): TerminalNode;
    showIndexCommand(): ShowIndexCommandContext;
    showConstraintCommand(): ShowConstraintCommandContext;
    showFunctions(): ShowFunctionsContext;
    showProcedures(): ShowProceduresContext;
    showSettings(): ShowSettingsContext;
    showTransactions(): ShowTransactionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StringsOrExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    stringList(): StringListContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    typePart_list(): TypePartContext[];
    typePart(i: number): TypePartContext;
    BAR_list(): TerminalNode[];
    BAR(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TypePartContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    typeName(): TypeNameContext;
    typeNullability(): TypeNullabilityContext;
    typeListSuffix_list(): TypeListSuffixContext[];
    typeListSuffix(i: number): TypeListSuffixContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TypeNameContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NOTHING(): TerminalNode;
    NULL(): TerminalNode;
    BOOL(): TerminalNode;
    BOOLEAN(): TerminalNode;
    VARCHAR(): TerminalNode;
    STRING(): TerminalNode;
    INT(): TerminalNode;
    INTEGER(): TerminalNode;
    SIGNED(): TerminalNode;
    FLOAT(): TerminalNode;
    DATE(): TerminalNode;
    LOCAL(): TerminalNode;
    TIME(): TerminalNode;
    DATETIME(): TerminalNode;
    ZONED(): TerminalNode;
    WITHOUT(): TerminalNode;
    TIMEZONE(): TerminalNode;
    WITH(): TerminalNode;
    TIMESTAMP(): TerminalNode;
    DURATION(): TerminalNode;
    POINT(): TerminalNode;
    NODE(): TerminalNode;
    VERTEX(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    EDGE(): TerminalNode;
    MAP(): TerminalNode;
    LT(): TerminalNode;
    type_(): TypeContext;
    GT(): TerminalNode;
    LIST(): TerminalNode;
    ARRAY(): TerminalNode;
    PATH(): TerminalNode;
    PATHS(): TerminalNode;
    PROPERTY(): TerminalNode;
    VALUE(): TerminalNode;
    ANY(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TypeNullabilityContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NOT(): TerminalNode;
    NULL(): TerminalNode;
    EXCLAMATION_MARK(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TypeListSuffixContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LIST(): TerminalNode;
    ARRAY(): TerminalNode;
    typeNullability(): TypeNullabilityContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CommandNodePatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    variable(): VariableContext;
    labelType(): LabelTypeContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CommandRelPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN_list(): TerminalNode[];
    LPAREN(i: number): TerminalNode;
    RPAREN_list(): TerminalNode[];
    RPAREN(i: number): TerminalNode;
    arrowLine_list(): ArrowLineContext[];
    arrowLine(i: number): ArrowLineContext;
    LBRACKET(): TerminalNode;
    variable(): VariableContext;
    relType(): RelTypeContext;
    RBRACKET(): TerminalNode;
    leftArrow(): LeftArrowContext;
    rightArrow(): RightArrowContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateConstraintContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CONSTRAINT(): TerminalNode;
    constraintType(): ConstraintTypeContext;
    ON(): TerminalNode;
    FOR(): TerminalNode;
    commandNodePattern(): CommandNodePatternContext;
    commandRelPattern(): CommandRelPatternContext;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    commandOptions(): CommandOptionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: ConstraintTypeContext): void;
}
export declare class ConstraintTypedContext extends ConstraintTypeContext {
    constructor(parser: CypherCmdParser, ctx: ConstraintTypeContext);
    propertyList(): PropertyListContext;
    type_(): TypeContext;
    REQUIRE(): TerminalNode;
    ASSERT(): TerminalNode;
    COLONCOLON(): TerminalNode;
    IS(): TerminalNode;
    TYPED(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintExistsContext extends ConstraintTypeContext {
    constructor(parser: CypherCmdParser, ctx: ConstraintTypeContext);
    ASSERT(): TerminalNode;
    EXISTS(): TerminalNode;
    propertyList(): PropertyListContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintKeyContext extends ConstraintTypeContext {
    constructor(parser: CypherCmdParser, ctx: ConstraintTypeContext);
    propertyList(): PropertyListContext;
    IS(): TerminalNode;
    KEY(): TerminalNode;
    REQUIRE(): TerminalNode;
    ASSERT(): TerminalNode;
    NODE(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    REL(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintIsNotNullContext extends ConstraintTypeContext {
    constructor(parser: CypherCmdParser, ctx: ConstraintTypeContext);
    propertyList(): PropertyListContext;
    IS(): TerminalNode;
    NOT(): TerminalNode;
    NULL(): TerminalNode;
    REQUIRE(): TerminalNode;
    ASSERT(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintIsUniqueContext extends ConstraintTypeContext {
    constructor(parser: CypherCmdParser, ctx: ConstraintTypeContext);
    propertyList(): PropertyListContext;
    IS(): TerminalNode;
    UNIQUE(): TerminalNode;
    REQUIRE(): TerminalNode;
    ASSERT(): TerminalNode;
    NODE(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    REL(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropConstraintContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CONSTRAINT(): TerminalNode;
    ON(): TerminalNode;
    ASSERT(): TerminalNode;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    commandNodePattern(): CommandNodePatternContext;
    commandRelPattern(): CommandRelPatternContext;
    EXISTS(): TerminalNode;
    propertyList(): PropertyListContext;
    IS(): TerminalNode;
    IF(): TerminalNode;
    UNIQUE(): TerminalNode;
    NODE(): TerminalNode;
    KEY(): TerminalNode;
    NOT(): TerminalNode;
    NULL(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateIndexContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    BTREE(): TerminalNode;
    INDEX(): TerminalNode;
    createIndex_(): CreateIndex_Context;
    RANGE(): TerminalNode;
    TEXT(): TerminalNode;
    POINT(): TerminalNode;
    VECTOR(): TerminalNode;
    LOOKUP(): TerminalNode;
    createLookupIndex(): CreateLookupIndexContext;
    FULLTEXT(): TerminalNode;
    createFulltextIndex(): CreateFulltextIndexContext;
    ON(): TerminalNode;
    oldCreateIndex(): OldCreateIndexContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class OldCreateIndexContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    labelType(): LabelTypeContext;
    LPAREN(): TerminalNode;
    nonEmptyNameList(): NonEmptyNameListContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateIndex_Context extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FOR(): TerminalNode;
    ON(): TerminalNode;
    propertyList(): PropertyListContext;
    commandNodePattern(): CommandNodePatternContext;
    commandRelPattern(): CommandRelPatternContext;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    commandOptions(): CommandOptionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateFulltextIndexContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FOR(): TerminalNode;
    ON(): TerminalNode;
    EACH(): TerminalNode;
    LBRACKET(): TerminalNode;
    variable_list(): VariableContext[];
    variable(i: number): VariableContext;
    property_list(): PropertyContext[];
    property(i: number): PropertyContext;
    RBRACKET(): TerminalNode;
    fulltextNodePattern(): FulltextNodePatternContext;
    fulltextRelPattern(): FulltextRelPatternContext;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    commandOptions(): CommandOptionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FulltextNodePatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    variable(): VariableContext;
    COLON(): TerminalNode;
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    RPAREN(): TerminalNode;
    BAR_list(): TerminalNode[];
    BAR(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class FulltextRelPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN_list(): TerminalNode[];
    LPAREN(i: number): TerminalNode;
    RPAREN_list(): TerminalNode[];
    RPAREN(i: number): TerminalNode;
    arrowLine_list(): ArrowLineContext[];
    arrowLine(i: number): ArrowLineContext;
    LBRACKET(): TerminalNode;
    variable(): VariableContext;
    COLON(): TerminalNode;
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    RBRACKET(): TerminalNode;
    leftArrow(): LeftArrowContext;
    BAR_list(): TerminalNode[];
    BAR(i: number): TerminalNode;
    rightArrow(): RightArrowContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateLookupIndexContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FOR(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    LPAREN(): TerminalNode;
    variable(): VariableContext;
    RPAREN(): TerminalNode;
    lookupIndexNodePattern(): LookupIndexNodePatternContext;
    lookupIndexRelPattern(): LookupIndexRelPatternContext;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    commandOptions(): CommandOptionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LookupIndexNodePatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    variable(): VariableContext;
    RPAREN(): TerminalNode;
    ON(): TerminalNode;
    EACH(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LookupIndexRelPatternContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN_list(): TerminalNode[];
    LPAREN(i: number): TerminalNode;
    RPAREN_list(): TerminalNode[];
    RPAREN(i: number): TerminalNode;
    arrowLine_list(): ArrowLineContext[];
    arrowLine(i: number): ArrowLineContext;
    LBRACKET(): TerminalNode;
    variable(): VariableContext;
    RBRACKET(): TerminalNode;
    ON(): TerminalNode;
    leftArrow(): LeftArrowContext;
    rightArrow(): RightArrowContext;
    EACH(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropIndexContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    INDEX(): TerminalNode;
    ON(): TerminalNode;
    labelType(): LabelTypeContext;
    LPAREN(): TerminalNode;
    nonEmptyNameList(): NonEmptyNameListContext;
    RPAREN(): TerminalNode;
    symbolicNameOrStringParameter(): SymbolicNameOrStringParameterContext;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertyListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    variable_list(): VariableContext[];
    variable(i: number): VariableContext;
    property_list(): PropertyContext[];
    property(i: number): PropertyContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class EnableServerCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ENABLE(): TerminalNode;
    SERVER(): TerminalNode;
    stringOrParameter(): StringOrParameterContext;
    commandOptions(): CommandOptionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterServerContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SERVER(): TerminalNode;
    stringOrParameter(): StringOrParameterContext;
    SET(): TerminalNode;
    commandOptions(): CommandOptionsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RenameServerContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SERVER(): TerminalNode;
    stringOrParameter_list(): StringOrParameterContext[];
    stringOrParameter(i: number): StringOrParameterContext;
    TO(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropServerContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SERVER(): TerminalNode;
    stringOrParameter(): StringOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowServersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SERVER(): TerminalNode;
    SERVERS(): TerminalNode;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AllocationCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    deallocateDatabaseFromServers(): DeallocateDatabaseFromServersContext;
    reallocateDatabases(): ReallocateDatabasesContext;
    DRYRUN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DeallocateDatabaseFromServersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DEALLOCATE(): TerminalNode;
    FROM(): TerminalNode;
    stringOrParameter_list(): StringOrParameterContext[];
    stringOrParameter(i: number): StringOrParameterContext;
    DATABASE(): TerminalNode;
    DATABASES(): TerminalNode;
    SERVER(): TerminalNode;
    SERVERS(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ReallocateDatabasesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REALLOCATE(): TerminalNode;
    DATABASE(): TerminalNode;
    DATABASES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateRoleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ROLE(): TerminalNode;
    commandNameExpression_list(): CommandNameExpressionContext[];
    commandNameExpression(i: number): CommandNameExpressionContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    AS(): TerminalNode;
    COPY(): TerminalNode;
    OF(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropRoleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ROLE(): TerminalNode;
    commandNameExpression(): CommandNameExpressionContext;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RenameRoleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ROLE(): TerminalNode;
    commandNameExpression_list(): CommandNameExpressionContext[];
    commandNameExpression(i: number): CommandNameExpressionContext;
    TO(): TerminalNode;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowRolesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    roleToken(): RoleTokenContext;
    WITH(): TerminalNode;
    showCommandYield(): ShowCommandYieldContext;
    ALL(): TerminalNode;
    POPULATED(): TerminalNode;
    USER(): TerminalNode;
    USERS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RoleTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ROLES(): TerminalNode;
    ROLE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USER(): TerminalNode;
    commandNameExpression(): CommandNameExpressionContext;
    SET_list(): TerminalNode[];
    SET(i: number): TerminalNode;
    password(): PasswordContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    PASSWORD_list(): TerminalNode[];
    PASSWORD(i: number): TerminalNode;
    passwordChangeRequired_list(): PasswordChangeRequiredContext[];
    passwordChangeRequired(i: number): PasswordChangeRequiredContext;
    userStatus_list(): UserStatusContext[];
    userStatus(i: number): UserStatusContext;
    homeDatabase_list(): HomeDatabaseContext[];
    homeDatabase(i: number): HomeDatabaseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USER(): TerminalNode;
    commandNameExpression(): CommandNameExpressionContext;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RenameUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USER(): TerminalNode;
    commandNameExpression_list(): CommandNameExpressionContext[];
    commandNameExpression(i: number): CommandNameExpressionContext;
    TO(): TerminalNode;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterCurrentUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CURRENT(): TerminalNode;
    USER(): TerminalNode;
    SET(): TerminalNode;
    PASSWORD(): TerminalNode;
    FROM(): TerminalNode;
    passwordExpression_list(): PasswordExpressionContext[];
    passwordExpression(i: number): PasswordExpressionContext;
    TO(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USER(): TerminalNode;
    commandNameExpression(): CommandNameExpressionContext;
    REMOVE(): TerminalNode;
    HOME(): TerminalNode;
    DATABASE(): TerminalNode;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    SET_list(): TerminalNode[];
    SET(i: number): TerminalNode;
    password_list(): PasswordContext[];
    password(i: number): PasswordContext;
    PASSWORD_list(): TerminalNode[];
    PASSWORD(i: number): TerminalNode;
    passwordChangeRequired_list(): PasswordChangeRequiredContext[];
    passwordChangeRequired(i: number): PasswordChangeRequiredContext;
    userStatus_list(): UserStatusContext[];
    userStatus(i: number): UserStatusContext;
    homeDatabase_list(): HomeDatabaseContext[];
    homeDatabase(i: number): HomeDatabaseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PasswordContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PASSWORD(): TerminalNode;
    passwordExpression(): PasswordExpressionContext;
    passwordChangeRequired(): PasswordChangeRequiredContext;
    PLAINTEXT(): TerminalNode;
    ENCRYPTED(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PasswordExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    stringLiteral(): StringLiteralContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PasswordChangeRequiredContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CHANGE(): TerminalNode;
    REQUIRED(): TerminalNode;
    NOT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UserStatusContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    STATUS(): TerminalNode;
    SUSPENDED(): TerminalNode;
    ACTIVE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class HomeDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    HOME(): TerminalNode;
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowUsersContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USER(): TerminalNode;
    USERS(): TerminalNode;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowCurrentUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CURRENT(): TerminalNode;
    USER(): TerminalNode;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowPrivilegesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    privilegeToken(): PrivilegeTokenContext;
    ALL(): TerminalNode;
    privilegeAsCommand(): PrivilegeAsCommandContext;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowSupportedPrivilegesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SUPPORTED(): TerminalNode;
    privilegeToken(): PrivilegeTokenContext;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowRolePrivilegesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    roleNames(): RoleNamesContext;
    privilegeToken(): PrivilegeTokenContext;
    ROLE(): TerminalNode;
    ROLES(): TerminalNode;
    privilegeAsCommand(): PrivilegeAsCommandContext;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowUserPrivilegesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    privilegeToken(): PrivilegeTokenContext;
    USER(): TerminalNode;
    USERS(): TerminalNode;
    userNames(): UserNamesContext;
    privilegeAsCommand(): PrivilegeAsCommandContext;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PrivilegeAsCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    AS(): TerminalNode;
    COMMAND(): TerminalNode;
    COMMANDS(): TerminalNode;
    REVOKE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PrivilegeTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PRIVILEGE(): TerminalNode;
    PRIVILEGES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GrantCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    GRANT(): TerminalNode;
    privilege(): PrivilegeContext;
    TO(): TerminalNode;
    roleNames(): RoleNamesContext;
    roleToken(): RoleTokenContext;
    grantRole(): GrantRoleContext;
    IMMUTABLE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GrantRoleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    roleNames(): RoleNamesContext;
    TO(): TerminalNode;
    userNames(): UserNamesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UserNamesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameOrStringParameterList(): SymbolicNameOrStringParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RoleNamesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameOrStringParameterList(): SymbolicNameOrStringParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DenyCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DENY(): TerminalNode;
    privilege(): PrivilegeContext;
    TO(): TerminalNode;
    roleNames(): RoleNamesContext;
    IMMUTABLE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RevokeCommandContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REVOKE(): TerminalNode;
    privilege(): PrivilegeContext;
    FROM(): TerminalNode;
    roleNames(): RoleNamesContext;
    roleToken(): RoleTokenContext;
    revokeRole(): RevokeRoleContext;
    IMMUTABLE(): TerminalNode;
    DENY(): TerminalNode;
    GRANT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RevokeRoleContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    roleNames(): RoleNamesContext;
    FROM(): TerminalNode;
    userNames(): UserNamesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    allPrivilege(): AllPrivilegeContext;
    createPrivilege(): CreatePrivilegeContext;
    databasePrivilege(): DatabasePrivilegeContext;
    dbmsPrivilege(): DbmsPrivilegeContext;
    dropPrivilege(): DropPrivilegeContext;
    loadPrivilege(): LoadPrivilegeContext;
    qualifiedGraphPrivileges(): QualifiedGraphPrivilegesContext;
    qualifiedGraphPrivilegesWithProperty(): QualifiedGraphPrivilegesWithPropertyContext;
    removePrivilege(): RemovePrivilegeContext;
    setPrivilege(): SetPrivilegeContext;
    showPrivilege(): ShowPrivilegeContext;
    writePrivilege(): WritePrivilegeContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AllPrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALL(): TerminalNode;
    ON(): TerminalNode;
    allPrivilegeTarget(): AllPrivilegeTargetContext;
    allPrivilegeType(): AllPrivilegeTypeContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AllPrivilegeTypeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PRIVILEGES(): TerminalNode;
    DATABASE(): TerminalNode;
    GRAPH(): TerminalNode;
    DBMS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AllPrivilegeTargetContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: AllPrivilegeTargetContext): void;
}
export declare class DefaultTargetContext extends AllPrivilegeTargetContext {
    constructor(parser: CypherCmdParser, ctx: AllPrivilegeTargetContext);
    DEFAULT(): TerminalNode;
    HOME(): TerminalNode;
    DATABASE(): TerminalNode;
    GRAPH(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DatabaseVariableTargetContext extends AllPrivilegeTargetContext {
    constructor(parser: CypherCmdParser, ctx: AllPrivilegeTargetContext);
    DATABASE(): TerminalNode;
    DATABASES(): TerminalNode;
    TIMES(): TerminalNode;
    symbolicAliasNameList(): SymbolicAliasNameListContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GraphVariableTargetContext extends AllPrivilegeTargetContext {
    constructor(parser: CypherCmdParser, ctx: AllPrivilegeTargetContext);
    GRAPH(): TerminalNode;
    GRAPHS(): TerminalNode;
    TIMES(): TerminalNode;
    symbolicAliasNameList(): SymbolicAliasNameListContext;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DBMSTargetContext extends AllPrivilegeTargetContext {
    constructor(parser: CypherCmdParser, ctx: AllPrivilegeTargetContext);
    DBMS(): TerminalNode;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreatePrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CREATE(): TerminalNode;
    createPrivilegeForDatabase(): CreatePrivilegeForDatabaseContext;
    ON(): TerminalNode;
    databaseScope(): DatabaseScopeContext;
    actionForDBMS(): ActionForDBMSContext;
    DBMS(): TerminalNode;
    graphScope(): GraphScopeContext;
    graphQualifier(): GraphQualifierContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreatePrivilegeForDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    indexToken(): IndexTokenContext;
    constraintToken(): ConstraintTokenContext;
    createNodePrivilegeToken(): CreateNodePrivilegeTokenContext;
    createRelPrivilegeToken(): CreateRelPrivilegeTokenContext;
    createPropertyPrivilegeToken(): CreatePropertyPrivilegeTokenContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateNodePrivilegeTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NEW(): TerminalNode;
    LABEL(): TerminalNode;
    LABELS(): TerminalNode;
    NODE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateRelPrivilegeTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NEW(): TerminalNode;
    TYPE(): TerminalNode;
    TYPES(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreatePropertyPrivilegeTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NEW(): TerminalNode;
    NAME(): TerminalNode;
    NAMES(): TerminalNode;
    PROPERTY(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ActionForDBMSContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALIAS(): TerminalNode;
    DATABASE(): TerminalNode;
    COMPOSITE(): TerminalNode;
    ROLE(): TerminalNode;
    USER(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropPrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DROP(): TerminalNode;
    ON(): TerminalNode;
    databaseScope(): DatabaseScopeContext;
    actionForDBMS(): ActionForDBMSContext;
    DBMS(): TerminalNode;
    indexToken(): IndexTokenContext;
    constraintToken(): ConstraintTokenContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LoadPrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LOAD(): TerminalNode;
    ON(): TerminalNode;
    stringOrParameter(): StringOrParameterContext;
    ALL(): TerminalNode;
    DATA(): TerminalNode;
    URL(): TerminalNode;
    CIDR(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowPrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SHOW(): TerminalNode;
    ON(): TerminalNode;
    databaseScope(): DatabaseScopeContext;
    DBMS(): TerminalNode;
    indexToken(): IndexTokenContext;
    constraintToken(): ConstraintTokenContext;
    transactionToken(): TransactionTokenContext;
    ALIAS(): TerminalNode;
    PRIVILEGE(): TerminalNode;
    ROLE(): TerminalNode;
    SERVER(): TerminalNode;
    SERVERS(): TerminalNode;
    settingToken(): SettingTokenContext;
    settingQualifier(): SettingQualifierContext;
    USER(): TerminalNode;
    userQualifier(): UserQualifierContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SetPrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SET(): TerminalNode;
    ON(): TerminalNode;
    DBMS(): TerminalNode;
    LABEL(): TerminalNode;
    labelsResource(): LabelsResourceContext;
    graphScope(): GraphScopeContext;
    PROPERTY(): TerminalNode;
    propertiesResource(): PropertiesResourceContext;
    graphQualifier(): GraphQualifierContext;
    passwordToken(): PasswordTokenContext;
    USER(): TerminalNode;
    DATABASE(): TerminalNode;
    ACCESS(): TerminalNode;
    STATUS(): TerminalNode;
    HOME(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PasswordTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PASSWORD(): TerminalNode;
    PASSWORDS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RemovePrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    REMOVE(): TerminalNode;
    ON(): TerminalNode;
    DBMS(): TerminalNode;
    LABEL(): TerminalNode;
    labelsResource(): LabelsResourceContext;
    graphScope(): GraphScopeContext;
    PRIVILEGE(): TerminalNode;
    ROLE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WritePrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    WRITE(): TerminalNode;
    ON(): TerminalNode;
    graphScope(): GraphScopeContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DatabasePrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ON(): TerminalNode;
    databaseScope(): DatabaseScopeContext;
    ACCESS(): TerminalNode;
    START(): TerminalNode;
    STOP(): TerminalNode;
    indexToken(): IndexTokenContext;
    constraintToken(): ConstraintTokenContext;
    NAME(): TerminalNode;
    TRANSACTION(): TerminalNode;
    TERMINATE(): TerminalNode;
    transactionToken(): TransactionTokenContext;
    MANAGEMENT(): TerminalNode;
    userQualifier(): UserQualifierContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DbmsPrivilegeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ON(): TerminalNode;
    DBMS(): TerminalNode;
    ALTER(): TerminalNode;
    ASSIGN(): TerminalNode;
    MANAGEMENT(): TerminalNode;
    dbmsPrivilegeExecute(): DbmsPrivilegeExecuteContext;
    RENAME(): TerminalNode;
    IMPERSONATE(): TerminalNode;
    ALIAS(): TerminalNode;
    DATABASE(): TerminalNode;
    USER(): TerminalNode;
    PRIVILEGE(): TerminalNode;
    ROLE(): TerminalNode;
    SERVER(): TerminalNode;
    userQualifier(): UserQualifierContext;
    COMPOSITE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DbmsPrivilegeExecuteContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    EXECUTE(): TerminalNode;
    adminToken(): AdminTokenContext;
    PROCEDURES(): TerminalNode;
    procedureToken(): ProcedureTokenContext;
    executeProcedureQualifier(): ExecuteProcedureQualifierContext;
    functionToken(): FunctionTokenContext;
    executeFunctionQualifier(): ExecuteFunctionQualifierContext;
    BOOSTED(): TerminalNode;
    USER(): TerminalNode;
    DEFINED(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AdminTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ADMIN(): TerminalNode;
    ADMINISTRATOR(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ProcedureTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PROCEDURE(): TerminalNode;
    PROCEDURES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class IndexTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    INDEX(): TerminalNode;
    INDEXES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ConstraintTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    CONSTRAINT(): TerminalNode;
    CONSTRAINTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class TransactionTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TRANSACTION(): TerminalNode;
    TRANSACTIONS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UserQualifierContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    TIMES(): TerminalNode;
    userNames(): UserNamesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExecuteFunctionQualifierContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    globs(): GlobsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ExecuteProcedureQualifierContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    globs(): GlobsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SettingQualifierContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    globs(): GlobsContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GlobsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    glob_list(): GlobContext[];
    glob(i: number): GlobContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class QualifiedGraphPrivilegesWithPropertyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ON(): TerminalNode;
    graphScope(): GraphScopeContext;
    graphQualifier(): GraphQualifierContext;
    TRAVERSE(): TerminalNode;
    propertiesResource(): PropertiesResourceContext;
    READ(): TerminalNode;
    MATCH(): TerminalNode;
    LPAREN(): TerminalNode;
    TIMES(): TerminalNode;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class QualifiedGraphPrivilegesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ON(): TerminalNode;
    graphScope(): GraphScopeContext;
    graphQualifier(): GraphQualifierContext;
    DELETE(): TerminalNode;
    MERGE(): TerminalNode;
    propertiesResource(): PropertiesResourceContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class LabelsResourceContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TIMES(): TerminalNode;
    nonEmptyStringList(): NonEmptyStringListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PropertiesResourceContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LCURLY(): TerminalNode;
    RCURLY(): TerminalNode;
    TIMES(): TerminalNode;
    nonEmptyStringList(): NonEmptyStringListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NonEmptyStringListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GraphQualifierContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    graphQualifierToken(): GraphQualifierTokenContext;
    FOR(): TerminalNode;
    LPAREN(): TerminalNode;
    TIMES(): TerminalNode;
    nonEmptyStringList(): NonEmptyStringListContext;
    RPAREN(): TerminalNode;
    WHERE(): TerminalNode;
    expression(): ExpressionContext;
    variable(): VariableContext;
    COLON(): TerminalNode;
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    map(): MapContext;
    BAR_list(): TerminalNode[];
    BAR(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GraphQualifierTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    relToken(): RelTokenContext;
    nodeToken(): NodeTokenContext;
    elementToken(): ElementTokenContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class RelTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    RELATIONSHIP(): TerminalNode;
    RELATIONSHIPS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ElementTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ELEMENT(): TerminalNode;
    ELEMENTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class NodeTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    NODE(): TerminalNode;
    NODES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateCompositeDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    COMPOSITE(): TerminalNode;
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    commandOptions(): CommandOptionsContext;
    waitClause(): WaitClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    TOPOLOGY(): TerminalNode;
    commandOptions(): CommandOptionsContext;
    waitClause(): WaitClauseContext;
    primaryTopology_list(): PrimaryTopologyContext[];
    primaryTopology(i: number): PrimaryTopologyContext;
    secondaryTopology_list(): SecondaryTopologyContext[];
    secondaryTopology(i: number): SecondaryTopologyContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PrimaryTopologyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    primaryToken(): PrimaryTokenContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class PrimaryTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PRIMARY(): TerminalNode;
    PRIMARIES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SecondaryTopologyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    secondaryToken(): SecondaryTokenContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SecondaryTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SECONDARY(): TerminalNode;
    SECONDARIES(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    COMPOSITE(): TerminalNode;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    DATA(): TerminalNode;
    waitClause(): WaitClauseContext;
    DUMP(): TerminalNode;
    DESTROY(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    waitClause(): WaitClauseContext;
    SET_list(): TerminalNode[];
    SET(i: number): TerminalNode;
    REMOVE_list(): TerminalNode[];
    REMOVE(i: number): TerminalNode;
    OPTION_list(): TerminalNode[];
    OPTION(i: number): TerminalNode;
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    alterDatabaseAccess_list(): AlterDatabaseAccessContext[];
    alterDatabaseAccess(i: number): AlterDatabaseAccessContext;
    alterDatabaseTopology_list(): AlterDatabaseTopologyContext[];
    alterDatabaseTopology(i: number): AlterDatabaseTopologyContext;
    alterDatabaseOption_list(): AlterDatabaseOptionContext[];
    alterDatabaseOption(i: number): AlterDatabaseOptionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterDatabaseAccessContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ACCESS(): TerminalNode;
    READ(): TerminalNode;
    ONLY(): TerminalNode;
    WRITE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterDatabaseTopologyContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TOPOLOGY(): TerminalNode;
    primaryTopology_list(): PrimaryTopologyContext[];
    primaryTopology(i: number): PrimaryTopologyContext;
    secondaryTopology_list(): SecondaryTopologyContext[];
    secondaryTopology(i: number): SecondaryTopologyContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterDatabaseOptionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    OPTION(): TerminalNode;
    symbolicNameString(): SymbolicNameStringContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StartDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    START(): TerminalNode;
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    waitClause(): WaitClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StopDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    STOP(): TerminalNode;
    DATABASE(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    waitClause(): WaitClauseContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class WaitClauseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    WAIT(): TerminalNode;
    UNSIGNED_DECIMAL_INTEGER(): TerminalNode;
    secondsToken(): SecondsTokenContext;
    NOWAIT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SecondsTokenContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    SEC(): TerminalNode;
    SECOND(): TerminalNode;
    SECONDS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowDatabaseContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DATABASE(): TerminalNode;
    DEFAULT(): TerminalNode;
    HOME(): TerminalNode;
    showCommandYield(): ShowCommandYieldContext;
    DATABASES(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DatabaseScopeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DATABASE(): TerminalNode;
    DEFAULT(): TerminalNode;
    HOME(): TerminalNode;
    DATABASES(): TerminalNode;
    TIMES(): TerminalNode;
    symbolicAliasNameList(): SymbolicAliasNameListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GraphScopeContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    GRAPH(): TerminalNode;
    DEFAULT(): TerminalNode;
    HOME(): TerminalNode;
    GRAPHS(): TerminalNode;
    TIMES(): TerminalNode;
    symbolicAliasNameList(): SymbolicAliasNameListContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CommandOptionsContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    OPTIONS(): TerminalNode;
    mapOrParameter(): MapOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CommandNameExpressionContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicNameOrStringParameterContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString(): SymbolicNameStringContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class CreateAliasContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALIAS(): TerminalNode;
    symbolicAliasNameOrParameter_list(): SymbolicAliasNameOrParameterContext[];
    symbolicAliasNameOrParameter(i: number): SymbolicAliasNameOrParameterContext;
    FOR(): TerminalNode;
    DATABASE(): TerminalNode;
    IF(): TerminalNode;
    NOT(): TerminalNode;
    EXISTS(): TerminalNode;
    AT(): TerminalNode;
    stringOrParameter(): StringOrParameterContext;
    USER(): TerminalNode;
    commandNameExpression(): CommandNameExpressionContext;
    PASSWORD(): TerminalNode;
    passwordExpression(): PasswordExpressionContext;
    PROPERTIES(): TerminalNode;
    mapOrParameter_list(): MapOrParameterContext[];
    mapOrParameter(i: number): MapOrParameterContext;
    DRIVER(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class DropAliasContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALIAS(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    FOR(): TerminalNode;
    DATABASE(): TerminalNode;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterAliasContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ALIAS(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    SET(): TerminalNode;
    DATABASE(): TerminalNode;
    IF(): TerminalNode;
    EXISTS(): TerminalNode;
    alterAliasTarget_list(): AlterAliasTargetContext[];
    alterAliasTarget(i: number): AlterAliasTargetContext;
    alterAliasUser_list(): AlterAliasUserContext[];
    alterAliasUser(i: number): AlterAliasUserContext;
    alterAliasPassword_list(): AlterAliasPasswordContext[];
    alterAliasPassword(i: number): AlterAliasPasswordContext;
    alterAliasDriver_list(): AlterAliasDriverContext[];
    alterAliasDriver(i: number): AlterAliasDriverContext;
    alterAliasProperties_list(): AlterAliasPropertiesContext[];
    alterAliasProperties(i: number): AlterAliasPropertiesContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterAliasTargetContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    TARGET(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    AT(): TerminalNode;
    stringOrParameter(): StringOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterAliasUserContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    USER(): TerminalNode;
    commandNameExpression(): CommandNameExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterAliasPasswordContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PASSWORD(): TerminalNode;
    passwordExpression(): PasswordExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterAliasDriverContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DRIVER(): TerminalNode;
    mapOrParameter(): MapOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class AlterAliasPropertiesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    PROPERTIES(): TerminalNode;
    mapOrParameter(): MapOrParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class ShowAliasesContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    FOR(): TerminalNode;
    ALIAS(): TerminalNode;
    ALIASES(): TerminalNode;
    DATABASE(): TerminalNode;
    DATABASES(): TerminalNode;
    symbolicAliasNameOrParameter(): SymbolicAliasNameOrParameterContext;
    showCommandYield(): ShowCommandYieldContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicAliasNameListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicAliasNameOrParameter_list(): SymbolicAliasNameOrParameterContext[];
    symbolicAliasNameOrParameter(i: number): SymbolicAliasNameOrParameterContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicAliasNameOrParameterContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicAliasName(): SymbolicAliasNameContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicAliasNameContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    symbolicNameString_list(): SymbolicNameStringContext[];
    symbolicNameString(i: number): SymbolicNameStringContext;
    DOT_list(): TerminalNode[];
    DOT(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicNameOrStringParameterListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    commandNameExpression_list(): CommandNameExpressionContext[];
    commandNameExpression(i: number): CommandNameExpressionContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GlobContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    escapedSymbolicNameString(): EscapedSymbolicNameStringContext;
    globRecursive(): GlobRecursiveContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GlobRecursiveContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    globPart(): GlobPartContext;
    globRecursive(): GlobRecursiveContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class GlobPartContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    DOT(): TerminalNode;
    escapedSymbolicNameString(): EscapedSymbolicNameStringContext;
    QUESTION(): TerminalNode;
    TIMES(): TerminalNode;
    unescapedSymbolicNameString(): UnescapedSymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StringListContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    stringLiteral_list(): StringLiteralContext[];
    stringLiteral(i: number): StringLiteralContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StringLiteralContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    STRING_LITERAL1(): TerminalNode;
    STRING_LITERAL2(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class StringOrParameterContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    stringLiteral(): StringLiteralContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MapOrParameterContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    map(): MapContext;
    parameter(): ParameterContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class MapContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    LCURLY(): TerminalNode;
    RCURLY(): TerminalNode;
    propertyKeyName_list(): PropertyKeyNameContext[];
    propertyKeyName(i: number): PropertyKeyNameContext;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicNameStringContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    escapedSymbolicNameString(): EscapedSymbolicNameStringContext;
    unescapedSymbolicNameString(): UnescapedSymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class EscapedSymbolicNameStringContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    ESCAPED_SYMBOLIC_NAME(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UnescapedSymbolicNameStringContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    unescapedLabelSymbolicNameString(): UnescapedLabelSymbolicNameStringContext;
    NOT(): TerminalNode;
    NULL(): TerminalNode;
    TYPED(): TerminalNode;
    NORMALIZED(): TerminalNode;
    NFC(): TerminalNode;
    NFD(): TerminalNode;
    NFKC(): TerminalNode;
    NFKD(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class SymbolicLabelNameStringContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    escapedSymbolicNameString(): EscapedSymbolicNameStringContext;
    unescapedLabelSymbolicNameString(): UnescapedLabelSymbolicNameStringContext;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class UnescapedLabelSymbolicNameStringContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    IDENTIFIER(): TerminalNode;
    ACCESS(): TerminalNode;
    ACTIVE(): TerminalNode;
    ADMIN(): TerminalNode;
    ADMINISTRATOR(): TerminalNode;
    ALIAS(): TerminalNode;
    ALIASES(): TerminalNode;
    ALL_SHORTEST_PATHS(): TerminalNode;
    ALL(): TerminalNode;
    ALTER(): TerminalNode;
    AND(): TerminalNode;
    ANY(): TerminalNode;
    ARRAY(): TerminalNode;
    AS(): TerminalNode;
    ASC(): TerminalNode;
    ASCENDING(): TerminalNode;
    ASSERT(): TerminalNode;
    ASSIGN(): TerminalNode;
    AT(): TerminalNode;
    BINDINGS(): TerminalNode;
    BOOL(): TerminalNode;
    BOOLEAN(): TerminalNode;
    BOOSTED(): TerminalNode;
    BOTH(): TerminalNode;
    BREAK(): TerminalNode;
    BRIEF(): TerminalNode;
    BTREE(): TerminalNode;
    BUILT(): TerminalNode;
    BY(): TerminalNode;
    CALL(): TerminalNode;
    CASE(): TerminalNode;
    CHANGE(): TerminalNode;
    CIDR(): TerminalNode;
    COLLECT(): TerminalNode;
    COMMAND(): TerminalNode;
    COMMANDS(): TerminalNode;
    COMMIT(): TerminalNode;
    COMPOSITE(): TerminalNode;
    CONCURRENT(): TerminalNode;
    CONSTRAINT(): TerminalNode;
    CONSTRAINTS(): TerminalNode;
    CONTAINS(): TerminalNode;
    CONTINUE(): TerminalNode;
    COPY(): TerminalNode;
    COUNT(): TerminalNode;
    CREATE(): TerminalNode;
    CSV(): TerminalNode;
    CURRENT(): TerminalNode;
    DATA(): TerminalNode;
    DATABASE(): TerminalNode;
    DATABASES(): TerminalNode;
    DATE(): TerminalNode;
    DATETIME(): TerminalNode;
    DBMS(): TerminalNode;
    DEALLOCATE(): TerminalNode;
    DEFAULT(): TerminalNode;
    DEFINED(): TerminalNode;
    DELETE(): TerminalNode;
    DENY(): TerminalNode;
    DESC(): TerminalNode;
    DESCENDING(): TerminalNode;
    DESTROY(): TerminalNode;
    DETACH(): TerminalNode;
    DIFFERENT(): TerminalNode;
    DISTINCT(): TerminalNode;
    DRIVER(): TerminalNode;
    DROP(): TerminalNode;
    DRYRUN(): TerminalNode;
    DUMP(): TerminalNode;
    DURATION(): TerminalNode;
    EACH(): TerminalNode;
    EDGE(): TerminalNode;
    ELEMENT(): TerminalNode;
    ELEMENTS(): TerminalNode;
    ELSE(): TerminalNode;
    ENABLE(): TerminalNode;
    ENCRYPTED(): TerminalNode;
    END(): TerminalNode;
    ENDS(): TerminalNode;
    ERROR(): TerminalNode;
    EXECUTABLE(): TerminalNode;
    EXECUTE(): TerminalNode;
    EXIST(): TerminalNode;
    EXISTENCE(): TerminalNode;
    EXISTS(): TerminalNode;
    FAIL(): TerminalNode;
    FALSE(): TerminalNode;
    FIELDTERMINATOR(): TerminalNode;
    FINISH(): TerminalNode;
    FLOAT(): TerminalNode;
    FOREACH(): TerminalNode;
    FOR(): TerminalNode;
    FROM(): TerminalNode;
    FULLTEXT(): TerminalNode;
    FUNCTION(): TerminalNode;
    FUNCTIONS(): TerminalNode;
    GRANT(): TerminalNode;
    GRAPH(): TerminalNode;
    GRAPHS(): TerminalNode;
    GROUP(): TerminalNode;
    GROUPS(): TerminalNode;
    HEADERS(): TerminalNode;
    HOME(): TerminalNode;
    IF(): TerminalNode;
    IMMUTABLE(): TerminalNode;
    IMPERSONATE(): TerminalNode;
    IN(): TerminalNode;
    INDEX(): TerminalNode;
    INDEXES(): TerminalNode;
    INF(): TerminalNode;
    INFINITY(): TerminalNode;
    INSERT(): TerminalNode;
    INT(): TerminalNode;
    INTEGER(): TerminalNode;
    IS(): TerminalNode;
    JOIN(): TerminalNode;
    KEY(): TerminalNode;
    LABEL(): TerminalNode;
    LABELS(): TerminalNode;
    LEADING(): TerminalNode;
    LIMITROWS(): TerminalNode;
    LIST(): TerminalNode;
    LOAD(): TerminalNode;
    LOCAL(): TerminalNode;
    LOOKUP(): TerminalNode;
    MATCH(): TerminalNode;
    MANAGEMENT(): TerminalNode;
    MAP(): TerminalNode;
    MERGE(): TerminalNode;
    NAME(): TerminalNode;
    NAMES(): TerminalNode;
    NAN(): TerminalNode;
    NEW(): TerminalNode;
    NODE(): TerminalNode;
    NODETACH(): TerminalNode;
    NODES(): TerminalNode;
    NONE(): TerminalNode;
    NORMALIZE(): TerminalNode;
    NOTHING(): TerminalNode;
    NOWAIT(): TerminalNode;
    OF(): TerminalNode;
    ON(): TerminalNode;
    ONLY(): TerminalNode;
    OPTIONAL(): TerminalNode;
    OPTIONS(): TerminalNode;
    OPTION(): TerminalNode;
    OR(): TerminalNode;
    ORDER(): TerminalNode;
    OUTPUT(): TerminalNode;
    PASSWORD(): TerminalNode;
    PASSWORDS(): TerminalNode;
    PATH(): TerminalNode;
    PATHS(): TerminalNode;
    PERIODIC(): TerminalNode;
    PLAINTEXT(): TerminalNode;
    POINT(): TerminalNode;
    POPULATED(): TerminalNode;
    PRIMARY(): TerminalNode;
    PRIMARIES(): TerminalNode;
    PRIVILEGE(): TerminalNode;
    PRIVILEGES(): TerminalNode;
    PROCEDURE(): TerminalNode;
    PROCEDURES(): TerminalNode;
    PROPERTIES(): TerminalNode;
    PROPERTY(): TerminalNode;
    RANGE(): TerminalNode;
    READ(): TerminalNode;
    REALLOCATE(): TerminalNode;
    REDUCE(): TerminalNode;
    REL(): TerminalNode;
    RELATIONSHIP(): TerminalNode;
    RELATIONSHIPS(): TerminalNode;
    REMOVE(): TerminalNode;
    RENAME(): TerminalNode;
    REPEATABLE(): TerminalNode;
    REPLACE(): TerminalNode;
    REPORT(): TerminalNode;
    REQUIRE(): TerminalNode;
    REQUIRED(): TerminalNode;
    RETURN(): TerminalNode;
    REVOKE(): TerminalNode;
    ROLE(): TerminalNode;
    ROLES(): TerminalNode;
    ROW(): TerminalNode;
    ROWS(): TerminalNode;
    SCAN(): TerminalNode;
    SECONDARY(): TerminalNode;
    SECONDARIES(): TerminalNode;
    SEC(): TerminalNode;
    SECOND(): TerminalNode;
    SECONDS(): TerminalNode;
    SEEK(): TerminalNode;
    SERVER(): TerminalNode;
    SERVERS(): TerminalNode;
    SET(): TerminalNode;
    SETTING(): TerminalNode;
    SETTINGS(): TerminalNode;
    SHORTEST(): TerminalNode;
    SHORTEST_PATH(): TerminalNode;
    SHOW(): TerminalNode;
    SIGNED(): TerminalNode;
    SINGLE(): TerminalNode;
    SKIPROWS(): TerminalNode;
    START(): TerminalNode;
    STARTS(): TerminalNode;
    STATUS(): TerminalNode;
    STOP(): TerminalNode;
    VARCHAR(): TerminalNode;
    STRING(): TerminalNode;
    SUPPORTED(): TerminalNode;
    SUSPENDED(): TerminalNode;
    TARGET(): TerminalNode;
    TERMINATE(): TerminalNode;
    TEXT(): TerminalNode;
    THEN(): TerminalNode;
    TIME(): TerminalNode;
    TIMESTAMP(): TerminalNode;
    TIMEZONE(): TerminalNode;
    TO(): TerminalNode;
    TOPOLOGY(): TerminalNode;
    TRAILING(): TerminalNode;
    TRANSACTION(): TerminalNode;
    TRANSACTIONS(): TerminalNode;
    TRAVERSE(): TerminalNode;
    TRIM(): TerminalNode;
    TRUE(): TerminalNode;
    TYPE(): TerminalNode;
    TYPES(): TerminalNode;
    UNION(): TerminalNode;
    UNIQUE(): TerminalNode;
    UNIQUENESS(): TerminalNode;
    UNWIND(): TerminalNode;
    URL(): TerminalNode;
    USE(): TerminalNode;
    USER(): TerminalNode;
    USERS(): TerminalNode;
    USING(): TerminalNode;
    VALUE(): TerminalNode;
    VECTOR(): TerminalNode;
    VERBOSE(): TerminalNode;
    VERTEX(): TerminalNode;
    WAIT(): TerminalNode;
    WHEN(): TerminalNode;
    WHERE(): TerminalNode;
    WITH(): TerminalNode;
    WITHOUT(): TerminalNode;
    WRITE(): TerminalNode;
    XOR(): TerminalNode;
    YIELD(): TerminalNode;
    ZONED(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}
export declare class EndOfFileContext extends ParserRuleContext {
    constructor(parser?: CypherCmdParser, parent?: ParserRuleContext, invokingState?: number);
    EOF(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: CypherCmdParserListener): void;
    exitRule(listener: CypherCmdParserListener): void;
    accept<Result>(visitor: CypherCmdParserVisitor<Result>): Result;
}